UnrealEngine/Plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b6bd971bc85840dda56829c2a00535c0fb0c77de
Plugin/Source/SenseGlove/Private/SenseGlove/GameFramework/SGVirtualHandActor.cpp
T

703 lines
30 KiB
C++
Raw Blame History

/**
* @file
*
* @author Mamadou Babaei <mamadou@senseglove.com>
*
* @section LICENSE
*
* (The MIT License)
*
* Copyright (c) 2020 - 2023 SenseGlove
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* @section DESCRIPTION
*
*
*/
#include "SenseGlove/GameFramework/SGVirtualHandActor.h"
#include "Components/SphereComponent.h"
#include "SenseGlove/Components/SGGrabComponent.h"
#include "SenseGlove/Components/SGTouchComponent.h"
#include "SenseGlove/Components/SGVirtualHandComponent.h"
#include "SenseGlove/Components/SGWristTrackerComponent.h"
struct ASGVirtualHandActor::FImpl
{
/************************
* Owner object
************************/
ASGVirtualHandActor* Owner;
/************************
* Constructor / Destructor
************************/
explicit FImpl(ASGVirtualHandActor* InOwner);
~FImpl();
/************************
* Default copy constructor & copy assignment operator
************************/
FImpl(const FImpl& Rhs) = default;
FImpl& operator=(const FImpl& Rhs) = default;
/************************
* Methods
************************/
void BindFingerGrabOverlapEvents();
void UnbindFingerGrabOverlapEvents();
void BindFingerTouchOverlapEvents();
void UnbindFingerTouchOverlapEvents();
bool IsFingerGrabbing(AActor* Actor) const;
bool IsFingerTouching(AActor* Actor) const;
};
ASGVirtualHandActor::ASGVirtualHandActor(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer),
Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
{
PrimaryActorTick.bCanEverTick = true;
SceneRoot = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
SetRootComponent(SceneRoot);
VirtualHand = CreateDefaultSubobject<USGVirtualHandComponent>(TEXT("VirtualHand"));
VirtualHand->SetupAttachment(RootComponent);
VirtualHand->SetRelativeRotation(FRotator{0.0f, -90.0f, 0.0f},
false, nullptr, ETeleportType::None);
ThumbFingertipGrabCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("ThumbFingertipGrabCollider"));
ThumbFingertipGrabCollider->SetupAttachment(VirtualHand, VirtualHand->GetThumbFingertipGrabSocketName());
ThumbFingertipGrabCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsGrabColliderSize());
ThumbFingertipGrabCollider->SetCastShadow(false);
ThumbFingertipGrabCollider->bCastDynamicShadow = false;
ThumbFingertipGrabCollider->SetReceivesDecals(true);
ThumbFingertipGrabCollider->SetCanEverAffectNavigation(false);
ThumbFingertipGrabCollider->SetCollisionObjectType(ECC_WorldDynamic);
ThumbFingertipGrabCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
ThumbFingertipGrabCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
ThumbFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
IndexFingertipGrabCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("IndexFingertipGrabCollider"));
IndexFingertipGrabCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsGrabColliderSize());
IndexFingertipGrabCollider->SetupAttachment(VirtualHand, VirtualHand->GetIndexFingertipGrabSocketName());
IndexFingertipGrabCollider->SetCastShadow(false);
IndexFingertipGrabCollider->bCastDynamicShadow = false;
IndexFingertipGrabCollider->SetReceivesDecals(true);
IndexFingertipGrabCollider->SetCanEverAffectNavigation(false);
IndexFingertipGrabCollider->SetCollisionObjectType(ECC_WorldDynamic);
IndexFingertipGrabCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
IndexFingertipGrabCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
IndexFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
MiddleFingertipGrabCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("MiddleFingertipGrabCollider"));
MiddleFingertipGrabCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsGrabColliderSize());
MiddleFingertipGrabCollider->SetupAttachment(VirtualHand, VirtualHand->GetMiddleFingertipGrabSocketName());
MiddleFingertipGrabCollider->SetCastShadow(false);
MiddleFingertipGrabCollider->bCastDynamicShadow = false;
MiddleFingertipGrabCollider->SetReceivesDecals(true);
MiddleFingertipGrabCollider->SetCanEverAffectNavigation(false);
MiddleFingertipGrabCollider->SetCollisionObjectType(ECC_WorldDynamic);
MiddleFingertipGrabCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
MiddleFingertipGrabCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
MiddleFingertipGrabCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
ThumbFingertipTouchCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("ThumbFingertipTouchCollider"));
ThumbFingertipTouchCollider->SetupAttachment(VirtualHand, VirtualHand->GetThumbFingertipTouchSocketName());
ThumbFingertipTouchCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsTouchColliderSize());
ThumbFingertipTouchCollider->SetCastShadow(false);
ThumbFingertipTouchCollider->bCastDynamicShadow = false;
ThumbFingertipTouchCollider->SetReceivesDecals(true);
ThumbFingertipTouchCollider->SetCanEverAffectNavigation(false);
ThumbFingertipTouchCollider->SetCollisionObjectType(ECC_WorldDynamic);
ThumbFingertipTouchCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
ThumbFingertipTouchCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
ThumbFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
IndexFingertipTouchCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("IndexFingertipTouchCollider"));
IndexFingertipTouchCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsTouchColliderSize());
IndexFingertipTouchCollider->SetupAttachment(VirtualHand, VirtualHand->GetIndexFingertipTouchSocketName());
IndexFingertipTouchCollider->SetCastShadow(false);
IndexFingertipTouchCollider->bCastDynamicShadow = false;
IndexFingertipTouchCollider->SetReceivesDecals(true);
IndexFingertipTouchCollider->SetCanEverAffectNavigation(false);
IndexFingertipTouchCollider->SetCollisionObjectType(ECC_WorldDynamic);
IndexFingertipTouchCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
IndexFingertipTouchCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
IndexFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
MiddleFingertipTouchCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("MiddleFingertipTouchCollider"));
MiddleFingertipTouchCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsTouchColliderSize());
MiddleFingertipTouchCollider->SetupAttachment(VirtualHand, VirtualHand->GetMiddleFingertipTouchSocketName());
MiddleFingertipTouchCollider->SetCastShadow(false);
MiddleFingertipTouchCollider->bCastDynamicShadow = false;
MiddleFingertipTouchCollider->SetReceivesDecals(true);
MiddleFingertipTouchCollider->SetCanEverAffectNavigation(false);
MiddleFingertipTouchCollider->SetCollisionObjectType(ECC_WorldDynamic);
MiddleFingertipTouchCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
MiddleFingertipTouchCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
MiddleFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
RingFingertipTouchCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("RingFingertipTouchCollider"));
RingFingertipTouchCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsTouchColliderSize());
RingFingertipTouchCollider->SetupAttachment(VirtualHand, VirtualHand->GetRingFingertipTouchSocketName());
RingFingertipTouchCollider->SetCastShadow(false);
RingFingertipTouchCollider->bCastDynamicShadow = false;
RingFingertipTouchCollider->SetReceivesDecals(true);
RingFingertipTouchCollider->SetCanEverAffectNavigation(false);
RingFingertipTouchCollider->SetCollisionObjectType(ECC_WorldDynamic);
RingFingertipTouchCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
RingFingertipTouchCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
RingFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
PinkyFingertipTouchCollider = ObjectInitializer.CreateDefaultSubobject<USphereComponent>(
this, TEXT("PinkyFingertipTouchCollider"));
PinkyFingertipTouchCollider->SetRelativeScale3D(VirtualHand->GetDefaultFingertipsTouchColliderSize());
PinkyFingertipTouchCollider->SetupAttachment(VirtualHand, VirtualHand->GetPinkyFingertipTouchSocketName());
PinkyFingertipTouchCollider->SetCastShadow(false);
PinkyFingertipTouchCollider->bCastDynamicShadow = false;
PinkyFingertipTouchCollider->SetReceivesDecals(true);
PinkyFingertipTouchCollider->SetCanEverAffectNavigation(false);
PinkyFingertipTouchCollider->SetCollisionObjectType(ECC_WorldDynamic);
PinkyFingertipTouchCollider->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
PinkyFingertipTouchCollider->SetCollisionResponseToAllChannels(ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldStatic, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_WorldDynamic, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Pawn, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Visibility, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_PhysicsBody, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Vehicle, ECR_Overlap);
PinkyFingertipTouchCollider->SetCollisionResponseToChannel(ECC_Destructible, ECR_Overlap);
WristTracker = CreateDefaultSubobject<USGWristTrackerComponent>(TEXT("WristTracker"));
WristTracker->SetupAttachment(RootComponent);
WristTracker->SetRight(VirtualHand->IsRight());
GrabState = FSGGrabState(VirtualHand, nullptr, nullptr, nullptr, nullptr);
TouchState = FSGTouchState(VirtualHand, nullptr, nullptr, nullptr, nullptr, nullptr);
}
void ASGVirtualHandActor::BeginPlay()
{
Super::BeginPlay();
ensureAlwaysMsgf(
(WristTracker->IsLeft() && VirtualHand->IsLeft())
|| (WristTracker->IsRight() && VirtualHand->IsRight()),
TEXT("The virtual hand component and the wrist tracker component do not track the same hand!"));
WristTracker->OnWristLocationChanged().AddWeakLambda(this, [&](const FVector& Location)-> void
{
VirtualHand->SetWorldLocation(Location);
});
WristTracker->OnWristRotationChanged().AddWeakLambda(this, [&](const FRotator& Rotation)-> void
{
VirtualHand->SetWorldRotation(Rotation);
});
Pimpl->BindFingerGrabOverlapEvents();
Pimpl->BindFingerTouchOverlapEvents();
}
void ASGVirtualHandActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);
Pimpl->UnbindFingerGrabOverlapEvents();
Pimpl->UnbindFingerTouchOverlapEvents();
}
void ASGVirtualHandActor::PreInitializeComponents()
{
Super::PreInitializeComponents();
WristTracker->SetRight(VirtualHand->IsRight());
}
void ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGGrabComponent::IsGrabbable(OtherActor))
{
GrabState.ActorThumbCanGrab = OtherActor;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
if (GrabState.ActorThumbCanGrab == OtherActor)
{
GrabState.ActorThumbCanGrab = nullptr;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGGrabComponent::IsGrabbable(OtherActor))
{
GrabState.ActorIndexCanGrab = OtherActor;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
if (GrabState.ActorIndexCanGrab == OtherActor)
{
GrabState.ActorIndexCanGrab = nullptr;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGGrabComponent::IsGrabbable(OtherActor))
{
GrabState.ActorMiddleCanGrab = OtherActor;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherBodyIndex;
if (GrabState.ActorMiddleCanGrab == OtherActor)
{
GrabState.ActorMiddleCanGrab = nullptr;
GrabStateUpdatedEvent.Broadcast(GrabState);
}
}
void ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGTouchComponent::IsTouchable(OtherActor))
{
TouchState.ActorThumbTouching = OtherActor;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
if (TouchState.ActorThumbTouching == OtherActor)
{
TouchState.ActorThumbTouching = nullptr;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGTouchComponent::IsTouchable(OtherActor))
{
TouchState.ActorIndexTouching = OtherActor;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
if (TouchState.ActorIndexTouching == OtherActor)
{
TouchState.ActorIndexTouching = nullptr;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
(void) bFromSweep;
(void) SweepResult;
if (USGTouchComponent::IsTouchable(OtherActor))
{
TouchState.ActorMiddleTouching = OtherActor;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
if (TouchState.ActorMiddleTouching == OtherActor)
{
TouchState.ActorMiddleTouching = nullptr;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
if (USGTouchComponent::IsTouchable(OtherActor))
{
TouchState.ActorRingTouching = OtherActor;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
if (TouchState.ActorRingTouching == OtherActor)
{
TouchState.ActorRingTouching = nullptr;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapBegins(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex,
const bool bFromSweep,
const FHitResult& SweepResult)
{
if (USGTouchComponent::IsTouchable(OtherActor))
{
TouchState.ActorPinkyTouching = OtherActor;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
void ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapEnds(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
const int32 OtherBodyIndex)
{
(void) OverlappedComponent;
(void) OtherComp;
(void) OtherBodyIndex;
if (TouchState.ActorPinkyTouching == OtherActor)
{
TouchState.ActorPinkyTouching = nullptr;
TouchStateUpdatedEvent.Broadcast(TouchState);
}
}
bool ASGVirtualHandActor::IsLeft() const
{
return WristTracker->IsLeft() && VirtualHand->IsLeft();
}
bool ASGVirtualHandActor::IsRight() const
{
return WristTracker->IsRight() && VirtualHand->IsRight();
}
void ASGVirtualHandActor::SetRight(const bool bRight)
{
WristTracker->SetRight(bRight);
VirtualHand->SetRight(bRight);
}
bool ASGVirtualHandActor::IsGloveConnected() const
{
return VirtualHand->IsGloveConnected();
}
ASGVirtualHandActor::FImpl::FImpl(ASGVirtualHandActor* InOwner)
: Owner(InOwner)
{
}
void ASGVirtualHandActor::FImpl::BindFingerGrabOverlapEvents()
{
Owner->ThumbFingertipGrabCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapBegins);
Owner->ThumbFingertipGrabCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapEnds);
Owner->IndexFingertipGrabCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapBegins);
Owner->IndexFingertipGrabCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapEnds);
Owner->MiddleFingertipGrabCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapBegins);
Owner->MiddleFingertipGrabCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapEnds);
}
void ASGVirtualHandActor::FImpl::UnbindFingerGrabOverlapEvents()
{
Owner->ThumbFingertipGrabCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapBegins);
Owner->ThumbFingertipGrabCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipGrabColliderOverlapEnds);
Owner->IndexFingertipGrabCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapBegins);
Owner->IndexFingertipGrabCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipGrabColliderOverlapEnds);
Owner->MiddleFingertipGrabCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapBegins);
Owner->MiddleFingertipGrabCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipGrabColliderOverlapEnds);
}
void ASGVirtualHandActor::FImpl::BindFingerTouchOverlapEvents()
{
Owner->ThumbFingertipTouchCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapBegins);
Owner->ThumbFingertipTouchCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapEnds);
Owner->IndexFingertipTouchCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapBegins);
Owner->IndexFingertipTouchCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapEnds);
Owner->MiddleFingertipTouchCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapBegins);
Owner->MiddleFingertipTouchCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapEnds);
Owner->RingFingertipTouchCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapBegins);
Owner->RingFingertipTouchCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapEnds);
Owner->PinkyFingertipTouchCollider->OnComponentBeginOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapBegins);
Owner->PinkyFingertipTouchCollider->OnComponentEndOverlap.AddDynamic(
Owner, &ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapEnds);
}
void ASGVirtualHandActor::FImpl::UnbindFingerTouchOverlapEvents()
{
Owner->ThumbFingertipTouchCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapBegins);
Owner->ThumbFingertipTouchCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnThumbFingertipTouchColliderOverlapEnds);
Owner->IndexFingertipTouchCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapBegins);
Owner->IndexFingertipTouchCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnIndexFingertipTouchColliderOverlapEnds);
Owner->MiddleFingertipTouchCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapBegins);
Owner->MiddleFingertipTouchCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnMiddleFingertipTouchColliderOverlapEnds);
Owner->RingFingertipTouchCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapBegins);
Owner->RingFingertipTouchCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnRingFingertipTouchColliderOverlapEnds);
Owner->PinkyFingertipTouchCollider->OnComponentBeginOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapBegins);
Owner->PinkyFingertipTouchCollider->OnComponentEndOverlap.RemoveDynamic(
Owner, &ASGVirtualHandActor::OnPinkyFingertipTouchColliderOverlapEnds);
}
ASGVirtualHandActor::FImpl::~FImpl() = default;
void ASGVirtualHandActor::FImplDeleter::operator()(const FImpl* P) const
{
delete P;
}
Reference in New Issue View Git Blame Copy Permalink