PixoVRHand.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
#include "PixoVRHand.h"
#include "GripMotionControllerComponent.h"
#include "PixoVRCharacter.h"
#include "Interfaces/HandAnimationInterface.h"
#include "Interfaces/PixoVRInteractiveObject.h"
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetMathLibrary.h"
#include "Kismet/KismetSystemLibrary.h"
 
// Sets default values
APixoVRHand::APixoVRHand()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
 
    Root = CreateDefaultSubobject<USceneComponent>("Root");
    Root->SetupAttachment(RootComponent);
 
    MotionController = CreateDefaultSubobject<UGripMotionControllerComponent>("MotionController");
    if (MotionController)
    {
        MotionController->SetupAttachment(Root);
        MotionController->SetGenerateOverlapEvents(false);
        MotionController->SetRelativeLocation(FVector(65.0f, -43.25f, -11.51f));
        MotionController->OnGripOutOfRange.AddDynamic(this, &APixoVRHand::OnObjectOutOfRange);
    }
 
    GrabSphere = CreateDefaultSubobject<USphereComponent>("GrabSphere");
    GrabSphere->SetupAttachment(MotionController);
    GrabSphere->SetCollisionProfileName("OverlapAll");
    GrabSphere->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    GrabSphere->SetVisibility(true, true);
    GrabSphere->SetHiddenInGame(false, true);
    GrabSphere->SetSphereRadius(4.0f);
    GrabSphere->SetRelativeLocation(FVector(2.0f, 0.0f, -2.5f));
    GrabSphere->SetIsReplicated(true);
 
    HandMesh = CreateDefaultSubobject<USkeletalMeshComponent>("HandMesh");
    HandMesh->SetupAttachment(MotionController);
 
    LaserMesh = CreateDefaultSubobject<UStaticMeshComponent>("Laser");
    LaserMesh->SetupAttachment(HandMesh, "LaserSocket");
    static ConstructorHelpers::FObjectFinder<UStaticMesh> LaserMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/Tools/SM_LaserPointer.SM_LaserPointer'"));
    LaserMesh->SetStaticMesh(LaserMeshFinder.Object);
    LaserMesh->SetVisibility(false);
 
    static ConstructorHelpers::FObjectFinder<USoundCue> LaserSoundFinder(TEXT("SoundCue'/PixoCore/Audio/SFX/LaserToggle_Cue.LaserToggle_Cue'"));
    LaserSound = NewObject<USoundCue>();
    LaserSound = LaserSoundFinder.Object;
 
    TouchComponent = CreateDefaultSubobject<UWidgetInteractionComponent>("TouchComponent");
    TouchComponent->SetupAttachment(HandMesh, "TouchIntr");
    TouchComponent->SetRelativeLocation(FVector(6.8, -1.3, 0));
    TouchComponent->SetRelativeRotation(FRotator(0.0,170.0, 0.0));
    TouchComponent->TraceChannel = ECollisionChannel::ECC_Visibility;
    TouchComponent->InteractionDistance = 10.0;
    TouchComponent->bEnableHitTesting = true;
    TouchComponent->OnHoveredWidgetChanged.AddDynamic(this, &APixoVRHand::OnTouchWidget);
    TouchComponent->SetAutoActivate(false);
 
    WristMenu = CreateDefaultSubobject<UChildActorComponent>("WristMenu");
    WristMenu->SetupAttachment(MotionController);
 
    //Right now it's implemented in blueprint class
    /*ThumbSpline = CreateDefaultSubobject<USplineComponent>("ThumbSpline");
    ThumbSpline->SetupAttachment(HandMesh);
    IndexSpline = CreateDefaultSubobject<USplineComponent>("IndexSpline");
    IndexSpline->SetupAttachment(HandMesh);
    MiddleSpline = CreateDefaultSubobject<USplineComponent>("MiddleSpline");
    MiddleSpline->SetupAttachment(HandMesh);
    RingSpline = CreateDefaultSubobject<USplineComponent>("RingSpline");
    RingSpline->SetupAttachment(HandMesh);
    PinkySpline = CreateDefaultSubobject<USplineComponent>("PinkySpline");
    PinkySpline->SetupAttachment(HandMesh);*/
}
 
void APixoVRHand::OnObjectOutOfRange(const FBPActorGripInformation& GripInformation, float Distance)
{
    ReleaseObject();
 
    APixoVRCharacter* PlayerRef = Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0));
    if (PlayerRef)
    {
        if (HandMotionSource == EControllerHand::Right)
        {
            PlayerRef->HoldToolRight = false;
        }
        else
        {
            PlayerRef->HoldToolLeft = false;
        }
    }
}
 
void APixoVRHand::GrabObject()
{
    FOverlappingInfo OverlappingInfo;
    GetOverlappingActor(OverlappingInfo);
    if (!OverlappingInfo.OverlapActor)
    {
        return;
    }
 
    FTransform ActorWorldTransformInHand; // World transform for actor to snap to and move relative to hand
    if (OverlappingInfo.OverlapActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
        ActorWorldTransformInHand = IPixoVRStoryObject::Execute_GetObjectGrabTransform(OverlappingInfo.OverlapActor, this);
    else
        ActorWorldTransformInHand = OverlappingInfo.OverlapActor->GetTransform();
 
    if (OverlappingInfo.OverlapComponent == nullptr)
    {
        if (OverlappingInfo.OverlapActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass())
            && IPixoVRStoryObject::Execute_IsGrabbingWrongActorActive(OverlappingInfo.OverlapActor)
            && (!IPixoVRStoryObject::Execute_IsObjectActive(OverlappingInfo.OverlapActor) || IVRGripInterface::Execute_DenyGripping(OverlappingInfo.OverlapActor, MotionController)))
        {
            IPixoVRStoryObject::Execute_SendWrongGrabbingNotification(OverlappingInfo.OverlapActor);
            return;
        }
 
        if (OverlappingInfo.OverlapActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()) && IPixoVRStoryObject::Execute_CouldBeGrabbedByOtherHand(OverlappingInfo.OverlapActor))
            ReleaseHeldObjectOnOtherHand(OverlappingInfo.OverlapActor);
        
        if (MotionController->GripObjectByInterface(OverlappingInfo.OverlapActor, ActorWorldTransformInHand))
            HandHoldingObject = OverlappingInfo.OverlapActor;
    }
    else
    {
        MotionController->GripObjectByInterface(OverlappingInfo.OverlapComponent, ActorWorldTransformInHand);
        HandHoldingObject = OverlappingInfo.OverlapComponent;
    }
    //Do we need this ???
    //ClientSetHoldingActor(HandHoldingObject, EControllerHand::Left);
    UpdateFingerData();
}
 
void APixoVRHand::ReleaseObject()
{
    UObject* ObjectToDrop = HandHoldingObject;
    HandHoldingObject = nullptr;
    MotionController->DropObjectByInterface(ObjectToDrop);
 
    //Do we need this ???
    //ClientReleaseHoldingActor(EControllerHand::Left);
 
    FingerData.Index = 0.0;
    FingerData.Middle = 0.0;
    FingerData.Pinky = 0.0;
    FingerData.Ring = 0.0;
    FingerData.Thumb = 0.0;
}
 
void APixoVRHand::ManuallyPutActorToHand(AActor* ActorRef)
{
    if (ActorRef)
    {
        FTransform ActorWorldTransformInHand; // World transform for actor to snap to and move relative to hand
        if (ActorRef->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
            ActorWorldTransformInHand = IPixoVRStoryObject::Execute_GetObjectGrabTransform(ActorRef, this);
        else
            ActorWorldTransformInHand = ActorRef->GetTransform();
        
        if (MotionController->GripObjectByInterface(ActorRef, ActorWorldTransformInHand))
            GetWorldTimerManager().SetTimerForNextTick([this, ActorRef](){HandHoldingObject = ActorRef;});
    }
    UpdateFingerData();
}
 
void APixoVRHand::OnTouchWidget(UWidgetComponent* WidgetComponent, UWidgetComponent* PreviousWidgetComponent)
{
    if (WidgetComponent && WidgetComponent->GetUserWidgetObject() && !TouchComponentCooldownActive)
    {
        TouchComponent->PressPointerKey("LeftMouseButton");
        TouchComponentCooldownActive = true;
        FTimerHandle TimerHandle;
        GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &APixoVRHand::DeactivateTouchCooldown, 0.2);
    }
}
 
void APixoVRHand::DeactivateTouchCooldown()
{
    TouchComponent->ReleasePointerKey("LeftMouseButton");
    TouchComponentCooldownActive = false;
}
 
void APixoVRHand::ReleaseHeldObjectOnOtherHand(AActor* HeldActor)
{
    if (!HeldActor)
    {
        UE_LOG(LogTemp, Error, TEXT("PixoVrHand - ReleaseHeldedObjectOnOtherHand - Actor reference is invalid"));
        return;
    }
    TArray<FBPGripPair> HoldingControllers;
    bool IsHeld;
    IVRGripInterface::Execute_IsHeld(HeldActor, HoldingControllers, IsHeld);
    if (IsHeld)
    {
        APixoVRCharacter* PlayerRef = Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0));
        APixoVRHand* HandHoldingItem = HandMotionSource == EControllerHand::Right ? PlayerRef->VRHandLeft : PlayerRef->VRHandRight;
        APixoVRHand* HandHGrabbingItem = HandMotionSource == EControllerHand::Left ? PlayerRef->VRHandLeft : PlayerRef->VRHandRight;
 
        PlayerRef->HoldToolLeft = false;
        PlayerRef->HoldToolRight = false;
 
        HandHGrabbingItem->ReleaseObject();
 
        if (HandHGrabbingItem->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(HandHGrabbingItem->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        }
 
        HandHoldingItem->ReleaseObject();
 
        // let hand holding item animate to the open pose on release of object
        if (HandHoldingItem->HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
        {
            IHandAnimationInterface::Execute_SetAnimationGripState(HandHoldingItem->HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
        }
    }
}
 
void APixoVRHand::ToggleLaser(bool Visible)
{
    LaserMesh->SetVisibility(Visible);
 
    UGameplayStatics::PlaySound2D(this, LaserSound);
}
 
TArray<FVector> APixoVRHand::GetRelativePointsArray(USplineComponent* FingerSpline, float Precision)
{
    if (Precision <= 0)
    {
        UE_LOG(LogTemp, Error, TEXT("Grab precision can not be less then 1"));
        return TArray<FVector>();
    }
    if (FingerSpline)
    {
        float stepSize = FingerSpline->Duration / Precision;
        TArray<FVector> relativePointsArray;
        for (int i = 0; i < Precision - 1; i++)
        {
            float splineTime = UKismetMathLibrary::FClamp(i * stepSize, 0.0, 1.0);
            relativePointsArray.Add(UKismetMathLibrary::TransformLocation(
                FingerSpline->GetRelativeTransform(),
                FingerSpline->GetLocationAtTime(splineTime, ESplineCoordinateSpace::Local, true)));
        }
        return relativePointsArray;
    }
    UE_LOG(LogTemp, Error, TEXT("Spline reference is not valid"));
    return TArray<FVector>();
}
 
float APixoVRHand::TraceFingerForObstacle(TArray<FVector> RelativePointsArray)
{
    FVector splinePointLocation;
    FVector nextSplinePointLocation;
    float hitLenght = 0;
    float totalLenght = 0;
    bool didHit = false;
    FHitResult hitResult;
    TArray<TEnumAsByte<EObjectTypeQuery>> traceObjectTypes;
    traceObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldStatic));
    traceObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldDynamic));
    traceObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_PhysicsBody));
    FCollisionQueryParams queryParams;
    queryParams.AddIgnoredActor(this);
 
    for (int i = 0; i < RelativePointsArray.Num() - 2; i++)
    {
        splinePointLocation = UKismetMathLibrary::TransformLocation(HandMesh->GetComponentTransform(),
                                                                    RelativePointsArray[i]);
        nextSplinePointLocation = UKismetMathLibrary::TransformLocation(HandMesh->GetComponentTransform(),
                                                                        RelativePointsArray[i + 1]);
 
        //Trace grabbed Component for Finger Positioning
        if (!didHit)
        {
            bool didTraceHit = GetWorld()->LineTraceSingleByObjectType(hitResult, splinePointLocation,
                                                                       nextSplinePointLocation, traceObjectTypes,
                                                                       queryParams);
            if (didTraceHit)
            {
                didHit = true;
                hitLenght = totalLenght + hitResult.Distance;
            }
        }
        //Calculate Total Length of the Trace and update Hit Length if necessary
        totalLenght = totalLenght + UKismetMathLibrary::Vector_Distance(splinePointLocation, nextSplinePointLocation);
        if (!didHit)
        {
            hitLenght = totalLenght;
        }
    }
    return UKismetMathLibrary::FClamp(hitLenght / totalLenght, 0.0, 1.0);
}
 
void APixoVRHand::SetupFingerTracePoints()
{
    float precision = 30.0;
    ThumbPositionCache = GetRelativePointsArray(ThumbSpline, precision);
    IndexPositionCache = GetRelativePointsArray(IndexSpline, precision);
    MiddlePositionCache = GetRelativePointsArray(MiddleSpline, precision);
    RingPositionCache = GetRelativePointsArray(RingSpline, precision);
    PinkyPositionCache = GetRelativePointsArray(PinkySpline, precision);
}
 
void APixoVRHand::UpdateFingerData()
{
    FingerData.Index = TraceFingerForObstacle(IndexPositionCache);
    FingerData.Middle = TraceFingerForObstacle(MiddlePositionCache);
    FingerData.Pinky = TraceFingerForObstacle(PinkyPositionCache);
    FingerData.Ring = TraceFingerForObstacle(RingPositionCache);
    FingerData.Thumb = TraceFingerForObstacle(ThumbPositionCache);
}
 
// Called when the game starts or when spawned
void APixoVRHand::BeginPlay()
{
    Super::BeginPlay();
 
    //Can be used when init of splines would be in c++
    //SetupFingerTracePoints();
    SetWristMenuEnabled(IsWristMenuEnabled);
}
 
void APixoVRHand::SetWristMenuEnabled(bool Enabled)
{
    IsWristMenuEnabled = Enabled;
    WristMenu->SetVisibility(Enabled);
}
 
// Called every frame
void APixoVRHand::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    auto IsObjectHasGripType = [](const FOverlappingInfo &OverlapInfo, const EGrippableTypeChecker &GripTypeChecker)->bool
    {
        switch (GripTypeChecker)
        {
        case EGrippableTypeChecker::Default:
            return true;
        case EGrippableTypeChecker::StoryActive:
            if (OverlapInfo.OverlapActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
            {
                return IPixoVRStoryObject::Execute_IsObjectActive(OverlapInfo.OverlapActor)
                    || IPixoVRStoryObject::Execute_IsGrabbingWrongActorActive(OverlapInfo.OverlapActor);
            }
 
            return false;
        case EGrippableTypeChecker::StoryObject:
            return OverlapInfo.OverlapActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass());
        case EGrippableTypeChecker::VRGrip:
            return OverlapInfo.OverlapActor->GetClass()->ImplementsInterface(UVRGripInterface::StaticClass());
        default:
            return false;
        }
    };
 
    // Activation logic when hand approaches to interactable object hand animation changing and object is highlighting
    if (ChangeHandAnimationNearInteractableObject)
    {
        if (HandHoldingObject == nullptr)
        {
            FOverlappingInfo OverlapInfo;
            GetOverlappingActor(OverlapInfo);
            if (OverlapInfo.OverlapActor)
            {
                if (OverlapedActor != OverlapInfo.OverlapActor)
                {
                    InteractableObjectNearHand = false;
                    IHandAnimationInterface::Execute_SetAnimationGripState(HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
                    if (IsObjectHighlightActive && OverlapedActor)
                    {
                        if (OverlapedActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
                        {
                            IPixoVRStoryObject::Execute_UpdateObjectHighlight(OverlapedActor, false);
                        }
                    }
                }
                if (IsObjectHasGripType(OverlapInfo, GrippableTypeChecker) && !InteractableObjectNearHand)
                {
                    IHandAnimationInterface::Execute_SetAnimationGripState(HandMesh->GetAnimInstance(), EPixoVRGripState::CanGrab);
                    InteractableObjectNearHand = true;
                    OverlapedActor = OverlapInfo.OverlapActor;
                    if (IsObjectHighlightActive)
                    {
                        if (OverlapedActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
                        {
                            IPixoVRStoryObject::Execute_UpdateObjectHighlight(OverlapedActor, true);
                        }
                    }
                }
            }
            else
            {
                if (InteractableObjectNearHand)
                {
                    IHandAnimationInterface::Execute_SetAnimationGripState(HandMesh->GetAnimInstance(), EPixoVRGripState::Open);
                    InteractableObjectNearHand = false;
                    if (IsObjectHighlightActive && OverlapedActor)
                    {
                        if (OverlapedActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
                        {
                            IPixoVRStoryObject::Execute_UpdateObjectHighlight(OverlapedActor, false);
                        }
                    }
                }
            }
        }
        else if (IsObjectHighlightActive && OverlapedActor)
        {
            if (OverlapedActor->GetClass()->ImplementsInterface(UPixoVRStoryObject::StaticClass()))
            {
                IPixoVRStoryObject::Execute_UpdateObjectHighlight(OverlapedActor, false);
            }
 
            OverlapedActor = nullptr;
        }
    }
}
 
void APixoVRHand::InitPixoVRHands(EControllerHand MotionSource, APixoVRCharacter* Character)
{
    OwningCharacter = Character;
 
    HandMotionSource = MotionSource;
    switch (MotionSource)
    {
    case EControllerHand::Left:
        MotionController->SetTrackingMotionSource(FXRMotionControllerBase::LeftHandSourceId);
        HandMesh->SetRelativeScale3D(FVector(1.0, 1.0, -1.0));
        GrabSphere->SetRelativeLocation(GrabSphere->GetRelativeLocation() * FVector(1.f, -1.f, 1.f));
        TouchComponent->PointerIndex = 0;
        break;
    case EControllerHand::Right:
        MotionController->SetTrackingMotionSource(FXRMotionControllerBase::RightHandSourceId);
        TouchComponent->PointerIndex = 1;
        break;
    default:
        UE_LOG(LogTemp, Error, TEXT("Hand motion source is undefined!"));
        break;
    }
 
    MotionController->bOffsetByHMD = false;
    // Keep the controllers ticking after movement
    /*MotionController->AddTickPrerequisiteComponent(OwningCharacter->GetCharacterMovement());
    MotionController->OverrideSendTransform = &AVRBaseCharacter::Server_SendTransformLeftController;*/
 
    if (HandMesh->GetAnimInstance()->GetClass()->ImplementsInterface(UHandAnimationInterface::StaticClass()))
    {
        IHandAnimationInterface::Execute_SetHandActor(HandMesh->GetAnimInstance(), this);
    }
    else
        UE_LOG(LogTemp, Error, TEXT("Animation blueprint does not implement PixoVRGripInterface"));
}
 
void APixoVRHand::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(APixoVRHand, HandHoldingObject);
    DOREPLIFETIME(APixoVRHand, FingerData);
}
 
void APixoVRHand::GetOverlappingActor(FOverlappingInfo& OverlappingInfo)
{
    // If we hold already something on this hand, don't check for anything else.
    if (HandHoldingObject != nullptr)
    {
        return;
    }
 
    TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes;
    ObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldDynamic));
    ObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_PhysicsBody));
    ObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldStatic));
    auto TraceComplex = false;
    TArray<AActor*> ActorsToIgnore;
    auto IgnoreSelf = true;
    TArray<FHitResult> HitResults;
 
    // TODO Because 4.22 has issues (returning always false) when Start and End vector are the same
    // an offset is used.
    bool Hit = UKismetSystemLibrary::SphereTraceMultiForObjects(GetWorld(),
                                                                GrabSphere->GetComponentLocation(),
                                                                GrabSphere->GetComponentLocation() + (GrabSphere->
                                                                    GetForwardVector() * 0.01),
                                                                GrabSphere->GetUnscaledSphereRadius(),
                                                                ObjectTypes,
                                                                TraceComplex,
                                                                ActorsToIgnore,
                                                                EDrawDebugTrace::None,
                                                                HitResults,
                                                                IgnoreSelf);
 
    
    if (Hit)
    {
        for (const auto& HitResult : HitResults)
        {
            // Does the actor support our grip interface?
            if (HitResult.Actor->GetClass()->ImplementsInterface(UVRGripInterface::StaticClass()))
            {
                OverlappingInfo.OverlapActor = HitResult.Actor.Get();
 
                if (HitResult.Component->GetClass()->ImplementsInterface(UVRGripInterface::StaticClass()))
                {
                    OverlappingInfo.OverlapComponent = HitResult.Component.Get();
                }
 
                // Do we have a collision with a socket?
                if (HitResult.BoneName != NAME_None)
                {
                    OverlappingInfo.Socket = HitResult.BoneName;
                }
 
                if (OverlappingInfo.OverlapActor && !IVRGripInterface::Execute_DenyGripping(OverlappingInfo.OverlapActor,MotionController))
                {
                    break;
                }
            }
        }
    }
}