PixoVRTeleporter.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "CharacterTools/Teleporters/PixoVRTeleporter.h"
#include "Components/StaticMeshComponent.h"
#include "Components/WidgetInteractionComponent.h"
#include "Kismet/GameplayStatics.h"
#include "NavigationSystem.h"
#include "VRExpansionFunctionLibrary.h"
#include "PixoVRCharacter.h"
#include "EventSystem/EventLogService.h"
#include "EventSystem/Events/Fade/FadeInAndFadeOutEvent.h"
#include "Kismet/KismetMathLibrary.h"
 
#define TELEPORT_DEBUG 0
 
DEFINE_LOG_CATEGORY(LogPixoVRTeleporter);
 
APixoVRTeleporter::APixoVRTeleporter()
    : TeleportCylinder(nullptr)
    , Ring(nullptr)
    , bDrawTeleportCylinder(true)
    , TeleportFadeColor(FLinearColor::Black)
    , NavigationSystem(nullptr)
{
    static ConstructorHelpers::FObjectFinder<UStaticMesh> CylinderMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/BasicShapes/Cylinder.Cylinder'"));
    UStaticMesh* CylinderMesh = CylinderMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UStaticMesh> CylinderRingMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/Controller/SM_FatCylinder.SM_FatCylinder'"));
    UStaticMesh* CylinderRingMesh = CylinderRingMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UMaterialInstance> TeleportCylinderMaterialFinder(TEXT("MaterialInstanceConstant'/PixoCore/Materials/Controller/TeleportCylinderPreviewMaterialInstance.TeleportCylinderPreviewMaterialInstance'"));
    UMaterialInstance* CylinderMaterial = TeleportCylinderMaterialFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UMaterial> ArcEndPointMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/ArcEndpointMaterial.ArcEndpointMaterial'"));
    UMaterial* ArcEndPointMaterial = ArcEndPointMaterialFinder.Object;
 
    // Teleport Cylinder.
    TeleportCylinder = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("TeleportCylinder"));
    TeleportCylinder->SetupAttachment(RootComponent);
    TeleportCylinder->SetWorldScale3D(FVector(0.75f, 0.75f, 1.0f));
    TeleportCylinder->SetStaticMesh(CylinderMesh);
    TeleportCylinder->SetMaterial(0, CylinderMaterial);
    TeleportCylinder->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    TeleportCylinder->SetGenerateOverlapEvents(false);
    TeleportCylinder->SetAbsolute(true, true, true);
 
    // Teleport Cylinder Ring.
    Ring = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Ring"));
    Ring->SetupAttachment(TeleportCylinder);
    Ring->SetRelativeScale3D(FVector(0.5f, 0.5f, 0.15f));
    Ring->SetStaticMesh(CylinderRingMesh);
    Ring->SetMaterial(0, ArcEndPointMaterial);
    Ring->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    Ring->SetGenerateOverlapEvents(false);
}
 
void APixoVRTeleporter::ActivateTeleporter(bool InActivate)
{
    Super::ActivateTeleporter(InActivate);
 
    // Hide/Show the teleport cylinder.
    if(bDrawTeleportCylinder)
    {
        TeleportCylinder->SetVisibility(InActivate, true);
    }
}
 
void APixoVRTeleporter::BeginPlay()
{
    Super::BeginPlay();
 
    TeleportCylinder->SetVisibility(false, true);
 
    NavigationSystem = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
}
 
void APixoVRTeleporter::TickTeleporter(float DeltaTime)
{
    TArray<FVector> TracePoints;
 
    // Is the location of the projectile falling onto the ground.
    FVector TraceLocation;
 
    // The projects location will be mapped to the Nav Mesh location.
    FVector NavMeshLocation;
 
    bIsValidTeleportDestination = TraceTeleportDestination(TracePoints, TraceLocation, NavMeshLocation);
 
    if(bDrawArcSpline)
    {
        UpdateArcSpline(TracePoints, bIsValidTeleportDestination);
    }
 
    if(bDrawTeleportCylinder)
    {
        TeleportCylinder->SetVisibility(bIsValidTeleportDestination, true);
    }
    
    UpdateTeleportCylinder(NavMeshLocation, bIsValidTeleportDestination);
    UpdateArcEndpoint(TraceLocation, bIsValidTeleportDestination);
 
    // We prepare the rotation of the teleport cylinder.
    if(PadRotation != FRotator::ZeroRotator)
    {
        // User changed rotation using the otion Controller Pad.
        TeleportRotation = PadRotation;
    }
    else
    {
        // If we don't have any Motion Controller Pad rotation, set pitch and roll to zero.
        // and use previous Yaw rotation.
        TeleportRotation.Pitch = 0.0f;
        TeleportRotation.Roll = 0.0f;
    }
 
#if TELEPORT_DEBUG
    // The following lines can be all deleted. It exists only for debug purpose.
    FVector DevicePosition = FVector::ZeroVector;
    FRotator DeviceRotation = FRotator::ZeroRotator;
    UHeadMountedDisplayFunctionLibrary::GetOrientationAndPosition(DeviceRotation, DevicePosition);
    DevicePosition.Z = 0.0f;
    FVector Correction = UKismetMathLibrary::GreaterGreater_VectorRotator(DevicePosition, TeleportRotation);
 
    FVector HMDPositionInWorldSpace =  GetOwner()->GetActorLocation() - DevicePosition;
    APixoVRCharacter* PixoVRCharacter = Cast<APixoVRCharacter>(GetOwner());
    HMDPositionInWorldSpace = PixoVRCharacter->GetVRLocation();
    HMDPositionInWorldSpace.Z = 30.0f;
    FVector OwnerActorLocation = GetOwner()->GetActorLocation();
    OwnerActorLocation.Z += 10.0f;
    UKismetSystemLibrary::DrawDebugLine(this, OwnerActorLocation, TeleportCylinder->GetComponentLocation(), FColor::Red, 0.0f, 2.0f);
    UKismetSystemLibrary::DrawDebugLine(this, OwnerActorLocation, HMDPositionInWorldSpace, FColor::Green, 0.0f, 2.0f);
#endif
}
 
bool APixoVRTeleporter::TraceTeleportDestination(TArray<FVector>& TracePoints, FVector& TraceLocation, FVector& NavMeshLocation) 
{
    FVector StartPos(FVector::ZeroVector);
    FVector LaunchVelocity (FVector::ZeroVector);
 
    GetTeleportationTransform(StartPos, LaunchVelocity);
    LaunchVelocity *= TeleportLaunchVelocity;
 
    TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes;
    ObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldStatic));
 
    FPredictProjectilePathParams Params;
    Params.bTraceWithCollision = true;
    Params.bTraceComplex = false;
    Params.DrawDebugType = EDrawDebugTrace::None;
    Params.DrawDebugTime = 0.0f;
    Params.SimFrequency = 30.0f;
    Params.OverrideGravityZ = 0.0f;
    Params.ObjectTypes = ObjectTypes;
    Params.bTraceWithChannel = false;
    Params.ProjectileRadius = 0.0f;
    Params.StartLocation = StartPos;
    Params.MaxSimTime = 2.0f;
    Params.LaunchVelocity = LaunchVelocity;
    
    FPredictProjectilePathResult PredictResult;
    bool bHit = UGameplayStatics::PredictProjectilePath(this, Params, PredictResult);
 
    FHitResult HitResult;
    FVector LastTraceDestination;
 
    HitResult = PredictResult.HitResult;
    LastTraceDestination = PredictResult.LastTraceDestination.Location;
    TracePoints.Empty(PredictResult.PathData.Num());
    
    for (const FPredictProjectilePathPointData& PathPoint : PredictResult.PathData)
    {
        TracePoints.Add(PathPoint.Location);
    }
    
    TraceLocation = HitResult.Location;
 
    bool bProjectPointToNavigation = false;
    if (NavigationSystem)
    {
        FVector QueryingExtent (500.0f, 500.0f, 500.0f);
        FNavLocation NavLocation {};
 
        bProjectPointToNavigation = NavigationSystem->ProjectPointToNavigation(HitResult.Location, NavLocation, QueryingExtent);
        NavMeshLocation = NavLocation.Location;
    }
 
    bProjectPointToNavigation = (NavMeshLocation != FVector(0.0f, 0.0f, 0.0f)) && (TraceLocation != NavMeshLocation);
 
    return bHit & bProjectPointToNavigation;
}
 
void APixoVRTeleporter::UpdateTeleportCylinder(const FVector& NavMeshLocation, bool ValidLocationFound)
{
    if(ValidLocationFound)
    {
        const auto Start = NavMeshLocation;
        const auto End = Start + FVector(0.0f, 0.0f, -200.0f);
        TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes;
        ObjectTypes.Add(UEngineTypes::ConvertToObjectType(ECC_WorldStatic));
        const auto TraceComplex = false;
        const TArray<AActor*> ActorsToIgnore;
        const auto IgnoreSelf = true;
        FHitResult HitResult;
        const float DrawTime = 5.0;
 
        UKismetSystemLibrary::LineTraceSingleForObjects(this,
                                                        Start,
                                                        End,
                                                        ObjectTypes,
                                                        TraceComplex,
                                                        ActorsToIgnore,
                                                        EDrawDebugTrace::None,
                                                        HitResult,
                                                        IgnoreSelf,
                                                        FLinearColor::Red,
                                                        FLinearColor::Green,
                                                        DrawTime);
 
        FVector NewLocation = FVector::ZeroVector;
        if(HitResult.bBlockingHit)
        {
            NewLocation = HitResult.ImpactPoint;
        }
        else
        {
            NewLocation = NavMeshLocation;
        }
 
        TeleportCylinder->SetWorldLocation(NewLocation, false, nullptr, ETeleportType::TeleportPhysics);
    }
    else
    {
        // TODO Do we want to do something here if we have no valid location?
    }
}
 
#if WITH_EDITOR
void APixoVRTeleporter::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
    if(PropertyChangedEvent.Property != nullptr)
    {
        const FName PropertyName (PropertyChangedEvent.Property->GetFName());
        if(PropertyName == GET_MEMBER_NAME_CHECKED(APixoVRTeleporter, bDrawTeleportArrow))
        {
            Arrow->SetVisibility(bDrawTeleportArrow, false);
        }
    }
 
    Super::PostEditChangeProperty(PropertyChangedEvent);
}
#endif
 
void APixoVRTeleporter::ExecuteTeleportation(UVRBaseCharacterMovementComponent* InMovementComponent, const FTransform& ActorTransform, const FVector& VRLocation, const FRotator& ActorRotation)
{
    // If we don't have a valid destination, don't execute teleportation.
    if(!bIsValidTeleportDestination)
    {
        return;
    }
 
    APixoVRCharacter* PixoVRCharacter = Cast<APixoVRCharacter>(GetOwner());
    if (PixoVRCharacter)
    {
        if (PixoVRCharacter->bTeleportSoundsEnabled && PixoVRCharacter->TeleportSoundCue)
        {
            UGameplayStatics::PlaySound2D(this, PixoVRCharacter->TeleportSoundCue);
        }
    }
    
    MovementComponent = InMovementComponent;
    
    const FVector PivotPoint = VRLocation;
    const FVector InvPivotPoint = UKismetMathLibrary::InverseTransformLocation(ActorTransform, PivotPoint);
 
    const FVector LastValidTeleportLocation = TeleportCylinder->GetComponentLocation();
    const FVector TeleportToLocation = GetTeleportDestination(LastValidTeleportLocation);
 
    UVRExpansionFunctionLibrary::RotateAroundPivot(FRotator::ZeroRotator, TeleportToLocation, ActorRotation, InvPivotPoint, TimedLocation, TimedRotation, true);
 
    auto FadeInFinishedEvent = [this]()
    {
        MovementComponent->PerformMoveAction_Teleport(TimedLocation, TimedRotation);
    };
 
    EventLogService::NewEvent<UFadeInAndFadeOutEvent>(nullptr, FadeInFinishedEvent, nullptr, FadeInDuration, 0.0f, FadeOutDuration);
}