FProjectilePathSelector 구조체 참조

#include <ProjectilePathSelector.h>

FProjectilePathSelector에 대한 협력 다이어그램:

Public 멤버 함수
bool	ResolveImpactPoint (const AActor *RequestingActor, const FTargetSelectionResult &TargetResult, float MaxImpactDistance, float ImpactObstructionOffset, FWeaponRequestImpactResult &OutImpactResult) const
bool	ResolveLaunchPath (const AActor *RequestingActor, const FVector &ImpactPoint, float SpawnHeightAboveImpact, float SpawnLateralOffset, float SpawnForwardOffset, FVector &OutFrom, FVector &OutDirection) const
bool	ResolveTargetHeightLocation (const UObject *WorldContextObject, const FVector &PathStart, const FVector &PathEnd, float TargetHeight, FProjectilePathResult &OutResult) const

Private 멤버 함수
float	ClampDistanceByObstruction (const AActor *RequestingActor, const FVector &StartLocation, const FVector &Direction, float Distance, float ImpactObstructionOffset) const
bool	BSForHeight (const FVector &PathStart, const FVector &PathEnd, float TargetHeight, FProjectilePathResult &OutResult, float PreviousAlpha, float PreviousDelta, float CurrentAlpha, float CurrentDelta, bool &bValue) const
bool	EvaluateHeightAtAlpha (const FVector &PathStart, const FVector &PathEnd, float Alpha, float TargetHeight, FProjectilePathResult &OutResult) const
bool	FindGroundLocation (const FVector &PathLocation, FVector &OutGroundLocation) const

Private 속성
float	GroundTraceUpOffset = 1000.0f
float	GroundTraceDownDistance = 10000.0f
int32	SegmentCount = 16
int32	BinarySearchIterationCount = 12
TObjectPtr< UWorld >	CachedWorld

멤버 함수 문서화

BSForHeight()

bool FProjectilePathSelector::BSForHeight ( const FVector &  PathStart, const FVector &  PathEnd, float  TargetHeight, FProjectilePathResult &  OutResult, float  PreviousAlpha, float  PreviousDelta, float  CurrentAlpha, float  CurrentDelta, bool &  bValue  ) const

private

{
    const bool bPreviousAbove = PreviousDelta > KINDA_SMALL_NUMBER;
    const bool bPreviousBelow = PreviousDelta < -KINDA_SMALL_NUMBER;
    const bool bCurrentAbove = CurrentDelta > KINDA_SMALL_NUMBER;
    const bool bCurrentBelow = CurrentDelta < -KINDA_SMALL_NUMBER;
 
    if ((bPreviousAbove && bCurrentBelow) == false && (bPreviousBelow && bCurrentAbove) == false)
    {
        return false;
    }
    
    float LowAlpha = PreviousAlpha;
    float HighAlpha = CurrentAlpha;
 
    for (int32 IterationIndex = 0; IterationIndex < BinarySearchIterationCount; ++IterationIndex)
    {
        const float MidAlpha = (LowAlpha + HighAlpha) * 0.5f;
        FProjectilePathResult MidResult;
 
        if (EvaluateHeightAtAlpha(PathStart, PathEnd, MidAlpha, TargetHeight, MidResult) == false)
        {
            bValue = false;
            return true;
        }
 
        const float MidDelta = MidResult.HeightAboveGround - TargetHeight;
 
        const bool bMidAbove = MidDelta > KINDA_SMALL_NUMBER;
        const bool bMidBelow = MidDelta < -KINDA_SMALL_NUMBER;
 
        if ((bPreviousAbove && bMidAbove) || (bPreviousBelow && bMidBelow))
        {
            LowAlpha = MidAlpha;
        }
        else
        {
            HighAlpha = MidAlpha;
        }
 
        OutResult = MidResult;
    }
 
    bValue = true;
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ClampDistanceByObstruction()

float FProjectilePathSelector::ClampDistanceByObstruction ( const AActor *  RequestingActor, const FVector &  StartLocation, const FVector &  Direction, float  Distance, float  ImpactObstructionOffset  ) const

private

{
    UWorld* World = RequestingActor ? RequestingActor->GetWorld() : nullptr;
 
    if (World == nullptr || Distance <= KINDA_SMALL_NUMBER)
    {
        return Distance;
    }
 
    const FVector TraceStart = StartLocation;
    const FVector TraceEnd = StartLocation + Direction * Distance;
 
    FCollisionObjectQueryParams ObjectQuery;
    ObjectQuery.AddObjectTypesToQuery(ECC_WorldStatic);
 
    FCollisionQueryParams TraceParams(SCENE_QUERY_STAT(WeaponRequestImpactObstruction), false);
 
    FHitResult Hit;
 
    if (World->LineTraceSingleByObjectType(Hit, TraceStart, TraceEnd, ObjectQuery, TraceParams) == false)
    {
        return Distance;
    }
 
    return FMath::Max(Hit.Distance - ImpactObstructionOffset, KINDA_SMALL_NUMBER);
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

EvaluateHeightAtAlpha()

bool FProjectilePathSelector::EvaluateHeightAtAlpha ( const FVector &  PathStart, const FVector &  PathEnd, float  Alpha, float  TargetHeight, FProjectilePathResult &  OutResult  ) const

private

{
    OutResult = FProjectilePathResult();
 
    if (CachedWorld == nullptr)
    {
        return false;
    }
 
    const float ClampedAlpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
    const FVector PathLocation = FMath::Lerp(PathStart, PathEnd, ClampedAlpha);
    FVector GroundLocation = FVector::ZeroVector;
 
    if (FindGroundLocation(PathLocation, GroundLocation) == false)
    {
        return false;
    }
 
    OutResult.TargetLocation = PathLocation;
    OutResult.GroundLocation = GroundLocation;
    OutResult.HeightAboveGround = PathLocation.Z - GroundLocation.Z;
    OutResult.PathAlpha = ClampedAlpha;
    return OutResult.HeightAboveGround >= -KINDA_SMALL_NUMBER || TargetHeight <= KINDA_SMALL_NUMBER;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FindGroundLocation()

bool FProjectilePathSelector::FindGroundLocation ( const FVector &  PathLocation, FVector &  OutGroundLocation  ) const

private

{
    OutGroundLocation = FVector::ZeroVector;
 
    if (CachedWorld == nullptr)
    {
        return false;
    }
 
    const FVector TraceStart = PathLocation + FVector::UpVector * GroundTraceUpOffset;
    const FVector TraceEnd = PathLocation - FVector::UpVector * GroundTraceDownDistance;
 
    FCollisionObjectQueryParams ObjectQuery;
    ObjectQuery.AddObjectTypesToQuery(ECC_WorldStatic);
 
    FCollisionQueryParams TraceParams(SCENE_QUERY_STAT(ProjectilePathHeightSelector), false);
 
    FHitResult Hit;
 
    if (CachedWorld->LineTraceSingleByObjectType(Hit, TraceStart, TraceEnd, ObjectQuery, TraceParams) == false)
    {
        return false;
    }
 
    OutGroundLocation = Hit.ImpactPoint;
    return true;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ResolveImpactPoint()

bool FProjectilePathSelector::ResolveImpactPoint	(	const AActor *	RequestingActor,
		const FTargetSelectionResult &	TargetResult,
		float	MaxImpactDistance,
		float	ImpactObstructionOffset,
		FWeaponRequestImpactResult &	OutImpactResult
	)		const

{
    OutImpactResult = FWeaponRequestImpactResult();
 
    if (RequestingActor == nullptr)
    {
        return false;
    }
 
    const FVector RequesterLocation = RequestingActor->GetActorLocation();
 
    if (TargetResult.bHasTarget == false)
    {
        FVector FallbackDirection = RequestingActor->GetActorForwardVector();
        FallbackDirection.Z = 0.0f;
        FallbackDirection = FallbackDirection.GetSafeNormal();
 
        if (FallbackDirection.IsNearlyZero())
        {
            return false;
        }
 
        const float SafeDistance = ClampDistanceByObstruction(RequestingActor, RequesterLocation, FallbackDirection, MaxImpactDistance, ImpactObstructionOffset);
 
        OutImpactResult.TargetLocation = RequesterLocation + FallbackDirection * MaxImpactDistance;
        OutImpactResult.ImpactPoint = RequesterLocation + FallbackDirection * SafeDistance;
        return true;
    }
 
    FVector RequesterToTarget = TargetResult.TargetLocation - RequesterLocation;
    RequesterToTarget.Z = 0.0f;
 
    FVector Direction = RequesterToTarget.GetSafeNormal();
 
    if (Direction.IsNearlyZero())
    {
        Direction = RequestingActor->GetActorForwardVector();
        Direction.Z = 0.0f;
        Direction = Direction.GetSafeNormal();
    }
 
    if (Direction.IsNearlyZero())
    {
        return false;
    }
 
    const float ImpactDistance = FMath::Min(TargetResult.TargetDistance, MaxImpactDistance);
    const float SafeDistance = ClampDistanceByObstruction(RequestingActor, RequesterLocation, Direction, ImpactDistance, ImpactObstructionOffset);
    FVector ImpactPoint = RequesterLocation + Direction * SafeDistance;
    ImpactPoint.Z = TargetResult.TargetLocation.Z;
 
    OutImpactResult.TargetLocation = TargetResult.TargetLocation;
    OutImpactResult.ImpactPoint = ImpactPoint;
    OutImpactResult.TargetDistance = TargetResult.TargetDistance;
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ResolveLaunchPath()

bool FProjectilePathSelector::ResolveLaunchPath	(	const AActor *	RequestingActor,
		const FVector &	ImpactPoint,
		float	SpawnHeightAboveImpact,
		float	SpawnLateralOffset,
		float	SpawnForwardOffset,
		FVector &	OutFrom,
		FVector &	OutDirection
	)		const

{
    OutFrom = FVector::ZeroVector;
    OutDirection = FVector::ZeroVector;
 
    if (RequestingActor == nullptr)
    {
        return false;
    }
 
    FVector ForwardFlat = ImpactPoint - RequestingActor->GetActorLocation();
    ForwardFlat.Z = 0.0f;
    ForwardFlat = ForwardFlat.GetSafeNormal();
 
    if (ForwardFlat.IsNearlyZero())
    {
        ForwardFlat = RequestingActor->GetActorForwardVector();
        ForwardFlat.Z = 0.0f;
        ForwardFlat = ForwardFlat.GetSafeNormal();
    }
 
    const FVector RightFlat = FVector::CrossProduct(FVector::UpVector, ForwardFlat).GetSafeNormal();
 
    OutFrom = ImpactPoint;
    OutFrom += FVector::UpVector * SpawnHeightAboveImpact;
    OutFrom += RightFlat * SpawnLateralOffset;
    OutFrom += ForwardFlat * SpawnForwardOffset;
 
    OutDirection = (ImpactPoint - OutFrom).GetSafeNormal();
 
    return OutDirection.IsNearlyZero() == false;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ResolveTargetHeightLocation()

bool FProjectilePathSelector::ResolveTargetHeightLocation	(	const UObject *	WorldContextObject,
		const FVector &	PathStart,
		const FVector &	PathEnd,
		float	TargetHeight,
		FProjectilePathResult &	OutResult
	)		const

{
    OutResult = FProjectilePathResult();
 
    if (WorldContextObject == nullptr || TargetHeight < KINDA_SMALL_NUMBER)
    {
        return false;
    }
 
    CachedWorld = WorldContextObject->GetWorld();
    check(CachedWorld);
 
    if (FVector::DistSquared(PathStart, PathEnd) < KINDA_SMALL_NUMBER)
    {
        return false;
    }
 
    const int32 SafeSegmentCount = FMath::Max(SegmentCount, 1);
    FProjectilePathResult PreviousResult;
 
    if (EvaluateHeightAtAlpha(PathStart, PathEnd, 0.0f, TargetHeight, PreviousResult) == false)
    {
        return false;
    }
 
    float PreviousAlpha = 0.0f;
    float PreviousDelta = PreviousResult.HeightAboveGround - TargetHeight;
 
    if (FMath::Abs(PreviousDelta) <= KINDA_SMALL_NUMBER)
    {
        OutResult = PreviousResult;
        return true;
    }
 
    for (int32 SegmentIndex = 1; SegmentIndex <= SafeSegmentCount; ++SegmentIndex)
    {
        const float CurrentAlpha = static_cast<float>(SegmentIndex) / static_cast<float>(SafeSegmentCount);
        FProjectilePathResult CurrentResult;
 
        if (EvaluateHeightAtAlpha(PathStart, PathEnd, CurrentAlpha, TargetHeight, CurrentResult) == false)
        {
            return false;
        }
 
        const float CurrentDelta = CurrentResult.HeightAboveGround - TargetHeight;
 
        if (FMath::Abs(CurrentDelta) <= KINDA_SMALL_NUMBER)
        {
            OutResult = CurrentResult;
            return true;
        }
 
        bool bValue;
        
        if (BSForHeight(PathStart, PathEnd, TargetHeight, OutResult, PreviousAlpha, PreviousDelta, CurrentAlpha, CurrentDelta, bValue))
        {
            return bValue;
        }
 
        PreviousAlpha = CurrentAlpha;
        PreviousDelta = CurrentDelta;
        PreviousResult = CurrentResult;
    }
 
    return false;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

BinarySearchIterationCount

int32 FProjectilePathSelector::BinarySearchIterationCount = 12

private

CachedWorld

TObjectPtr<UWorld> FProjectilePathSelector::CachedWorld

mutableprivate

GroundTraceDownDistance

float FProjectilePathSelector::GroundTraceDownDistance = 10000.0f

private

GroundTraceUpOffset

float FProjectilePathSelector::GroundTraceUpOffset = 1000.0f

private

SegmentCount

int32 FProjectilePathSelector::SegmentCount = 16

private

---

이 구조체에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/Level/Selector/ProjectilePathSelector.h
• Source/CK_UE/Level/Selector/ProjectilePathSelector.cpp