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"
 
ABaseGrippableStoryActor::ABaseGrippableStoryActor()
    : Super()
{
    StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>("StaticMeshComponent");
    StaticMeshComponent->SetupAttachment(RootComponent);
    
    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;
 
    //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::StartVelocityCheckTimer()
{
    GetWorld()->GetTimerManager().SetTimer(VelocityCheckTimer, this, &ABaseGrippableStoryActor::CheckVelocity, VelocityCheckRate, true);
}
 
void ABaseGrippableStoryActor::StopVelocityCheckTimer()
{
    GetWorld()->GetTimerManager().ClearTimer(VelocityCheckTimer);
}
 
void ABaseGrippableStoryActor::ResetPosition()
{
    if (!bCanResetPosition)
        return;
    
    bSaveResetTransformOnGrip = true;
    StaticMeshComponent->SetSimulatePhysics(false);
    SetActorTransform(ResetTransform);
    OnActorPositionResetDelegate.Broadcast(this);
}
 
void ABaseGrippableStoryActor::CheckVelocity()
{
    if (FMath::IsNearlyEqual(GetVelocity().Size(), 0.0f))
    {
        StopVelocityCheckTimer();
        OnActorStoppedDelegate.Broadcast(this);
        
        if (bActivateLocationResetAfterDrop)
        {
            ResetPosition();
        }
    }
}
 
void ABaseGrippableStoryActor::ObjectActivated_Implementation()
{
    Super::ObjectActivated_Implementation();
    VRGripInterfaceSettings.bDenyGripping = false;
}
 
void ABaseGrippableStoryActor::ObjectDeactivated_Implementation()
{
    Super::ObjectDeactivated_Implementation();
    if (IPixoVRStoryObject::Execute_CouldBeGrabbedByOtherHand(this))
        VRGripInterfaceSettings.bDenyGripping = false;
    else
        VRGripInterfaceSettings.bDenyGripping = true;
}
 
void ABaseGrippableStoryActor::OnGrip_Implementation(UGripMotionControllerComponent* GrippingController, const FBPActorGripInformation& GripInformation)
{
    switch (HandGripLogic)
    {
    case EHandGripLogic::AttachToHand:
        if (bSaveResetTransformOnGrip)
        {
            ResetTransform = GetTransform();
            bSaveResetTransformOnGrip = false;
        }       
        StopVelocityCheckTimer();   
        OnGripped.Broadcast(GrippingController, GripInformation);
        break;
    case EHandGripLogic::AttachToHandWithCustomTransform:
        if (bSaveResetTransformOnGrip)
        {
            ResetTransform = GetTransform();
            bSaveResetTransformOnGrip = false;
        }       
        StopVelocityCheckTimer();
        AttachToHandObject(GrippingController, GripInformation);
        break;
    case EHandGripLogic::OnlyOnGripEvent:
        OnGripped.Broadcast(GrippingController, GripInformation);
        break;
        default:
            OnGripped.Broadcast(GrippingController, GripInformation);
    }
 
    PlayHapticFeedbackEffect(GrippingController);
}
 
void ABaseGrippableStoryActor::OnGripRelease_Implementation(UGripMotionControllerComponent* ReleasingController, const FBPActorGripInformation& GripInformation, bool bWasSocketed)
{
    switch (HandGripLogic)
    {
    case EHandGripLogic::AttachToHand:
        StartVelocityCheckTimer();
        break;
    case EHandGripLogic::AttachToHandWithCustomTransform:
        StartVelocityCheckTimer();
        DetachObjectFromHand();
        break;
    case EHandGripLogic::OnlyOnGripEvent:
        break;
    default:
        break;
    }
    OnDropped.Broadcast(ReleasingController, GripInformation, bWasSocketed);
 
    if (HandGripLogic != EHandGripLogic::OnlyOnGripEvent)
    {
        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;
    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());
    if (bDisablePhysicsOnCustomTransformAttach)
    {
        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::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);
        }
    }
}