BySpotTeleporter.cpp

Go to the documentation of this file.

// Copyright(c) 2018 PixoVR, LLC. All Rights Reserved.
 
 
#include "CharacterTools/Teleporters/BySpotTeleporter.h"
 
#include "PixoVRCharacter.h"
#include "EventSystem/Events/Fade/FadeInAndFadeOutEvent.h"
#include "Kismet/GameplayStatics.h"
#include "Kismet/KismetMathLibrary.h"
 
ATeleportersSpot::ATeleportersSpot()
{
    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<UMaterial> TeleportCylinderMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/TeleportSpot/M_TeleportSpotPreviews.M_TeleportSpotPreviews'"));
    UMaterial* CylinderMaterial = TeleportCylinderMaterialFinder.Object;
 
    static ConstructorHelpers::FObjectFinder<UMaterial> ArcEndPointMaterialFinder(TEXT("Material'/PixoCore/Materials/Controller/TeleportSpot/M_TeleporterSpotMaterial.M_TeleporterSpotMaterial'"));
    UMaterial* ArcEndPointMaterial = ArcEndPointMaterialFinder.Object;
 
    TeleportersSpotCylinder = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("TeleportersSpotCylinder"));
    TeleportersSpotCylinder->SetupAttachment(RootComponent);
    TeleportersSpotCylinder->SetWorldScale3D(FVector(0.75f, 0.75f, 1.0f));
    TeleportersSpotCylinder->SetStaticMesh(CylinderMesh);
    TeleportersSpotCylinder->SetMaterial(0, CylinderMaterial);
    TeleportersSpotCylinder->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    TeleportersSpotCylinder->SetGenerateOverlapEvents(false);
    TeleportersSpotCylinder->SetAbsolute(true, true, true);
    TeleportersSpotCylinder->SetVisibility(false);
 
    TeleportersSpotRing = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("TeleportersSpotRing"));
    TeleportersSpotRing->SetupAttachment(TeleportersSpotCylinder);
    TeleportersSpotRing->SetRelativeScale3D(FVector(0.5f, 0.5f, 0.15f));
    TeleportersSpotRing->SetStaticMesh(CylinderRingMesh);
    TeleportersSpotRing->SetMaterial(0, ArcEndPointMaterial);
    TeleportersSpotRing->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
    TeleportersSpotRing->SetGenerateOverlapEvents(false);
    TeleportersSpotRing->SetVisibility(false);
}
 
void ATeleportersSpot::BeginPlay()
{
    Super::BeginPlay();
 
    if (TeleportersSpotCylinder)
    {
        CylinderMaterialInstanceDynamic = UMaterialInstanceDynamic::Create(TeleportersSpotCylinder->GetMaterial(0), nullptr);
        TeleportersSpotCylinder->SetMaterial(0, CylinderMaterialInstanceDynamic);
    }
 
    if (TeleportersSpotRing)
    {
        RingMaterialInstanceDynamic = UMaterialInstanceDynamic::Create(TeleportersSpotRing->GetMaterial(0), nullptr);
        TeleportersSpotRing->SetMaterial(0, RingMaterialInstanceDynamic);
    }
 
    ActivateSpot(false);
}
 
void ATeleportersSpot::ActivateSpot(bool InActivate)
{
    if (CylinderMaterialInstanceDynamic && RingMaterialInstanceDynamic)
    {
        bIsActive = InActivate;
        if (InActivate)
        {
            CylinderMaterialInstanceDynamic->SetVectorParameterValue("Color", FLinearColor(ActiveColorOfSpot));
            RingMaterialInstanceDynamic->SetVectorParameterValue("Color", FLinearColor(ActiveColorOfSpot));
        }
        else
        {
            CylinderMaterialInstanceDynamic->SetVectorParameterValue("Color", FLinearColor(NotActiveColorOfSpot));
            RingMaterialInstanceDynamic->SetVectorParameterValue("Color", FLinearColor(NotActiveColorOfSpot));
        }
    }
}
 
bool ATeleportersSpot::IsActive()
{
    return bIsActive;
}
 
ABySpotTeleporter::ABySpotTeleporter()
{
}
 
void ABySpotTeleporter::BeginPlay()
{
    Super::BeginPlay();
 
    TArray<AActor*> FoundActors;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), ATeleportersSpot::StaticClass(), FoundActors);
    TeleportersSpots.Empty();
    for (auto FoundActor : FoundActors)
    {
        TeleportersSpots.Add(Cast<ATeleportersSpot>(FoundActor));
    }
}
 
void ABySpotTeleporter::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);
 
    ATeleportersSpot* LastValidTeleportersSpot = nullptr;
    FVector LastValidTeleportLocation;
    for (auto TeleportersSpot : TeleportersSpots)
    {
        if (TeleportersSpot->IsActive())
        {
            LastValidTeleportLocation = TeleportersSpot->TeleportersSpotCylinder->GetComponentLocation();
            LastValidTeleportersSpot = TeleportersSpot;
        }
    }
 
    // const FVector LastValidTeleportLocation = TeleportCylinder->GetComponentLocation();
    const FVector TeleportToLocation = GetTeleportDestination(LastValidTeleportLocation);
 
    UVRExpansionFunctionLibrary::RotateAroundPivot(FRotator::ZeroRotator, TeleportToLocation, ActorRotation, InvPivotPoint, TimedLocation, TimedRotation, true);
 
    auto FadeInFinishedEvent = [this, LastValidTeleportersSpot, PixoVRCharacter]()
    {
        MovementComponent->PerformMoveAction_Teleport(TimedLocation, TimedRotation);
        LastValidTeleportersSpot->OnCharacterTeleportedOnSpot.Broadcast(LastValidTeleportersSpot, PixoVRCharacter);
    };
 
    EventLogService::NewEvent<UFadeInAndFadeOutEvent>(nullptr, FadeInFinishedEvent, nullptr, FadeInDuration, 0.0f, FadeOutDuration);
 
    DeactivateAllSpots();
}
 
void ABySpotTeleporter::ActivateTeleporter(bool InActivate)
{
    if (AtListOneTeleportersActive() && InActivate)
    {
        return;
    }
 
    Super::ActivateTeleporter(InActivate);
 
    for (auto TeleportersSpot : TeleportersSpots)
    {
        TeleportersSpot->TeleportersSpotCylinder->SetVisibility(InActivate);
        TeleportersSpot->TeleportersSpotRing->SetVisibility(InActivate);
    }
}
 
void ABySpotTeleporter::TickTeleporter(float DeltaTime)
{
    TArray<FVector> TracePoints;
 
    // Is the location of the projectile falling onto the ground.
    FVector TraceLocation;
 
    bIsValidTeleportDestination = TraceTeleportDestination(TracePoints, TraceLocation);
 
    if(bDrawArcSpline)
    {
        UpdateArcSpline(TracePoints, true);
    }
 
    UpdateArcEndpoint(TraceLocation, bIsValidTeleportDestination);
}
 
bool ABySpotTeleporter::TraceTeleportDestination(TArray<FVector>& TracePoints, FVector& TraceLocation)
{
    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);
 
    if (!bHit)
    {
        return false;
    }
 
    FHitResult HitResult;
    HitResult = PredictResult.HitResult;
    TracePoints.Empty(PredictResult.PathData.Num());
    
    for (const FPredictProjectilePathPointData& PathPoint : PredictResult.PathData)
    {
        TracePoints.Add(PathPoint.Location);
    }
 
    TraceLocation = HitResult.Location;
 
    for (auto TeleportersSpot : TeleportersSpots)
    {
        FTransform CylinderTransform = TeleportersSpot->TeleportersSpotCylinder->GetComponentTransform();
        FVector CylinderScale = CylinderTransform.GetScale3D();
        FVector RingScale = TeleportersSpot->TeleportersSpotRing->GetComponentTransform().GetScale3D();
 
        float CylinderRadius = TeleportersSpot->TeleportersSpotCylinder->Bounds.SphereRadius * CylinderScale.GetMax() + TeleportersSpot->BufferBoundsRadiusDetection;
        float CylinderHalfHeight = TeleportersSpot->TeleportersSpotRing->Bounds.BoxExtent.Z * RingScale.Z + TeleportersSpot->BufferBoundsHeightDetection;
 
        FVector LocationRelativeToComponent = CylinderTransform.InverseTransformPosition(TraceLocation);
        if (TeleportersSpot->IsSpotHaveCubeShape)
        {
            if (FMath::Abs(LocationRelativeToComponent.X) <= TeleportersSpot->TeleportersSpotCylinder->Bounds.BoxExtent.X*SpotTeleporterExtendCoeficient &&
            FMath::Abs(LocationRelativeToComponent.Y) <= TeleportersSpot->TeleportersSpotCylinder->Bounds.BoxExtent.Y*SpotTeleporterExtendCoeficient &&
            FMath::Abs(LocationRelativeToComponent.Z) <= CylinderHalfHeight)
            {
                DeactivateAllSpots();
                TeleportersSpot->ActivateSpot(true);
                return true;
            }
        }
        else //for sphere shapes
        {
            float DistanceToCenterXY = LocationRelativeToComponent.Size2D();
 
            if (DistanceToCenterXY <= CylinderRadius && FMath::Abs(LocationRelativeToComponent.Z) <= CylinderHalfHeight)
            {
                DeactivateAllSpots();
                TeleportersSpot->ActivateSpot(true);
                return true;
            }
        }
    }
 
    DeactivateAllSpots();
 
    return false;
}
 
void ABySpotTeleporter::DeactivateAllSpots()
{
    for (auto TeleportersSpot : TeleportersSpots)
    {
        TeleportersSpot->ActivateSpot(false);
    }
}
 
bool ABySpotTeleporter::AtListOneTeleportersActive()
{
    APixoVRCharacter* PixoVRCharacter = Cast<APixoVRCharacter>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
    return PixoVRCharacter->TeleportControllerLeft->IsActivated() || PixoVRCharacter->TeleportControllerRight->IsActivated();
}