AALSPlayerCameraManager Class Reference

#include <ALSPlayerCameraManager.h>

Inheritance diagram for AALSPlayerCameraManager:

Public Member Functions
	AALSPlayerCameraManager ()
void	OnPossess (AALSBaseCharacter *NewCharacter)
float	GetCameraBehaviorParam (FName CurveName) const
void	DrawDebugTargets (FVector PivotTargetLocation)

Public Attributes
TObjectPtr< AALSBaseCharacter >	ControlledCharacter = nullptr
TObjectPtr< USkeletalMeshComponent >	CameraBehavior = nullptr

Protected Member Functions
virtual void	UpdateViewTargetInternal (FTViewTarget &OutVT, float DeltaTime) override
bool	CustomCameraBehavior (float DeltaTime, FVector &Location, FRotator &Rotation, float &FOV)

Static Protected Member Functions
static FVector	CalculateAxisIndependentLag (FVector CurrentLocation, FVector TargetLocation, FRotator CameraRotation, FVector LagSpeeds, float DeltaTime)

Protected Attributes
FVector	RootLocation
FTransform	SmoothedPivotTarget
FVector	PivotLocation
FVector	TargetCameraLocation
FRotator	TargetCameraRotation
FRotator	DebugViewRotation
FVector	DebugViewOffset

Private Attributes
TObjectPtr< UALSDebugComponent >	ALSDebugComponent = nullptr

Detailed Description

Player camera manager class

Constructor & Destructor Documentation

AALSPlayerCameraManager()

AALSPlayerCameraManager::AALSPlayerCameraManager

(

)

{
    CameraBehavior = CreateDefaultSubobject<USkeletalMeshComponent>(NAME_CameraBehavior);
    CameraBehavior->SetupAttachment(GetRootComponent());
    CameraBehavior->bHiddenInGame = true;
}

Member Function Documentation

CalculateAxisIndependentLag()

FVector AALSPlayerCameraManager::CalculateAxisIndependentLag ( FVector CurrentLocation, FVector TargetLocation, FRotator CameraRotation, FVector LagSpeeds, float DeltaTime )

staticprotected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSPlayerCameraManager::CalculateAxisIndependentLag);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Camera_Manager);
 
    CameraRotation.Roll = 0.0f;
    CameraRotation.Pitch = 0.0f;
    const FVector UnrotatedCurLoc = CameraRotation.UnrotateVector(CurrentLocation);
    const FVector UnrotatedTargetLoc = CameraRotation.UnrotateVector(TargetLocation);
 
    const FVector ResultVector(
        FMath::FInterpTo(UnrotatedCurLoc.X, UnrotatedTargetLoc.X, DeltaTime, LagSpeeds.X),
        FMath::FInterpTo(UnrotatedCurLoc.Y, UnrotatedTargetLoc.Y, DeltaTime, LagSpeeds.Y),
        FMath::FInterpTo(UnrotatedCurLoc.Z, UnrotatedTargetLoc.Z, DeltaTime, LagSpeeds.Z));
 
    return CameraRotation.RotateVector(ResultVector);
}

CustomCameraBehavior()

bool AALSPlayerCameraManager::CustomCameraBehavior ( float DeltaTime, FVector & Location, FRotator & Rotation, float & FOV )

protected

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSPlayerCameraManager::CustomCameraBehavior);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Camera_Manager);
 
    if (!ControlledCharacter)
    {
        return false;
    }
 
    // Step 1: Get Camera Parameters from CharacterBP via the Camera Interface
    const FTransform& PivotTarget = ControlledCharacter->GetThirdPersonPivotTarget();
    const FVector& FPTarget = ControlledCharacter->GetFirstPersonCameraTarget();
    const FVector& ADSTarget = ControlledCharacter->GetAimDownSightCameraTarget();
 
    float TPFOV = 90.0f;
    float FPFOV = 90.0f;
    bool bRightShoulder = false;
    const float ADSFOV = ControlledCharacter->GetAimDownSightFOV();
    ControlledCharacter->GetCameraParameters(TPFOV, FPFOV, bRightShoulder);
 
    // Step 2: Calculate Target Camera Rotation. Use the Control Rotation and interpolate for smooth camera rotation.
    const FRotator& InterpResult = FMath::RInterpTo(GetCameraRotation(),
                                                    GetOwningPlayerController()->GetControlRotation(), DeltaTime,
                                                    GetCameraBehaviorParam(NAME_RotationLagSpeed));
 
    TargetCameraRotation = UKismetMathLibrary::RLerp(InterpResult, DebugViewRotation,
                                                     GetCameraBehaviorParam(TEXT("Override_Debug")), true);
 
    // Step 3: Calculate the Smoothed Pivot Target (Orange Sphere).
    // Get the 3P Pivot Target (Green Sphere) and interpolate using axis independent lag for maximum control.
    const FVector LagSpd(GetCameraBehaviorParam(NAME_PivotLagSpeed_X),
                         GetCameraBehaviorParam(NAME_PivotLagSpeed_Y),
                         GetCameraBehaviorParam(NAME_PivotLagSpeed_Z));
 
    const FVector& AxisIndpLag = CalculateAxisIndependentLag(SmoothedPivotTarget.GetLocation(),
                                                             PivotTarget.GetLocation(), TargetCameraRotation, LagSpd,
                                                             DeltaTime);
 
    SmoothedPivotTarget.SetRotation(PivotTarget.GetRotation());
    SmoothedPivotTarget.SetLocation(AxisIndpLag);
    SmoothedPivotTarget.SetScale3D(FVector::OneVector);
 
    // Step 4: Calculate Pivot Location (BlueSphere). Get the Smoothed
    // Pivot Target and apply local offsets for further camera control.
    PivotLocation =
        SmoothedPivotTarget.GetLocation() +
        UKismetMathLibrary::GetForwardVector(SmoothedPivotTarget.Rotator()) * GetCameraBehaviorParam(
            NAME_PivotOffset_X) +
        UKismetMathLibrary::GetRightVector(SmoothedPivotTarget.Rotator()) * GetCameraBehaviorParam(
            NAME_PivotOffset_Y) +
        UKismetMathLibrary::GetUpVector(SmoothedPivotTarget.Rotator()) * GetCameraBehaviorParam(
            NAME_PivotOffset_Z);
 
    // Step 5: Calculate Target Camera Location. Get the Pivot location and apply camera relative offsets.
    TargetCameraLocation = UKismetMathLibrary::VLerp(
        PivotLocation +
        UKismetMathLibrary::GetForwardVector(TargetCameraRotation) * GetCameraBehaviorParam(
            NAME_CameraOffset_X) +
        UKismetMathLibrary::GetRightVector(TargetCameraRotation) * GetCameraBehaviorParam(NAME_CameraOffset_Y)
        +
        UKismetMathLibrary::GetUpVector(TargetCameraRotation) * GetCameraBehaviorParam(NAME_CameraOffset_Z),
        PivotTarget.GetLocation() + DebugViewOffset,
        GetCameraBehaviorParam(NAME_Override_Debug));
 
    // Step 6: Trace for an object between the camera and character to apply a corrective offset.
    // Trace origins are set within the Character BP via the Camera Interface.
    // Functions like the normal spring arm, but can allow for different trace origins regardless of the pivot
    FVector TraceOrigin;
    float TraceRadius;
    ECollisionChannel TraceChannel = ControlledCharacter->GetThirdPersonTraceParams(TraceOrigin, TraceRadius);
 
    UWorld* World = GetWorld();
    check(World);
 
    FCollisionQueryParams Params;
    Params.AddIgnoredActor(this);
    Params.AddIgnoredActor(ControlledCharacter);
 
    FHitResult HitResult;
    const FCollisionShape SphereCollisionShape = FCollisionShape::MakeSphere(TraceRadius);
    const bool bHit = World->SweepSingleByChannel(HitResult, TraceOrigin, TargetCameraLocation, FQuat::Identity,
                                                  TraceChannel, SphereCollisionShape, Params);
 
    if (ALSDebugComponent && ALSDebugComponent->GetShowTraces())
    {
        UALSDebugComponent::DrawDebugSphereTraceSingle(World,
                                                       TraceOrigin,
                                                       TargetCameraLocation,
                                                       SphereCollisionShape,
                                                       EDrawDebugTrace::Type::ForOneFrame,
                                                       bHit,
                                                       HitResult,
                                                       FLinearColor::Red,
                                                       FLinearColor::Green,
                                                       5.0f);
    }
 
    if (HitResult.IsValidBlockingHit())
    {
        TargetCameraLocation += HitResult.Location - HitResult.TraceEnd;
    }
 
    // Step 8: Lerp First Person Override and return target camera parameters.
    FTransform TargetCameraTransform(TargetCameraRotation, TargetCameraLocation, FVector::OneVector);
    
    FTransform FPTargetCameraTransform(TargetCameraRotation, FPTarget, FVector::OneVector);
 
    FTransform ADSTargetCameraTransform(TargetCameraRotation, ADSTarget, FVector::OneVector);
 
 
    const FTransform& ADSTransform = UKismetMathLibrary::TLerp(FPTargetCameraTransform, ADSTargetCameraTransform,
                                                             GetCameraBehaviorParam(
                                                                 NAME_Weight_ADS));
 
 
    const FTransform& MixedTransform = UKismetMathLibrary::TLerp(TargetCameraTransform, ADSTransform, //FPTargetCameraTransform
                                                                 GetCameraBehaviorParam(
                                                                     NAME_Weight_FirstPerson));
 
    const FTransform& TargetTransform = UKismetMathLibrary::TLerp(MixedTransform,
                                                                  FTransform(DebugViewRotation, TargetCameraLocation,
                                                                             FVector::OneVector),
                                                                  GetCameraBehaviorParam(
                                                                      NAME_Override_Debug));
 
    Location = TargetTransform.GetLocation();
    Rotation = TargetTransform.Rotator();
    const float CalculateFPFOV = FMath::Lerp(FPFOV, ADSFOV, GetCameraBehaviorParam(NAME_Weight_ADS));
 
    FOV = FMath::Lerp(TPFOV, CalculateFPFOV, GetCameraBehaviorParam(NAME_Weight_FirstPerson));
 
    return true;
}

DrawDebugTargets()

void AALSPlayerCameraManager::DrawDebugTargets

(

FVector

PivotTargetLocation

)

Implemented debug logic in BP

GetCameraBehaviorParam()

float AALSPlayerCameraManager::GetCameraBehaviorParam

(

FName

CurveName

)

const

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSPlayerCameraManager::GetCameraBehaviorParam);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Camera_Manager);
 
    UAnimInstance* Inst = CameraBehavior->GetAnimInstance();
    if (Inst)
    {
        return Inst->GetCurveValue(CurveName);
    }
    return 0.0f;
}

OnPossess()

void AALSPlayerCameraManager::OnPossess

(

AALSBaseCharacter *

NewCharacter

)

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSPlayerCameraManager::OnPossess);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Camera_Manager);
 
    // Set "Controlled Pawn" when Player Controller Possesses new character. (called from Player Controller)
    check(NewCharacter);
    ControlledCharacter = NewCharacter;
 
    // Update references in the Camera Behavior AnimBP.
    UALSPlayerCameraBehavior* CastedBehv = Cast<UALSPlayerCameraBehavior>(CameraBehavior->GetAnimInstance());
    if (CastedBehv)
    {
        NewCharacter->SetCameraBehavior(CastedBehv);
        CastedBehv->MovementState = NewCharacter->GetMovementState();
        CastedBehv->MovementAction = NewCharacter->GetMovementAction();
        CastedBehv->bRightShoulder = NewCharacter->IsRightShoulder();
        CastedBehv->Gait = NewCharacter->GetGait();
        CastedBehv->SetRotationMode(NewCharacter->GetRotationMode());
        CastedBehv->Stance = NewCharacter->GetStance();
        CastedBehv->ViewMode = NewCharacter->GetViewMode();
        CastedBehv->bAimDownSights = NewCharacter->IsAimingDownSights();
    }
 
    // Initial position
    const FVector& TPSLoc = ControlledCharacter->GetThirdPersonPivotTarget().GetLocation();
    SetActorLocation(TPSLoc);
    SmoothedPivotTarget.SetLocation(TPSLoc);
 
    ALSDebugComponent = ControlledCharacter->FindComponentByClass<UALSDebugComponent>();
}

UpdateViewTargetInternal()

void AALSPlayerCameraManager::UpdateViewTargetInternal ( FTViewTarget & OutVT, float DeltaTime )

overrideprotectedvirtual

{
    TRACE_CPUPROFILER_EVENT_SCOPE(AALSPlayerCameraManager::UpdateViewTargetInternal);
    SCOPE_CYCLE_COUNTER(STATGROUP_ALS_Camera_Manager);
 
    // Partially taken from base class
 
    if (OutVT.Target)
    {
        FVector OutLocation;
        FRotator OutRotation;
        float OutFOV;
 
        if (OutVT.Target->IsA<AALSBaseCharacter>())
        {
            if (CustomCameraBehavior(DeltaTime, OutLocation, OutRotation, OutFOV))
            {
                OutVT.POV.Location = OutLocation;
                OutVT.POV.Rotation = OutRotation;
                OutVT.POV.FOV = OutFOV;
            }
            else
            {
                OutVT.Target->CalcCamera(DeltaTime, OutVT.POV);
            }
        }
        else
        {
            OutVT.Target->CalcCamera(DeltaTime, OutVT.POV);
        }
    }
}

Member Data Documentation

ALSDebugComponent

TObjectPtr<UALSDebugComponent> AALSPlayerCameraManager::ALSDebugComponent = nullptr

private

CameraBehavior

TObjectPtr<USkeletalMeshComponent> AALSPlayerCameraManager::CameraBehavior = nullptr

ControlledCharacter

TObjectPtr<AALSBaseCharacter> AALSPlayerCameraManager::ControlledCharacter = nullptr

DebugViewOffset

FVector AALSPlayerCameraManager::DebugViewOffset

protected

DebugViewRotation

FRotator AALSPlayerCameraManager::DebugViewRotation

protected

PivotLocation

FVector AALSPlayerCameraManager::PivotLocation

protected

RootLocation

FVector AALSPlayerCameraManager::RootLocation

protected

SmoothedPivotTarget

FTransform AALSPlayerCameraManager::SmoothedPivotTarget

protected

TargetCameraLocation

FVector AALSPlayerCameraManager::TargetCameraLocation

protected

TargetCameraRotation

FRotator AALSPlayerCameraManager::TargetCameraRotation

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Public/Character/ALSPlayerCameraManager.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/ALS-Community-main/Source/ALSV4_CPP/Private/Character/ALSPlayerCameraManager.cpp