PixoVRLaser.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "CharacterTools/PixoVRLaser.h"
#include "NavigationSystem.h"
#include "Interfaces/PixoVRInteractionInterface.h"
#include "VRExpansionFunctionLibrary.h"
#include "Components/SceneComponent.h"
#include "GameFramework/Character.h"
#include "Kismet/GameplayStatics.h"
#include "Materials/MaterialInstanceDynamic.h"
 
// In UGameplayStatics a lot of BP functions we use here.
 
DEFINE_LOG_CATEGORY(LogPixoVRLaser);
 
FString GetRoleName(ENetRole Role)
{
    switch (Role)
    {
    case ROLE_None:
         return TEXT("ROLE_None");
     case ROLE_SimulatedProxy:
         return TEXT("ROLE_SimulatedProxy");
     case ROLE_AutonomousProxy:
         return TEXT("ROLE_AutonomousProxy");
     case ROLE_Authority:
         return TEXT("ROLE_Authority");
     case ROLE_MAX:
    default:
         return TEXT("ROLE_MAX");
    }
}
 
FString GetNetModeName(ENetMode Mode)
{
    switch (Mode)
    {
    case NM_DedicatedServer:
         return TEXT("NM_DedicatedServer");
     case NM_ListenServer:
         return TEXT("NM_ListenServer");
     case NM_Standalone:
         return TEXT("NM_Standalone");
     case NM_Client:
         return TEXT("NM_Client");
     case NM_MAX:
    default:
         return TEXT("NM_MAX");
    }
}
 
APixoVRLaser::APixoVRLaser()
    : LaserBeam(nullptr)
    , LaserBeamEndPoint(nullptr)
    , WidgetInteraction(nullptr)
    , bIsLaserBeamActive(false)
    , LaserBeamMaxDistance(10000.0f)
    , LaserBeamRadius(1.0f)
    , LaserBeamEndpointRadius(0.02f)
    , LaserBeamColor(FLinearColor::Red)
    , LaserBeamEndpointColor(FLinearColor::Red)
    , bActivateHovering(true)
    , bLinkToInteraction(true)
    , LaserBeamMaterial(nullptr)
    , LaserBeamMaterialDynamic(nullptr)
    , LaserBeamEndpointMaterialDynamic(nullptr)
    , bIsLocal(true)
{
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
 
    bReplicates = true;
    SetReplicateMovement(true);
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> LaserBeamMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/Controller/BeamMesh.BeamMesh'"));
    UStaticMesh* LaserBeamMesh = LaserBeamMeshFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UStaticMesh> LaserBeamEndPointMeshFinder(TEXT("StaticMesh'/Engine/BasicShapes/Sphere.Sphere'"));
    UStaticMesh* LaserBeamEndPointMesh = LaserBeamEndPointMeshFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UMaterial> LaserBeamMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/LaserBeamSplineMat.LaserBeamSplineMat'"));
    LaserBeamMaterial = LaserBeamMaterialFinder.Object;
 
    SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("LaserSceneComponent"));
    RootComponent = SceneComponent;
 
    LaserBeam = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LaserBeam"));
    LaserBeam->SetupAttachment(SceneComponent);
    LaserBeam->SetStaticMesh(LaserBeamMesh);
    LaserBeam->SetMaterial(0, LaserBeamMaterial);
    LaserBeam->SetVisibility(false, true);
    LaserBeam->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    LaserBeam->SetGenerateOverlapEvents(false);
    LaserBeam->SetAutoActivate(false);
 
    LaserBeamEndPoint = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LaserBeamEndPoint"));
    LaserBeamEndPoint->SetupAttachment(SceneComponent);
    LaserBeamEndPoint->SetStaticMesh(LaserBeamEndPointMesh);
    LaserBeamEndPoint->SetMaterial(0, LaserBeamMaterial);
    LaserBeamEndPoint->SetVisibility(false, true);
    LaserBeamEndPoint->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    LaserBeamEndPoint->SetAutoActivate(false);
    LaserBeamEndPoint->SetGenerateOverlapEvents(false);
 
    LaserPointerMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LaserPointerMesh"));
    LaserPointerMesh->SetupAttachment(SceneComponent);
    LaserPointerMesh->SetVisibility(false, true);
    LaserPointerMesh->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    LaserPointerMesh->SetAutoActivate(false);
    LaserPointerMesh->SetGenerateOverlapEvents(false);
    
    WidgetInteraction = CreateDefaultSubobject<UWidgetInteractionComponent>(TEXT("LaserWidgetInteraction"));
    WidgetInteraction->SetupAttachment(LaserBeam);
    if(bLinkToInteraction)
    {
        WidgetInteraction->InteractionDistance = LaserBeamMaxDistance;
    }
    WidgetInteraction->bEnableHitTesting = false;
    WidgetInteraction->InteractionSource = EWidgetInteractionSource::World;
    WidgetInteraction->SetAutoActivate(false);
}
 
void APixoVRLaser::OnConstruction(const FTransform& Transform)
{
    Super::OnConstruction(Transform);
 
    LaserBeamEndPoint->SetWorldScale3D(FVector(LaserBeamEndpointRadius, LaserBeamEndpointRadius, LaserBeamEndpointRadius));
 
    LaserBeamMaterialDynamic = UMaterialInstanceDynamic::Create(LaserBeamMaterial, this);
    LaserBeamMaterialDynamic->SetVectorParameterValue(TEXT("LaserColor"), LaserBeamColor);
    LaserBeam->SetMaterial(0, LaserBeamMaterialDynamic);
 
    LaserBeamEndpointMaterialDynamic = UMaterialInstanceDynamic::Create(LaserBeamMaterial, this);
    LaserBeamEndpointMaterialDynamic->SetVectorParameterValue("LaserColor", LaserBeamEndpointColor);
    LaserBeamEndPoint->SetMaterial(0, LaserBeamEndpointMaterialDynamic);
}
 
void APixoVRLaser::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    ClientTickLaserBeam(DeltaTime);
}
 
void APixoVRLaser::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(APixoVRLaser, bIsLaserBeamActive);
}
 
void APixoVRLaser::SetHandType(EControllerHand HandType, bool InIsLocal)
{
    bIsLocal = InIsLocal;
}
 
void APixoVRLaser::OnRep_LaserBeamActive()
{
    UpdateStateLaserBeam();
}
 
void APixoVRLaser::UpdateStateLaserBeam()
{
    // Laserbeam got activated.
    if(!bIsLaserBeamActive)
    {
        // TODO Why do we set the custom hit result? It seems that
        // the InteractionSource isn't set to EWidgetInteractionSource::Custom, so it shouldn't do anything.
        FHitResult HitResult;
        HitResult.bBlockingHit = false;
        HitResult.Time = 0.0f;
        HitResult.Distance = 0.0f;
        HitResult.Location = FVector::ZeroVector;
        HitResult.ImpactPoint = FVector::ZeroVector;
        HitResult.Normal = FVector(0.0f, 0.0f, 1.0f);
        HitResult.ImpactNormal = FVector(0.0f, 0.0f, 1.0f);
        HitResult.BoneName = NAME_None;
        HitResult.Actor = nullptr;
        HitResult.Component = nullptr;
        HitResult.Item = 0;
        HitResult.FaceIndex = 0;
        HitResult.TraceStart = FVector::ZeroVector;
        HitResult.TraceEnd = FVector::ZeroVector;
 
        WidgetInteraction->SetCustomHitResult(HitResult);
    }
 
    // Set active will disable the tick of the components.
    LaserBeam->SetActive(bIsLaserBeamActive);
    LaserBeamEndPoint->SetActive(bIsLaserBeamActive);
 
    // Here we just hide the components.
    LaserBeam->SetVisibility(bIsLaserBeamActive, true);
    LaserBeamEndPoint->SetVisibility(bIsLaserBeamActive, true);
    LaserPointerMesh->SetVisibility(bIsLaserBeamActive, true);
    
    if(bIsLocal)
    {
        WidgetInteraction->bEnableHitTesting = bIsLaserBeamActive;
        WidgetInteraction->SetActive(bIsLaserBeamActive);
 
        if(bLinkToInteraction)
        {
            WidgetInteraction->InteractionDistance = LaserBeamMaxDistance;
        }
    }
 
    if(HoverHitResult.Actor.IsValid() && !bIsLaserBeamActive)
    {
        if(HoverHitResult.Actor->GetClass()->ImplementsInterface(UPixoVRInteractionInterface::StaticClass()))
        {
            if(!IPixoVRInteractionInterface::Execute_DisableHoverEvents(HoverHitResult.Actor.Get()))
            {
                TriggerHover(false, HoverHitResult.Actor.Get(), HoverHitResult);
 
                OnHoverEnd(HoverHitResult);
            }
        }
 
        HoverHitResult = FHitResult();
 
        HitActor = nullptr;
    }
 
    SetActorTickEnabled(bIsLaserBeamActive);
    OnLaserBeamActivated.Broadcast(this, bIsLaserBeamActive);
}
 
void APixoVRLaser::ActivateLaserBeam_Implementation(bool InActivate) 
{
    // Only change things if the activate state got changed.
    if(bIsLaserBeamActive == InActivate)
    {
        return;
    }
 
    bIsLaserBeamActive = InActivate;
    UpdateStateLaserBeam();
}
 
bool APixoVRLaser::IsOverWidgetUse(bool InPressed) 
{
    if(!bIsLaserBeamActive)
    {
        return false;
    }
 
    if(!WidgetInteraction->IsOverInteractableWidget())
    {
        return false;
    }
 
    InPressed ? WidgetInteraction->PressPointerKey(EKeys::LeftMouseButton) : WidgetInteraction->ReleasePointerKey(EKeys::LeftMouseButton);
 
    return true;
}
 
void APixoVRLaser::ClientTickLaserBeam_Implementation(float DeltaTime)
{
    // If not activated or the Motion controller specified, just skip ticking.
    if(!bIsLaserBeamActive)
    {
        return;
    }
 
    // Set start and endpoint for the laser beam.
    const FVector Start = GetActorLocation();
    const FVector End = GetActorLocation() + GetActorForwardVector() * LaserBeamMaxDistance;
 
    // Check for visibility.
    const ETraceTypeQuery ChannelType = UEngineTypes::ConvertToTraceType(ECC_Visibility);
    const auto TraceComplex = false;
 
    // Ignore the motion controller itself.
    TArray<AActor*> ActorsToIgnore;
    ActorsToIgnore.Add(GetOwner());
 
    // Ignore self.
    const auto IgnoreSelf = true;
    const float DrawTime = 5.0;
 
    FVector WorldScale3D;
    FHitResult HitResult;
    const auto Result = UKismetSystemLibrary::LineTraceSingle(this, 
                                                              Start, 
                                                              End, 
                                                              ChannelType, 
                                                              TraceComplex, 
                                                              ActorsToIgnore, 
                                                              EDrawDebugTrace::None, 
                                                              HitResult, 
                                                              IgnoreSelf, 
                                                              FLinearColor::Red, 
                                                              FLinearColor::Green, 
                                                              DrawTime);
    if(Result)
    {
        // The laser-beam hit something, scale the beam accordingly and put the endpoint to the correct
        // location.
        const auto LaserEndpointDistance = HitResult.Time * LaserBeamMaxDistance;
 
        WorldScale3D = FVector(LaserEndpointDistance, LaserBeamRadius * 1.0f, LaserBeamRadius * 1.0f);
        WidgetInteraction->SetCustomHitResult(HitResult);
 
        LaserBeamEndPoint->SetRelativeLocation(FVector(LaserEndpointDistance, 0.0f, 0.0f), false, nullptr, ETeleportType::TeleportPhysics);
 
        if( (HitActor != HitResult.Actor) && bActivateHovering)
        {
            if(HoverHitResult.Actor.IsValid())
            {
                if(HoverHitResult.Actor->GetClass()->ImplementsInterface(UPixoVRInteractionInterface::StaticClass()))
                {
                    if(!IPixoVRInteractionInterface::Execute_DisableHoverEvents(HoverHitResult.Actor.Get()))
                    {
                        TriggerHover(false, HoverHitResult.Actor.Get(), HoverHitResult);
 
                        OnHoverEnd(HoverHitResult);
                    }
                }
 
            }
 
            if (HitResult.Actor.IsValid())
            {
                if (HitResult.Actor->GetClass()->ImplementsInterface(UPixoVRInteractionInterface::StaticClass()))
                {
                    if (!IPixoVRInteractionInterface::Execute_DisableHoverEvents(HitResult.Actor.Get()))
                    {
                        TriggerHover(true, HitResult.Actor.Get(), HitResult);
 
                        OnHoverBegin(HitResult);
                    }
                }
                HoverHitResult = HitResult;
                HitActor = HitResult.Actor;
            }
        }
    }
    else
    {
        if(bActivateHovering)
        {
            if(HoverHitResult.Actor.IsValid())
            {
                if(HoverHitResult.Actor->GetClass()->ImplementsInterface(UPixoVRInteractionInterface::StaticClass()))
                {
                    if(!IPixoVRInteractionInterface::Execute_DisableHoverEvents(HoverHitResult.Actor.Get()))
                    {
                        TriggerHover(false, HoverHitResult.Actor.Get(), HoverHitResult);
 
                        OnHoverEnd(HoverHitResult);
                    }
                }
                HoverHitResult = FHitResult();
            }
            HitActor = nullptr;
        }
        WorldScale3D = FVector(LaserBeamMaxDistance, LaserBeamRadius * 1.0f, LaserBeamRadius * 1.0f);
    }
 
    LaserBeam->SetWorldScale3D(WorldScale3D);
    LaserBeamEndPoint->SetVisibility(Result, true);
}
 
void APixoVRLaser::TriggerHover(bool State, AActor* InteractableObject, const FHitResult& HitResult)
{
    APlayerController* Executor = GetWorld()->GetFirstPlayerController();
    if(Executor && Executor->GetCharacter() == Cast<ACharacter>(GetOwner()))
    {
        ServerTriggerHover(State, InteractableObject, HitResult, Executor);
    }
}
 
void APixoVRLaser::ServerTriggerHover_Implementation(bool State, AActor* InteractableObject,
    const FHitResult& HitResult, APlayerController* Executor)
{
    MulticastTriggerHover(State, InteractableObject, HitResult, Executor);
}
 
bool APixoVRLaser::ServerTriggerHover_Validate(bool State, AActor* InteractableObject, const FHitResult& HitResult,
    APlayerController* Executor)
{
    return true;
}
 
void APixoVRLaser::MulticastTriggerHover_Implementation(bool State, AActor* InteractableObject,
    const FHitResult& HitResult, APlayerController* Executor)
{
    if(!Executor || !InteractableObject)
    {
        return;
    }
    
    if (State)
    {
        IPixoVRInteractionInterface::Execute_OnHoverBegin(InteractableObject, HitResult, Executor);
    }
    else
    {
        IPixoVRInteractionInterface::Execute_OnHoverEnd(InteractableObject, HitResult, Executor);
    }       
}
 
bool APixoVRLaser::MulticastTriggerHover_Validate(bool State, AActor* InteractableObject, const FHitResult& HitResult,
    APlayerController* Executor)
{
    return true;
}
 
 
void APixoVRLaser::OnHoverBegin_Implementation(const FHitResult& HitResult)
{
    
}
 
void APixoVRLaser::OnHoverEnd_Implementation(const FHitResult& HitResult)
{
    
}
 
void APixoVRLaser::OnSelected_Implementation(const FHitResult& HitResult)
{
    
}
 
void APixoVRLaser::OnUnSelected_Implementation(const FHitResult& HitResult)
{
    
}
 
void APixoVRLaser::TriggerSelect(bool State)
{
    // User triggered select object.
    // Do we have a valid object that we hovered?
    if(HoverHitResult.Actor.IsValid() && bActivateHovering)
    {
        // In the following lines we just simulate if the user selected or unselected an object.
 
        if(HoverHitResult.Actor->GetClass()->ImplementsInterface(UPixoVRInteractionInterface::StaticClass()))
        {
            if(!IPixoVRInteractionInterface::Execute_DisablePressEvents(HoverHitResult.Actor.Get()))
            {
                // it will be always a client code, cause we have inputs only locally
                APlayerController* Executor = GetWorld()->GetFirstPlayerController();
                // it will be called on a server if we have it, or on the client in the single-player game
                ServerTriggerSelect(State, HoverHitResult.Actor.Get(), HoverHitResult, Executor);
            }
        }
        
        if(State)
        {
            OnSelected(HoverHitResult);
        }
        else
        {
            OnUnSelected(HoverHitResult);
        }
    }
}
 
void APixoVRLaser::ServerTriggerSelect_Implementation(bool State, AActor* InteractableObject, const FHitResult& HitResult, APlayerController* Executor)
{
    if (State)
    {
        IPixoVRInteractionInterface::Execute_OnPressBegin(InteractableObject, HitResult, Executor);
    }
    else
    {
        IPixoVRInteractionInterface::Execute_OnPressEnd(InteractableObject, HitResult, Executor);
    }
}
 
bool APixoVRLaser::ServerTriggerSelect_Validate(bool State, AActor* InteractableObject, const FHitResult& HitResult, APlayerController* Executor)
{
    return true;
}
 
bool APixoVRLaser::IsActivated() const
{
    return bIsLaserBeamActive;
}
 
#if WITH_EDITOR
void APixoVRLaser::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
    if(PropertyChangedEvent.Property != nullptr)
    {
        const FName PropertyName (PropertyChangedEvent.Property->GetFName());
        if(PropertyName == GET_MEMBER_NAME_CHECKED(APixoVRLaser, LaserBeamMaxDistance))
        {
            if(bLinkToInteraction)
            {
                WidgetInteraction->InteractionDistance = LaserBeamMaxDistance;
            }
        }
    }
 
    Super::PostEditChangeProperty(PropertyChangedEvent);
}
#endif