TeleporterBase.cpp

Go to the documentation of this file.

// Copyright(c) 2018 PixoVR, LLC. All Rights Reserved.
 
 
#include "CharacterTools/Teleporters/TeleporterBase.h"
 
#include "PixoVRCharacter.h"
 
 
// Sets default values
ATeleporterBase::ATeleporterBase()
    : MotionController(nullptr)
    , bIsTeleporterActive(false)
    , bIsValidTeleportDestination(false)
    , bDrawArcSpline(true)
    , bDrawTeleportArrow(false)
    , TeleportLaunchVelocity(1200.f)
    , TeleportRotation(FRotator::ZeroRotator)
    , PadRotation(FRotator::ZeroRotator)
    , FadeInDuration(0.25f)
    , FadeOutDuration(0.25f)
    , ThumbDeadZone(0.5f)
 {
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
 
    bReplicates = true;
    SetReplicateMovement(false);
    bNetLoadOnClient = false;
    
    static ConstructorHelpers::FObjectFinder<UStaticMesh> ArcSplineMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/Controller/BeamMesh.BeamMesh'"));
    ArcSplineMesh = ArcSplineMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UMaterial> ArcSplineMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/SplineArcMaterial.SplineArcMaterial'"));
    ArcSplineMaterial = ArcSplineMaterialFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UStaticMesh> ArcEndPointMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/BasicShapes/Sphere.Sphere'"));
    UStaticMesh* ArcEndPointMesh = ArcEndPointMeshFinder.Object;
    
    static ConstructorHelpers::FObjectFinder<UMaterial> ArcEndPointMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/ArcEndpointMaterial.ArcEndpointMaterial'"));
    UMaterial* ArcEndPointMaterial = ArcEndPointMaterialFinder.Object;
 
    USceneComponent* SceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("TeleportSceneComponent"));
    RootComponent = SceneComponent;
 
    // Arc Spline.
    ArcSplineComponent = CreateDefaultSubobject<USplineComponent>(TEXT("ArcSpline"));
    ArcSplineComponent->SetupAttachment(SceneComponent);
    ArcSplineComponent->SetWorldLocation(FVector(12.53f, -1.76f, 2.55f));
 
    // Arc Endpoint.
    ArcEndPoint = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ArcEndPoint"));
    ArcEndPoint->SetupAttachment(SceneComponent);
    ArcEndPoint->SetWorldScale3D(FVector(0.08f, 0.08f, 0.08f));
    ArcEndPoint->SetStaticMesh(ArcEndPointMesh);
    ArcEndPoint->SetMaterial(0, ArcEndPointMaterial);
    ArcEndPoint->SetVisibility(false, true);
    ArcEndPoint->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    ArcEndPoint->SetGenerateOverlapEvents(false);
    ArcEndPoint->SetAbsolute(true, true, true);
 
    // Teleport Cylinder Arrow.
    static ConstructorHelpers::FObjectFinder<UStaticMesh> CylinderArrowMeshFinder(TEXT("StaticMesh'/PixoCore/Meshes/Controller/BeaconDirection.BeaconDirection'"));
    UStaticMesh* CylinderArrowMesh = CylinderArrowMeshFinder.Object;
 
    Arrow = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Arrow"));
    Arrow->SetupAttachment(SceneComponent);
    Arrow->SetStaticMesh(CylinderArrowMesh);
    Arrow->SetMaterial(0, ArcEndPointMaterial);
    Arrow->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    Arrow->SetGenerateOverlapEvents(false);
    Arrow->SetVisibility(false, true);
}
 
// Called when the game starts or when spawned
void ATeleporterBase::BeginPlay()
{
    Super::BeginPlay();
}
 
void ATeleporterBase::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
 
    if(bIsTeleporterActive)
    {
        TickTeleporter(DeltaTime);
    }
}
 
void ATeleporterBase::UpdateArcSpline(TArray<FVector>& SplinePoints, bool ValidLocationFound)
{
    ArcSplineComponent->ClearSplinePoints(true);
 
    if(ValidLocationFound)
    {
        for(auto& SplinePoint : SplinePoints)
        {
            ArcSplineComponent->AddSplinePoint(SplinePoint, ESplineCoordinateSpace::Local, true);
        }
 
        ArcSplineComponent->SetSplinePointType(SplinePoints.Num() - 1, ESplinePointType::CurveClamped, true);
 
        if(SplineMeshComponents.Num() < ArcSplineComponent->GetNumberOfSplinePoints())
        {
            const int32 NumberOfSplinesToAdd = (ArcSplineComponent->GetNumberOfSplinePoints() - 1) - SplineMeshComponents.Num();
 
            for(int32 Index = 0; Index <= NumberOfSplinesToAdd; Index++)
            {
                USplineMeshComponent* SplineMeshComponent = NewObject<USplineMeshComponent>(this);
 
                SplineMeshComponent->SetMobility(EComponentMobility::Movable);
                SplineMeshComponent->SetStartPosition(FVector(0.0f, 0.0f, 0.0f), true);
                SplineMeshComponent->SetStartTangent(FVector(100.0f, 0.0f, 0.0f), true);
                SplineMeshComponent->SetEndPosition(FVector(100.0f, 0.0f, 0.0f), true);
                SplineMeshComponent->SetEndTangent(FVector(100.0f, 0.0f, 0.0f), true);
                SplineMeshComponent->SetSplineUpDir(FVector(0.0f, 0.0f, 1.0f), true);
                SplineMeshComponent->SetForwardAxis(ESplineMeshAxis::X, true);
                SplineMeshComponent->SetStartScale(FVector2D(4, 4));
                SplineMeshComponent->SetEndScale(FVector2D(4, 4));
                SplineMeshComponent->SetStaticMesh(ArcSplineMesh);
                SplineMeshComponent->SetMaterial(0, ArcSplineMaterial);
                SplineMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
                SplineMeshComponent->SetGenerateOverlapEvents(false);
 
                FTransform Transform = FTransform(FRotator(0.0f, 0.0f, 0.0f), FVector(0.0f, 0.0f, 0.0f), FVector(1.0f, 1.0f, 1.0f));
                SplineMeshComponent->SetRelativeTransform(Transform);
                SplineMeshComponent->RegisterComponent();
 
                SplineMeshComponents.Add(SplineMeshComponent);
            }
        }
 
        // Update the start/end points of the spline components.
        for(int32 Index = 0; Index < SplineMeshComponents.Num(); Index++)
        {
            USplineMeshComponent* SplineMeshComponent = SplineMeshComponents[Index];
 
            if(Index < (ArcSplineComponent->GetNumberOfSplinePoints() - 1))
            {
                SplineMeshComponent->SetVisibility(true, false);
 
                const auto StartTangent = ArcSplineComponent->GetTangentAtSplinePoint(Index, ESplineCoordinateSpace::Local);
                const auto EndTangent = ArcSplineComponent->GetTangentAtSplinePoint(Index + 1, ESplineCoordinateSpace::Local);
 
                SplineMeshComponent->SetStartAndEnd(SplinePoints[Index], StartTangent, SplinePoints[Index + 1], EndTangent, true);
            }
            else
            {
                // Unused spline components we better hide.
                SplineMeshComponent->SetVisibility(false, false);
            }
        }
    }
    else
    {
        // TODO For now we just hide all splines when we don't have a valid teleport location.
        for(int32 Index = 0; Index < SplineMeshComponents.Num(); Index++)
        {
            USplineMeshComponent* SplineMeshComponent = SplineMeshComponents[Index];
            SplineMeshComponent->SetVisibility(false, false);
        }
    }
}
 
void ATeleporterBase::ClearArc()
{
    for(const auto& SplineMeshComponent : SplineMeshComponents)
    {
        SplineMeshComponent->DestroyComponent();
    }
 
    SplineMeshComponents.Empty();
 
    ArcSplineComponent->ClearSplinePoints(true);
}
 
void ATeleporterBase::Destroyed()
{
    Super::Destroyed();
 
    ClearArc();
}
 
void ATeleporterBase::ActivateTeleporter(bool InActivate)
{
    if(InActivate == bIsTeleporterActive)
    {
        return;
    }
 
    bIsTeleporterActive = InActivate;
 
    // Enable/Disable ticking for this actor.
    SetActorTickEnabled(bIsTeleporterActive);
 
    // Hide/Show the arc splines.
    ArcSplineComponent->SetVisibility(InActivate && bDrawArcSpline, true);
 
    // Handle visibility of the arrow if it is enabled.
    Arrow->SetVisibility(InActivate && bDrawTeleportArrow, true);
 
    // The ArchEndPoint is activated inside UpdateArchEndPoint. We deactivate definitely when
    // InActivate = false.
    if(!InActivate)
    {
        ArcEndPoint->SetVisibility(false, false);
        ClearArc();
    }
}
 
bool ATeleporterBase::IsActivated()
{
    return bIsTeleporterActive;
}
 
void ATeleporterBase::UpdateArcEndpoint(const FVector& NewLocation, bool ValidLocationFound) 
{
    ArcEndPoint->SetVisibility(ValidLocationFound, true);
    ArcEndPoint->SetWorldLocation(NewLocation, false, nullptr, ETeleportType::TeleportPhysics);
}
 
FVector ATeleporterBase::GetTeleportDestination(const FVector& OriginalLocation) 
{
    APixoVRCharacter* PixoVRCharacter = Cast<APixoVRCharacter>(GetOwner());
    FVector Offset = PixoVRCharacter->VRRootReference->OffsetComponentToWorld.GetLocation() - PixoVRCharacter->GetActorLocation();
    Offset.Z = 0.0f;
    return OriginalLocation - Offset;
}
 
void ATeleporterBase::GetTeleportationTransform(FVector& Location, FVector& ForwardVector)
{
    Location = RootComponent->GetComponentLocation();
    ForwardVector = RootComponent->GetForwardVector();
}
 
void ATeleporterBase::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
    DOREPLIFETIME(ATeleporterBase, MotionController);
}
 
void ATeleporterBase::UpdateMotionControllerRotation(const FVector2D& Direction) 
{
    if(!bIsTeleporterActive && !bDrawTeleportArrow)
    {
        return;
    }
 
    PadRotation = GetRotationFromInput(Direction);
}
 
FRotator ATeleporterBase::GetRotationFromInput(const FVector2D& Direction)
{
    // Rotate input X+Y always point forward relative to the current pawn rotation.
    FVector A(Direction.X, Direction.Y, 0.0f);
 
    // We should normalize the vector.
    A.Normalize();
 
    // Check whether thumb in near center (ignore rotation overrides).
    const bool Condition = A.Size() > ThumbDeadZone;
    if(Condition)
    {
        FRotator CharacterRotation = GetOwner()->GetActorRotation();
        CharacterRotation.Roll = 0.0f;
        CharacterRotation.Pitch = 0.0f;
 
        const FVector RotatedVector = CharacterRotation.RotateVector(A);
        return RotatedVector.Rotation();
    }
 
    return FRotator::ZeroRotator;
}
 
void ATeleporterBase::SetMotionController(UGripMotionControllerComponent* InMotionController)
{
    MotionController = InMotionController;
}