BaseGrippableStoryActor.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
 
#include "InteractableObjects/BaseGrippableStoryActor.h"
 
#include "PixoVRPlayerController.h"
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetMathLibrary.h"
#include "Managers/GameManager.h"
 
ABaseGrippableStoryActor::ABaseGrippableStoryActor()
    : Super()
{
    StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>("StaticMeshComponent");
    SetRootComponent(StaticMeshComponent);
    
    VRGripInterfaceSettings.bDenyGripping = false;
    VRGripInterfaceSettings.OnTeleportBehavior = EGripInterfaceTeleportBehavior::TeleportAllComponents;
    VRGripInterfaceSettings.bSimulateOnDrop = true;
    VRGripInterfaceSettings.SecondaryGripType = ESecondaryGripType::SG_None;
    VRGripInterfaceSettings.MovementReplicationType = EGripMovementReplicationSettings::ForceClientSideMovement;
    VRGripInterfaceSettings.LateUpdateSetting = EGripLateUpdateSettings::NotWhenCollidingOrDoubleGripping;
    VRGripInterfaceSettings.ConstraintStiffness = 1500.0f;
    VRGripInterfaceSettings.ConstraintDamping = 200.0f;
    VRGripInterfaceSettings.ConstraintBreakDistance = 100.0f;
    VRGripInterfaceSettings.SecondarySlotRange = 20.0f;
    VRGripInterfaceSettings.PrimarySlotRange = 20.0f;
    VRGripInterfaceSettings.bIsHeld = false;
 
    HandGripLogic = EHandGripLogic::AttachToHand;
 
    bFeedbackEnabled = false;
    HapticDuration = 0.5f;
    HapticStrength = 0.5f;
 
    bGripSoundsEnabled = false;
    bReleaseSoundsEnabled = false;
 
    //Bind gripping events for using in the blueprints
    OnGripped.AddDynamic(this, &ABaseGrippableStoryActor::OnGrippedEvent);
    OnDropped.AddDynamic(this, &ABaseGrippableStoryActor::OnReleasedEvent);
}
 
void ABaseGrippableStoryActor::BeginPlay()
{
    Super::BeginPlay();
    UpdateHandGripLogic(HandGripLogic);
}
 
void ABaseGrippableStoryActor::StartPositionResetTimer()
{
    TimeSinceResetTimerStarted = 0.0f;
    GetWorld()->GetTimerManager().SetTimer(PositionResetTimer, this, &ABaseGrippableStoryActor::CheckPositionResetConditions, PositionResetCheckRate, true);
}
 
void ABaseGrippableStoryActor::StopPositionResetTimer()
{
    GetWorld()->GetTimerManager().ClearTimer(PositionResetTimer);
}
 
void ABaseGrippableStoryActor::ResetPosition()
{
    if (!bCanResetPosition)
        return;
 
    if (bDestroyActorAfterFailedDrop)
    {
        OnDroppedActorDeleted.Broadcast(GetClass());
        
        Destroy();
    }
    else
    {
        bSaveResetTransformOnGrip = true;
        StaticMeshComponent->SetSimulatePhysics(false);
        
        SetActorTransform(ResetTransform);
        OnActorPositionResetDelegate.Broadcast(this);
    }
}
 
void ABaseGrippableStoryActor::CheckPositionResetConditions()
{
    TimeSinceResetTimerStarted += PositionResetCheckRate;
    
    if (FMath::IsNearlyEqual(GetVelocity().Size(), 0.0f) || TimeSinceResetTimerStarted >= PositionResetMaximumDelay)
    {
        StopPositionResetTimer();
        OnActorStoppedDelegate.Broadcast(this);
        
        if (bActivateLocationResetAfterDrop)
        {
            ResetPosition();
        }
    }
}
 
bool ABaseGrippableStoryActor::IsGrabbingWrongActorActive_Implementation()
{
    return Story && Story->GameManager && Story->GameManager->bWrongInteractableActorGrabEnabled;
}
 
void ABaseGrippableStoryActor::SendWrongGrabbingNotification_Implementation()
{
    if (Story && Story->GameManager)
    {
        Story->GameManager->OnWrongInteractableActorGrabbed.Broadcast(this);
    }
}
 
FTransform ABaseGrippableStoryActor::GetObjectGrabTransform_Implementation(APixoVRHand* GrabbedHand)
{
    if (HandGripLogic == EHandGripLogic::CustomTransformAttachWithPhysics)
    {
        FTransform RelativeToHandWorldTransform = GrabbedHand->MotionController->GetComponentTransform();
        const FTransform InHandOffsetTransform = GrabbedHand->HandMotionSource == EControllerHand::Left ? ObjectTransformInLeftHand : ObjectTransformInRightHand;
        RelativeToHandWorldTransform.SetTranslation(RelativeToHandWorldTransform.TransformPosition(InHandOffsetTransform.GetTranslation()));
        RelativeToHandWorldTransform.SetRotation(RelativeToHandWorldTransform.GetRotation() * InHandOffsetTransform.GetRotation());
        RelativeToHandWorldTransform.SetScale3D(InHandOffsetTransform.GetScale3D());
        
        return RelativeToHandWorldTransform;
    }
    
    return GetTransform();
}
 
void ABaseGrippableStoryActor::ObjectActivated_Implementation()
{
    Super::ObjectActivated_Implementation();
 
    if (StoryActivationAffectsDenyGripping)
    {
        VRGripInterfaceSettings.bDenyGripping = false;
    }
}
 
void ABaseGrippableStoryActor::ObjectDeactivated_Implementation()
{
    Super::ObjectDeactivated_Implementation();
 
    if (!StoryActivationAffectsDenyGripping)
        return;
 
    if (Execute_CouldBeGrabbedByOtherHand(this) || (Story->GameManager && Story->GameManager->bWrongInteractableActorGrabEnabled))
        VRGripInterfaceSettings.bDenyGripping = false;
    else
        VRGripInterfaceSettings.bDenyGripping = true;
}
 
void ABaseGrippableStoryActor::OnGrip_Implementation(UGripMotionControllerComponent* GrippingController, const FBPActorGripInformation& GripInformation)
{
    switch (HandGripLogic)
    {
    case EHandGripLogic::AttachToHand:
    case EHandGripLogic::CustomTransformAttachWithPhysics:
    case EHandGripLogic::NativeVRGripInterfaceSettings:
        if (bSaveResetTransformOnGrip)
        {
            ResetTransform = GetTransform();
            bSaveResetTransformOnGrip = false;
        }       
        StopPositionResetTimer();   
        OnGripped.Broadcast(GrippingController, GripInformation);
        break;
    case EHandGripLogic::AttachToHandWithCustomTransform:
        if (bSaveResetTransformOnGrip)
        {
            ResetTransform = GetTransform();
            bSaveResetTransformOnGrip = false;
        }       
        StopPositionResetTimer();
        AttachToHandObject(GrippingController, GripInformation);
        break;
    case EHandGripLogic::OnlyOnGripEvent:
        OnGripped.Broadcast(GrippingController, GripInformation);
        break;
        default:
            OnGripped.Broadcast(GrippingController, GripInformation);
    }
    PlayGripSound();
    PlayHapticFeedbackEffect(GrippingController);
}
 
void ABaseGrippableStoryActor::OnGripRelease_Implementation(UGripMotionControllerComponent* ReleasingController, const FBPActorGripInformation& GripInformation, bool bWasSocketed)
{
    switch (HandGripLogic)
    {
    case EHandGripLogic::AttachToHand:
    case EHandGripLogic::CustomTransformAttachWithPhysics:
    case EHandGripLogic::NativeVRGripInterfaceSettings:
        StartPositionResetTimer();
        break;
    case EHandGripLogic::AttachToHandWithCustomTransform:
        StartPositionResetTimer();
        DetachObjectFromHand();
        break;
    case EHandGripLogic::OnlyOnGripEvent:
        break;
    default:
        break;
    }
    OnDropped.Broadcast(ReleasingController, GripInformation, bWasSocketed);
 
    if (HandGripLogic != EHandGripLogic::OnlyOnGripEvent)
    {
        PlayReleaseSound();
        PlayHapticFeedbackEffect(ReleasingController);
    }
}
 
void ABaseGrippableStoryActor::IsHeld_Implementation(TArray<FBPGripPair>& HoldingControllers, bool& bIsHeld)
{
    HoldingControllers = VRGripInterfaceSettings.HoldingControllers;
    bIsHeld = VRGripInterfaceSettings.bIsHeld;
}
 
void ABaseGrippableStoryActor::SetHeld_Implementation(UGripMotionControllerComponent* HoldingController, uint8 GripID, bool bIsHeld)
{
    if (bIsHeld)
    {
        VRGripInterfaceSettings.HoldingControllers.AddUnique(FBPGripPair(HoldingController, GripID));
        VRGripInterfaceSettings.bWasHeld = true;
        VRGripInterfaceSettings.bIsHeld = VRGripInterfaceSettings.HoldingControllers.Num() > 0;
    }
    else
    {
        VRGripInterfaceSettings.HoldingControllers.Remove(FBPGripPair(HoldingController, GripID));
        VRGripInterfaceSettings.bIsHeld = VRGripInterfaceSettings.HoldingControllers.Num() > 0;
    }
}
 
bool ABaseGrippableStoryActor::DenyGripping_Implementation(UGripMotionControllerComponent * GripInitiator)
{
    return VRGripInterfaceSettings.bDenyGripping;
}
 
 
EGripInterfaceTeleportBehavior ABaseGrippableStoryActor::TeleportBehavior_Implementation()
{
    return VRGripInterfaceSettings.OnTeleportBehavior;
}
 
bool ABaseGrippableStoryActor::SimulateOnDrop_Implementation()
{
    return VRGripInterfaceSettings.bSimulateOnDrop;
}
 
EGripCollisionType ABaseGrippableStoryActor::GetPrimaryGripType_Implementation(bool bIsSlot)
{
    return bIsSlot ? VRGripInterfaceSettings.SlotDefaultGripType : VRGripInterfaceSettings.FreeDefaultGripType;
}
 
ESecondaryGripType ABaseGrippableStoryActor::SecondaryGripType_Implementation()
{
    return VRGripInterfaceSettings.SecondaryGripType;
}
 
EGripMovementReplicationSettings ABaseGrippableStoryActor::GripMovementReplicationType_Implementation()
{
    return VRGripInterfaceSettings.MovementReplicationType;
}
 
EGripLateUpdateSettings ABaseGrippableStoryActor::GripLateUpdateSetting_Implementation()
{
    return VRGripInterfaceSettings.LateUpdateSetting;
}
 
void ABaseGrippableStoryActor::GetGripStiffnessAndDamping_Implementation(float &GripStiffnessOut, float &GripDampingOut)
{
    GripStiffnessOut = VRGripInterfaceSettings.ConstraintStiffness;
    GripDampingOut = VRGripInterfaceSettings.ConstraintDamping;
}
 
FBPAdvGripSettings ABaseGrippableStoryActor::AdvancedGripSettings_Implementation()
{
    return VRGripInterfaceSettings.AdvancedGripSettings;
}
 
float ABaseGrippableStoryActor::GripBreakDistance_Implementation()
{
    return VRGripInterfaceSettings.ConstraintBreakDistance;
}
 
void ABaseGrippableStoryActor::ClosestGripSlotInRange_Implementation(FVector WorldLocation, bool bSecondarySlot, bool & bHadSlotInRange, FTransform & SlotWorldTransform, FName & SlotName, UGripMotionControllerComponent * CallingController, FName OverridePrefix)
{
    if (OverridePrefix.IsNone())
        bSecondarySlot ? OverridePrefix = "VRGripS" : OverridePrefix = "VRGripP";
 
    UVRExpansionFunctionLibrary::GetGripSlotInRangeByTypeName(OverridePrefix, this, WorldLocation, bSecondarySlot ? VRGripInterfaceSettings.SecondarySlotRange : VRGripInterfaceSettings.PrimarySlotRange, bHadSlotInRange, SlotWorldTransform, SlotName, CallingController);
}
 
bool ABaseGrippableStoryActor::AllowsMultipleGrips_Implementation()
{
    return VRGripInterfaceSettings.bAllowMultipleGrips;
}
 
void ABaseGrippableStoryActor::UpdateHandGripLogic(EHandGripLogic NewHandGripLogic)
{
    HandGripLogic = NewHandGripLogic;
    switch (HandGripLogic)
    {
    case EHandGripLogic::AttachToHand:
        VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::InteractiveCollisionWithPhysics;
        VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::InteractiveCollisionWithPhysics;
        break;
    case EHandGripLogic::OnlyOnGripEvent:
        VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::EventsOnly;
        VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::EventsOnly;
        break;
    case EHandGripLogic::AttachToHandWithCustomTransform:
        VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::EventsOnly;
        VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::EventsOnly;
        break;
    case EHandGripLogic::CustomTransformAttachWithPhysics:
        VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::InteractiveHybridCollisionWithSweep;
        VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::InteractiveHybridCollisionWithSweep;
        break;
    case EHandGripLogic::NativeVRGripInterfaceSettings:
        break;
    default:
        VRGripInterfaceSettings.SlotDefaultGripType = EGripCollisionType::InteractiveCollisionWithPhysics;
        VRGripInterfaceSettings.FreeDefaultGripType = EGripCollisionType::InteractiveCollisionWithPhysics;
    }
}
 
void ABaseGrippableStoryActor::OnSecondaryGrip_Implementation(UGripMotionControllerComponent* GripOwningController, USceneComponent* SecondaryGripComponent, const FBPActorGripInformation& GripInformation) { OnSecondaryGripAdded.Broadcast(GripOwningController, GripInformation); }
void ABaseGrippableStoryActor::OnSecondaryGripRelease_Implementation(UGripMotionControllerComponent* GripOwningController, USceneComponent* ReleasingSecondaryGripComponent, const FBPActorGripInformation& GripInformation) { OnSecondaryGripRemoved.Broadcast(GripOwningController, GripInformation); }
 
void ABaseGrippableStoryActor::AttachToHandObject(UGripMotionControllerComponent* GrippingController,  const FBPActorGripInformation& GripInformation)
{
    CurrentHoldingHand = Cast<APixoVRHand>(GrippingController->GetOwner());
    
    DisableComponentsSimulatePhysics();
    AttachToComponent(CurrentHoldingHand->MotionController, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
 
    if (CurrentHoldingHand->HandMotionSource == EControllerHand::Left)
    {
        SetActorRelativeTransform(ObjectTransformInLeftHand);
    }
    else
    {
        SetActorRelativeTransform(ObjectTransformInRightHand);
    }
 
    OnGripped.Broadcast(GrippingController, GripInformation);
}
 
void ABaseGrippableStoryActor::DetachObjectFromHand()
{
    FDetachmentTransformRules DetachmentTransformRules(EDetachmentRule::KeepWorld, false);
    DetachFromActor(DetachmentTransformRules);
    if (IVRGripInterface::Execute_SimulateOnDrop(this))
    {
        for (UActorComponent* Component : GetComponents())
        {
            if (UPrimitiveComponent* PrimComp = Cast<UPrimitiveComponent>(Component))
            {
                PrimComp->SetSimulatePhysics(true);
            }
        }
    }
}
 
void ABaseGrippableStoryActor::GrabWithTwoHands_Implementation(UMotionControllerComponent* GrabbingController)
{
    Super::GrabWithTwoHands_Implementation(GrabbingController);
 
    FOverlappingInfo OverlappingInfo;
    APixoVRCharacter* PlayerRef = Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0));
    PixoVRHandLeft = PlayerRef->VRHandLeft;
    PixoVRHandRight = PlayerRef->VRHandRight;
    TWeakObjectPtr<APixoVRHand> GrabbingHand = GrabbingController->MotionSource.IsEqual("Right") ? PixoVRHandRight : PixoVRHandLeft;
    
    GrabbingHand.Get()->GetOverlappingActor(OverlappingInfo);
    if (!OverlappingInfo.OverlapActor || !(OverlappingInfo.OverlapActor == this))
        return;
 
    if( PlayerRef->bActivateLeftLaser || PlayerRef->bActivateRightLaser)
    {
        PlayerRef->bLaserBeamActive = false;
        PlayerRef->ActivateLaserBeam(EControllerHand::Right, false);
        PlayerRef->ActivateLaserBeam(EControllerHand::Left, false);
    }
    
    DetachFromActor(FDetachmentTransformRules::KeepWorldTransform);
    ObjectHeldWithTwoHands = true;
    PixoVRHandLeft->HandHoldingObject = this;
    PixoVRHandRight->HandHoldingObject = this;
    Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->HoldToolRight = true;
    Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->HoldToolLeft = true;
    TwoHandMainGrabController = GrabbingController->MotionSource.IsEqual("Right") ? PixoVRHandLeft->MotionController : PixoVRHandRight->MotionController;
 
    for (const auto FakeHand : IPixoVRStoryObject::Execute_GetTwoHandProperties(this).FakeHands)
    {
        FakeHand->SetVisibility(true);
    }
    if (PixoVRHandLeft.IsValid() && PixoVRHandRight.IsValid() && !IPixoVRStoryObject::Execute_GetTwoHandProperties(this).EnableDebug)
    {
        PixoVRHandLeft->SetActorHiddenInGame(true);
        PixoVRHandRight->SetActorHiddenInGame(true);
    }
    TwoHandGrab();
}
 
void ABaseGrippableStoryActor::ReleaseTwoHands_Implementation(UMotionControllerComponent* ReleasingController)
{
    Super::ReleaseTwoHands_Implementation(ReleasingController);
    if (EnableOnePressDetach)
    {
        if (GetWorldTimerManager().IsTimerActive(TwoHandTimer))
            GetWorldTimerManager().ClearTimer(TwoHandTimer);
        PixoVRHandLeft->SetActorHiddenInGame(false);
        PixoVRHandRight->SetActorHiddenInGame(false);
        ObjectHeldWithTwoHands = false;
        for (const auto FakeHand : IPixoVRStoryObject::Execute_GetTwoHandProperties(this).FakeHands)
        {
            FakeHand->SetVisibility(false);
        }
        Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->ResetHand(true);
        Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->ResetHand(false);
        IPixoVRStoryObject::Execute_ResetTwoHandsHoldingFunctionality(this);
    }
    if (TwoHandMainGrabController.IsValid() && (TwoHandMainGrabController == ReleasingController) && true)
    {
        return;
    }
    if (GetWorldTimerManager().IsTimerActive(TwoHandTimer))
    {
        GetWorldTimerManager().ClearTimer(TwoHandTimer);
        PixoVRHandLeft->SetActorHiddenInGame(false);
        PixoVRHandRight->SetActorHiddenInGame(false);
        ObjectHeldWithTwoHands = false;
 
        for (const auto FakeHand : IPixoVRStoryObject::Execute_GetTwoHandProperties(this).FakeHands)
        {
            FakeHand->SetVisibility(false);
        }
 
        APixoVRHand* ActiveHandAfterRelease = ReleasingController->MotionSource.IsEqual("Right") ? PixoVRHandLeft.Get() : PixoVRHandRight.Get();
        if (ReleasingController->MotionSource.IsEqual("Right"))
        {
            Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->ResetHand(true);
            // Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->HoldToolRight = false;
            // PixoVRHandRight->HandHoldingObject = nullptr;
        }
        else
        {
            Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->ResetHand(false);
            // Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(), 0))->HoldToolLeft = false;
            // PixoVRHandLeft->HandHoldingObject = nullptr;
        }
        
        if (TwoHandMainGrabController.IsValid() && TwoHandMainGrabController == ReleasingController)
        {
            TwoHandMainGrabController = ActiveHandAfterRelease->MotionController;
            ActiveHandAfterRelease->MotionController->GripObjectByInterface(this, IPixoVRStoryObject::Execute_GetObjectGrabTransform(this, ActiveHandAfterRelease));
        }
        else
        {
            this->AttachToComponent(ActiveHandAfterRelease->MotionController, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
            ReleasingController->MotionSource.IsEqual("Right") ? SetActorRelativeTransform(ObjectTransformInLeftHand) : SetActorRelativeTransform(ObjectTransformInRightHand);
        }
    }
}
 
bool ABaseGrippableStoryActor::IsObjectHeldWithTwoHands_Implementation()
{
    return ObjectHeldWithTwoHands;
}
 
void ABaseGrippableStoryActor::ResetTwoHandsHoldingFunctionality_Implementation()
{
    Super::ResetTwoHandsHoldingFunctionality_Implementation();
 
    if (GetWorldTimerManager().IsTimerActive(TwoHandTimer))
    {
        GetWorldTimerManager().ClearTimer(TwoHandTimer);
        PixoVRHandLeft->SetActorHiddenInGame(false);
        PixoVRHandRight->SetActorHiddenInGame(false);
        ObjectHeldWithTwoHands = false;
 
        for (const auto FakeHand : IPixoVRStoryObject::Execute_GetTwoHandProperties(this).FakeHands)
        {
            FakeHand->SetVisibility(false);
        }
    }
}
 
void ABaseGrippableStoryActor::EnableOnePressDetach_Implementation(bool Enable)
{
    EnableOnePressDetach = Enable;
}
 
void ABaseGrippableStoryActor::UpdateObjectHighlight_Implementation(bool Activate)
{
    if (HighlightComponent && !HighlightComponent->PulseHighlightTimerHandle.IsValid())
    {
        if (Activate)
        {
            HighlightComponent->UpdateHighlightValue(EHighlightColor::Blue);
        }
        else
        {
            HighlightComponent->UpdateHighlightValue(EHighlightColor::None);
        }
    }
}
 
void ABaseGrippableStoryActor::PlayHapticFeedbackEffect(UGripMotionControllerComponent* GripMotionControllerComponent) const
{
    if (bFeedbackEnabled && GripMotionControllerComponent)
    {
        APlayerController* PlayerController = UGameplayStatics::GetPlayerController(GetWorld(), 0);
        APixoVRPlayerController* PixoVRPlayerController = Cast<APixoVRPlayerController>(PlayerController);
        if (PixoVRPlayerController)
        {
            EControllerHand Hand;
            GripMotionControllerComponent->GetHandType(Hand);
 
            PixoVRPlayerController->PlayHapticFeedback(Hand == EControllerHand::Right, HapticDuration, HapticStrength);
        }
    }
}
 
void ABaseGrippableStoryActor::PlayGripSound() const
{
    if (bGripSoundsEnabled && GripSoundCue)
    {
        UGameplayStatics::PlaySoundAtLocation(this, GripSoundCue, GetActorLocation());
    }
}
 
void ABaseGrippableStoryActor::PlayReleaseSound() const
{
    if (bReleaseSoundsEnabled && ReleaseSoundCue)
    {
        UGameplayStatics::PlaySoundAtLocation(this, ReleaseSoundCue, GetActorLocation());
    }
}
 
void ABaseGrippableStoryActor::TwoHandGrab()
{
    if (!PixoVRHandLeft.IsValid() || !PixoVRHandRight.IsValid())
        return;
    
    const FRotator HandDirectionRotator =  UKismetMathLibrary::ComposeRotators(UKismetMathLibrary::FindLookAtRotation(PixoVRHandRight->GrabSphere->GetComponentLocation(), PixoVRHandLeft->GrabSphere->GetComponentLocation()), FRotator(0.0, -90.0, 0.0));
    if (CrossDetected && IPixoVRStoryObject::Execute_GetTwoHandProperties(this).EnableFlip)
    {
        if (HandDirectionRotator.Pitch <= 0.0)
        {
            ResultedPitch = FMath::Abs(PitchBeforeCross) + (FMath::Abs(PitchBeforeCross) - FMath::Abs(HandDirectionRotator.Pitch));
        }
        else
        {
            ResultedPitch = (FMath::Abs(PitchBeforeCross) + (FMath::Abs(PitchBeforeCross) - FMath::Abs(HandDirectionRotator.Pitch))) * -1.0;
        }
        SetActorRotation(FRotator(0.0, TwoHandZAxisValue, ResultedPitch));
    }
    else if (CrossDetected && !IPixoVRStoryObject::Execute_GetTwoHandProperties(this).EnableFlip)
    {
        SetActorRotation(FRotator(0.0, TwoHandZAxisValue, ResultedPitch));
    }
    else
    {
        if (HandDirectionRotator.Pitch <= 0.0)
        {
            ResultedPitch = (HandDirectionRotator.Pitch - MoveBackPitchDelta) * -1.0;
        }
        else
        {
            ResultedPitch = (HandDirectionRotator.Pitch + MoveBackPitchDelta) * -1.0;
        }
 
        if (MoveBackPitchDelta > 0.0)
        {
            MoveBackPitchDelta = MoveBackPitchDelta - 1.0;
        }
        else
        {
            MoveBackPitchDelta = 0.0;
        }
    
        if (!((ResultedPitch >= 60.0) || ResultedPitch <= -60.0))
            TwoHandZAxisValue = HandDirectionRotator.Yaw;
        SetActorRotation(FRotator(0.0, TwoHandZAxisValue, ResultedPitch));
    }
 
    FVector ObjectRelatedHandLocation = (PixoVRHandRight->GrabSphere->GetComponentLocation() - (PixoVRHandRight->GrabSphere->GetComponentLocation()-PixoVRHandLeft->GrabSphere->GetComponentLocation())/2);
    ObjectRelatedHandLocation.Z -= IPixoVRStoryObject::Execute_GetTwoHandProperties(this).ZAxisOffsetInHands; 
    SetActorLocation(ObjectRelatedHandLocation);
    HandCrossDetection(ResultedPitch, HandDirectionRotator.Pitch);
 
    if (IPixoVRStoryObject::Execute_GetTwoHandProperties(this).EnableDebug)
    {
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Red, FString::Printf(TEXT("Right hand distance to object - %f"), (PixoVRHandRight->GrabSphere->GetComponentLocation() - GetActorLocation()).Size()));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Blue, FString::Printf(TEXT("Left hand distance to object - %f"), (PixoVRHandLeft->GrabSphere->GetComponentLocation() - GetActorLocation()).Size()));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Black, FString::Printf(TEXT("Detach distance - %f"), (IPixoVRStoryObject::Execute_GetTwoHandProperties(this).ControllerDetachDistance)));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Black, FString::Printf(TEXT("Cross detected - %s"), CrossDetected ? TEXT("true") : TEXT("false")));
        DrawDebugSphere(GetWorld(), (PixoVRHandRight->GrabSphere->GetComponentLocation() - (PixoVRHandRight->GrabSphere->GetComponentLocation()-PixoVRHandLeft->GrabSphere->GetComponentLocation())/2), 3.0, 10, FColor::Yellow, false, 0.1);
    }
    if ((PixoVRHandRight->GrabSphere->GetComponentLocation() - GetActorLocation()).Size() > (IPixoVRStoryObject::Execute_GetTwoHandProperties(this).ControllerDetachDistance))
        IPixoVRStoryObject::Execute_ReleaseTwoHands(this, PixoVRHandRight->MotionController);
    if ((PixoVRHandLeft->GrabSphere->GetComponentLocation() - GetActorLocation()).Size() > (IPixoVRStoryObject::Execute_GetTwoHandProperties(this).ControllerDetachDistance))
        IPixoVRStoryObject::Execute_ReleaseTwoHands(this, PixoVRHandLeft->MotionController);
    
    GetWorldTimerManager().SetTimer(TwoHandTimer, this, &ABaseGrippableStoryActor::TwoHandGrab, IPixoVRStoryObject::Execute_GetTwoHandProperties(this).TwoHandUpdateFrequency, false);
}
 
void ABaseGrippableStoryActor::HandCrossDetection(float CurrentPitch, float RightLeftHandVPitch)
{
    const APixoVRCharacter* PlayerRef =Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerPawn(GetWorld(),0));
    FVector CameraRightHandV = PlayerRef->VRHandRight->GrabSphere->GetComponentLocation() - PlayerRef->VRReplicatedCamera->GetComponentLocation();
    FVector CameraLeftHandV = PlayerRef->VRHandLeft->GrabSphere->GetComponentLocation() - PlayerRef->VRReplicatedCamera->GetComponentLocation();
    if (!CameraRightHandV.Normalize())
        GEngine->AddOnScreenDebugMessage(-1, 10.0, FColor::Orange, FString::Printf(TEXT("Bad normalization CameraRightHandV")));
    if (!CameraLeftHandV.Normalize())
        GEngine->AddOnScreenDebugMessage(-1, 10.0, FColor::Orange, FString::Printf(TEXT("Bad normalization CameraLeftHandV")));
    
    FVector RightLeftHandV = CameraRightHandV + CameraLeftHandV;
    if (!RightLeftHandV.Normalize())
        GEngine->AddOnScreenDebugMessage(-1, 10.0, FColor::Orange, FString::Printf(TEXT("Bad normalization CameraLeftHandV")));
 
    const FVector Cross = FVector::CrossProduct(CameraRightHandV, RightLeftHandV);
    CrossDetected = Cross.Z > 0.f;
    if (IPixoVRStoryObject::Execute_GetTwoHandProperties(this).EnableDebug)
    {
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Orange, FString::Printf(TEXT("RightLeftHandV x - %f, y - %f, z - %f"), RightLeftHandV.X, RightLeftHandV.Y, RightLeftHandV.Z));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Orange, FString::Printf(TEXT("VRHandRight x - %f, y - %f, z - %f"), PlayerRef->VRHandRight->GetActorLocation().X, PlayerRef->VRHandRight->GetActorLocation().Y, PlayerRef->VRHandRight->GetActorLocation().Z));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Orange, FString::Printf(TEXT("CameraRightHandV x - %f, y - %f, z - %f"), CameraRightHandV.X, CameraRightHandV.Y, CameraRightHandV.Z));
        GEngine->AddOnScreenDebugMessage(-1, 0.01, FColor::Orange, FString::Printf(TEXT("Z cross - %f"), Cross.Z));
    }
    if (CrossDetected != CrossChanged)
    {
        PitchBeforeCross = CurrentPitch;
        if (CrossDetected)
        {
            CrossChanged = CrossDetected;
        }
        else
        {
            MoveBackPitchDelta = FMath::Abs(FMath::Abs(CurrentPitch) - FMath::Abs(RightLeftHandVPitch));
            CrossChanged = CrossDetected;
        }
    }
}