PixoVRToolBase.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "CharacterTools/WorkTools/PixoVRToolBase.h"
#include "Net/UnrealNetwork.h"
#include "AudioDevice.h"
#include "ActiveSound.h"
#include "GripMotionControllerComponent.h"
#include "PixoVRHand.h"
#include "Components/StaticMeshComponent.h"
#include "Components/BoxComponent.h"
#include "Components/AudioComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Sound/SoundAttenuation.h"
 
// Sets default values
APixoVRToolBase::APixoVRToolBase()
    : Super()
    , bDestroyOnExit(true)
    , bToggleCollisionOnUsage(true)
{
    // 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;
 
    GrabBoxComponent = CreateDefaultSubobject<UBoxComponent>(FName("GrabBox"));
    if (GrabBoxComponent)
    {
        RootComponent = GrabBoxComponent;
    }
 
    ToolMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(FName("ToolMesh"));
    if (ToolMeshComponent)
    {
        ToolMeshComponent->SetupAttachment(RootComponent);
    }
 
    bReplicates = true;
    SetReplicateMovement(true);
 
    DestroyState.bIsPendingKill = false;
    DestroyState.TimeBeforeKilled = 0.f;
}
 
// Called when the game starts or when spawned
void APixoVRToolBase::BeginPlay()
{
    Super::BeginPlay();
 
    bIsGripAllowed = true;
 
    if (bAdvancedDrop)
    {
        GrabBoxComponent->OnComponentBeginOverlap.AddDynamic(this, &APixoVRToolBase::OnOverlapBegin);
    }
}
 
void APixoVRToolBase::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);
 
    if (DestroyState.bIsPendingKill)
    {
        DestroyState.TimeBeforeKilled -= DeltaSeconds;
        if (DestroyState.TimeBeforeKilled <= 0.f && IsDestroyable())
        {
            HandleDestroy();
        }
    }
}
 
void APixoVRToolBase::OnOverlapBegin(UPrimitiveComponent* OverlappedComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (!bIsGripped && OtherActor != this && OtherActor != GetOwner())
    {
        FRotator NewRotation = GetActorRotation();
        NewRotation.Roll = 0.0f;
        NewRotation.Pitch = 0.0f;
 
        GrabBoxComponent->SetAllPhysicsLinearVelocity(FVector::ZeroVector);
        SetActorRotation(NewRotation);
    }
}
 
bool APixoVRToolBase::IsDestroyable_Implementation()
{
    return true;
}
 
void APixoVRToolBase::HandleDestroy_Implementation()
{
    Destroy();
}
 
bool APixoVRToolBase::IsGripped()
{
    return bIsGripped;
}
 
void APixoVRToolBase::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(APixoVRToolBase, GrabHand);
    DOREPLIFETIME(APixoVRToolBase, bIsGripped);
    DOREPLIFETIME(APixoVRToolBase, bIsPaused);
    DOREPLIFETIME(APixoVRToolBase, ToolData);
}
 
void APixoVRToolBase::OnGripObject_Implementation(UGripMotionControllerComponent* GrippingController, AActor* GrippedActor)
{
    if (GrippingController)
    {
        ServerUseTool(GrippingController, GrippedActor);
    }
}
 
void APixoVRToolBase::InitializeTool_Implementation(const FPixoToolData& InToolData)
{
    ToolData = InToolData;
    bDestroyOnDrop = ToolData.DestroyOnDrop;
 
    if (ToolData.DestroyAfterDelay)
    {
        DestroyDelay = ToolData.DestroyDelay;
    }
    else
    {
        DestroyDelay = -1.f;
    }
}
 
bool APixoVRToolBase::DenyGrippingPixoVR_Implementation(UGripMotionControllerComponent* GrippingController)
{
    return !bIsGripAllowed;
}
 
bool APixoVRToolBase::DenyTriggerGripping_Implementation()
{
    return false;
}
 
bool APixoVRToolBase::DenyDropping_Implementation()
{
    return false;
}
 
void APixoVRToolBase::OnTryGripObject_Implementation(UGripMotionControllerComponent* GrippingController, AActor* GrippedActor)
{
}
 
void APixoVRToolBase::OnGripObjectRelease_Implementation(UGripMotionControllerComponent* ReleasingController, AActor* GrippedActor)
{
    ServerOnDropped();
}
 
void APixoVRToolBase::GripTriggerMode_Implementation(EPixoVRGripTriggerModeEnum& GripTriggerMode)
{
    GripTriggerMode = EPixoVRGripTriggerModeEnum::GRIP_TRIGGER_TOGGLE_DROP;
}
 
void APixoVRToolBase::GripTriggerTransform_Implementation(UGripMotionControllerComponent* GrippingController, bool& bUseCustomTransform, FTransform& CustomTransform)
{
    bUseCustomTransform = true;
    CustomTransform = IsRightHand(GrippingController) ? RightHandGrip : LeftHandGrip;
}
 
void APixoVRToolBase::GripMode_Implementation(EPixoVRGripModeEnum& GripMode)
{
    GripMode = EPixoVRGripModeEnum::GRIP_STATIC;
}
 
bool APixoVRToolBase::DisablePhysicsOnDrop_Implementation()
{
    return false;
}
 
void APixoVRToolBase::OnObjectPaused_Implementation()
{
    ToolMeshComponent->SetVisibility(false);
    SetActorEnableCollision(false);
    bIsPaused = true;
}
 
void APixoVRToolBase::OnObjectUnPaused_Implementation()
{
    ToolMeshComponent->SetVisibility(true);
    SetActorEnableCollision(true);
    bIsPaused = false;
}
 
void APixoVRToolBase::MulticastToggleCollision_Implementation(ECollisionEnabled::Type Type)
{
    GrabBoxComponent->SetCollisionEnabled(Type);
    ToolMeshComponent->SetCollisionEnabled(Type);
}
 
 
void APixoVRToolBase::ServerStartPlayingSound_Implementation(USoundBase* Sound, const FVector& SoundLocation, float VolumeMultiplier /*= 1.0f*/)
{
    MulticastStartPlayingSound(Sound, SoundLocation, VolumeMultiplier);
}
 
bool APixoVRToolBase::ServerStartPlayingSound_Validate(USoundBase* Sound, const FVector& SoundLocation, float VolumeMultiplier /*= 1.0f*/)
{
    return true;
}
 
void APixoVRToolBase::MulticastStartPlayingSound_Implementation(USoundBase* Sound, const FVector& SoundLocation, float VolumeMultiplier)
{
    UWorld* ThisWorld = GetWorld();
    if (!Sound || !ThisWorld || !ThisWorld->bAllowAudioPlayback || ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        return;
    }
 
    if (FAudioDevice* AudioDevice = ThisWorld->GetAudioDevice().GetAudioDevice())
    {
        USoundAttenuation* AttenuationSettings = Sound->AttenuationSettings;
        if(!AttenuationSettings)
        {
            AttenuationSettings = GetDefaultAttenuationSettings();
 
            UE_LOG(LogTemp, Warning, TEXT("Attenuation settings for sound = %s - nullptr, used default settings"), *Sound->GetName());
        }
 
        AudioDevice->PlaySoundAtLocation(Sound, ThisWorld, VolumeMultiplier, 1.f, 0.f, SoundLocation, FRotator::ZeroRotator, AttenuationSettings, nullptr, nullptr, nullptr);
    }
}
 
void APixoVRToolBase::ServerStopPlayingSound_Implementation(USoundBase* sound)
{
    MulticastStopPlayingSound(sound);
}
 
bool APixoVRToolBase::ServerStopPlayingSound_Validate(USoundBase* sound)
{
    return true;
}
 
void APixoVRToolBase::MulticastStopPlayingSound_Implementation(USoundBase* Sound)
{
    UWorld* ThisWorld = GetWorld();
    if (!Sound || !ThisWorld || !ThisWorld->bAllowAudioPlayback || ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        return;
    }
 
    if (FAudioDevice* AudioDevice = ThisWorld->GetAudioDevice().GetAudioDevice())
    {
        auto StopSound = [AudioDevice, Sound]()
        {
            if(AudioDevice && Sound)
            {
                const TArray<FActiveSound*>& ActiveSounds = AudioDevice->GetActiveSounds();
                for (FActiveSound* ActiveSound : ActiveSounds)
                {
                    if (ActiveSound->GetSound() == Sound)
                    {
                        AudioDevice->StopActiveSound(ActiveSound);
                    }
                }
            }
        };
        
        if(IsInAudioThread())
        {
            StopSound();
        }
        else
        {
            if(IsAudioThreadRunning())
            {
                FAudioThread::RunCommandOnAudioThread(StopSound);
            }
        }
    }
}
 
void APixoVRToolBase::ServerOnDropped_Implementation()
{
    ServerDestroyTool();
}
 
bool APixoVRToolBase::ServerOnDropped_Validate()
{
    return true;
}
 
void APixoVRToolBase::ServerStartPlayingSoundViaComponent_Implementation(USoundBase* Sound, float VolumeMultiplier /*= 1.0f*/)
{
    MulticastStartPlayingSoundViaComponent(Sound, VolumeMultiplier);
}
 
bool APixoVRToolBase::ServerStartPlayingSoundViaComponent_Validate(USoundBase* Sound, float VolumeMultiplier /*= 1.0f*/)
{
    return true;
}
 
void APixoVRToolBase::MulticastStartPlayingSoundViaComponent_Implementation(USoundBase* Sound, float VolumeMultiplier)
{
    UWorld* ThisWorld = GetWorld();
    if (!Sound || (AudioComponent && AudioComponent->IsPlaying()) || !ThisWorld || !ThisWorld->bAllowAudioPlayback || ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        return;
    }
    
    USoundAttenuation* AttenuationSettings = Sound->AttenuationSettings;
    if(!AttenuationSettings)
    {
        AttenuationSettings = GetDefaultAttenuationSettings();
 
        UE_LOG(LogTemp, Warning, TEXT("Attenuation settings for sound = %s - nullptr, used default settings"), *Sound->GetName());
    }
 
    AudioComponent = UGameplayStatics::SpawnSoundAttached(Sound, RootComponent, "RootComponent", FVector(ForceInit), FRotator::ZeroRotator, EAttachLocation::KeepRelativeOffset, true, VolumeMultiplier, 1.f, 0.f, AttenuationSettings, nullptr, true);
    
    ensure(AudioComponent);
}
 
void APixoVRToolBase::ServerStopPlayingSoundViaComponent_Implementation()
{
    MulticastStopPlayingSoundViaComponent();
}
 
bool APixoVRToolBase::ServerStopPlayingSoundViaComponent_Validate()
{
    return true;
}
 
void APixoVRToolBase::MulticastStopPlayingSoundViaComponent_Implementation()
{
    UWorld* ThisWorld = GetWorld();
    if (!ThisWorld || !ThisWorld->bAllowAudioPlayback || ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        return;
    }
 
    if (IsValid(AudioComponent))
    {
        AudioComponent->Stop();
    }
}
 
void APixoVRToolBase::ServerAdjustPlayingSoundVolumeViaComponent_Implementation(float InVolumeMultiplier /*= 1.0f*/)
{
    MulticastAdjustPlayingSoundVolumeViaComponent(InVolumeMultiplier);
}
 
bool APixoVRToolBase::ServerAdjustPlayingSoundVolumeViaComponent_Validate(float InVolumeMultiplier)
{
    return true;
}
 
void APixoVRToolBase::MulticastAdjustPlayingSoundVolumeViaComponent_Implementation(float InVolumeMultiplier)
{
    if (IsValid(AudioComponent) && AudioComponent->VolumeMultiplier != InVolumeMultiplier)
    {
        if (InVolumeMultiplier == 0.f || FMath::Abs(AudioComponent->VolumeMultiplier - InVolumeMultiplier) >= 0.05f)
        {
            AudioComponent->SetVolumeMultiplier(InVolumeMultiplier);
        }
    }
}
 
void APixoVRToolBase::ServerUseTool_Implementation(UGripMotionControllerComponent* GrippingController, AActor* GrippedActor)
{
    if (bIsGripAllowed)
    {
        DestroyState.bIsPendingKill = false;
        
        GrabHand = IsRightHand(GrippingController) ? EControllerHand::Right : EControllerHand::Left;
        bIsGripped = true;
 
        if (bAdvancedDrop)
        {
            SetActorRotation(Cast<APixoVRHand>(GrippingController->GetOwner())->GrabSphere->GetComponentRotation());
            SetActorRelativeRotation(IsRightHand(GrippingController) ? RightHandGrip.GetRotation() : LeftHandGrip.GetRotation());
        }
        
        SetActorRelativeTransform(IsRightHand(GrippingController) ? RightHandGrip : LeftHandGrip);
        
        if (bToggleCollisionOnUsage)
        {
            GrabBoxComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
            ToolMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
            MulticastToggleCollision(ECollisionEnabled::NoCollision);
        }
 
        OnGripAction.Broadcast(false);
        ServerStartPlayingSound(GripSound, GetActorLocation());
    }
}
 
bool APixoVRToolBase::ServerUseTool_Validate(UGripMotionControllerComponent* GrippingController, AActor* GrippedActor)
{
    return true;
}
 
void APixoVRToolBase::ServerDestroyTool_Implementation()
{
    DestroyState.bIsPendingKill = bDestroyOnDrop;
    DestroyState.TimeBeforeKilled = DestroyDelay;
 
    if (bToggleCollisionOnUsage)
    {
        GrabBoxComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
        ToolMeshComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
        MulticastToggleCollision(ECollisionEnabled::QueryAndPhysics);
    }
 
    GrabHand = EControllerHand::AnyHand;
    bIsGripped = false;
 
    OnGripAction.Broadcast(true);
}
 
bool APixoVRToolBase::ServerDestroyTool_Validate()
{
    return true;
}
 
bool APixoVRToolBase::IsRightHand(UGripMotionControllerComponent* GrippingController) const
{
    const auto HandType = Cast<APixoVRHand>(GrippingController->GetOwner())->HandMotionSource;
    return HandType == EControllerHand::Right ? true : false;
}
 
USoundAttenuation* APixoVRToolBase::GetDefaultAttenuationSettings()
{
    if(!DefaultAttenuationSettings)
    {
        DefaultAttenuationSettings = NewObject<USoundAttenuation>();
        DefaultAttenuationSettings->Attenuation.FalloffDistance = 2000.f;
    }
 
    return DefaultAttenuationSettings;
}