TargetableQueryContext 구조체 참조

#include <TargetableQuery.h>

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

Public 멤버 함수
	TargetableQueryContext (UWorld *InWorld, const TArray< ITargetableInterface * > &Targetables)
TargetableQueryContext &	ResetCachedResult ()
TargetableQueryContext &	CacheResult ()
TargetableQueryContext &	FilterByLineOfSight ()
TargetableQueryContext &	PickClosestFromCenter ()
TargetableQueryContext &	FilterByClassType (UClass *ClassType)
TargetableQueryContext &	GatherCandidates (float MaxLockOnDistance)
TargetableQueryContext &	FilterByArrayRange (TArray< ITargetableInterface * > Array, int32 StartIdx, int32 EndIdx)
TargetableQueryContext &	FindDistanceNearestEnemy (const FVector &Origin, float MaxRange)
TargetableQueryContext &	FindDirectionNearestEnemy (const FVector &Origin, const FVector &Direction, float MaxRange)
TArray< ITargetableInterface * >	GetTargets (const int32 StartIdx, const int32 EndIdx)
TArray< ITargetableInterface * >	GetTargets (const int32 Count)
TArray< ITargetableInterface * >	GetTargets () const
ITargetableInterface *	GetTarget (const int32 Index=0)
TArray< ITargetableInterface * >	GetInitialTargets () const
TArray< ITargetableInterface * >	GetCachedTargets (const int32 StartIdx, const int32 EndIdx)
TArray< ITargetableInterface * >	GetCachedTargets ()
ITargetableInterface *	GetCachedTarget (const int32 Index=0)
bool	IsCached () const
template<typename TActorClass >
TargetableQueryContext &	FilterByClassType (TSubclassOf< TActorClass > ClassType)

Private 멤버 함수
bool	CheckLineOfSight (ITargetableInterface *Target, TArray< FHitResult > HitResults) const

Private 속성
TArray< ITargetableInterface * >	InitialTargets
TArray< ITargetableInterface * >	CachedTargets
TArray< ITargetableInterface * >	Targets
TObjectPtr< UWorld >	World

생성자 & 소멸자 문서화

TargetableQueryContext()

TargetableQueryContext::TargetableQueryContext ( UWorld *  InWorld, const TArray< ITargetableInterface * > &  Targetables  )

inline

    {
        InitialTargets = Targetables;
        Targets = Targetables;
        World = InWorld;
    }

멤버 함수 문서화

CacheResult()

TargetableQueryContext & TargetableQueryContext::CacheResult

(

)

{
    CachedTargets = GetTargets();
    return *this;
}

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

CheckLineOfSight()

bool TargetableQueryContext::CheckLineOfSight ( ITargetableInterface *  Target, TArray< FHitResult >  HitResults  ) const

private

{
    bool bIsBlocking = false;
 
    for (const FHitResult& Hit : HitResults)
    {
        if (Hit.Component.IsValid() && Hit.Component->GetCollisionProfileName() == CPROFILE_CKPLAYERCAPSULE)
        {
            continue;
        }
 
        if (Hit.GetActor() != ITargetableInterface::AsActor(Target))
        {
            bIsBlocking = true;
            break;
        }
    }
 
    if (bIsBlocking)
    {
        return true;
    }
    else
    {
        return false;
    }
}

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

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

FilterByArrayRange()

TargetableQueryContext & TargetableQueryContext::FilterByArrayRange	(	TArray< ITargetableInterface * >	Array,
		int32	StartIdx,
		int32	EndIdx
	)

{
    TArray<ITargetableInterface*> Result;
 
    if (StartIdx > EndIdx || StartIdx < 0 || EndIdx < 0 || StartIdx >= Array.Num() || Array.Num() <= EndIdx)
    {
        return *this;
    }
 
    Result.Reserve(EndIdx - StartIdx + 1);
 
    for (int32 Idx = StartIdx; Idx <= EndIdx; ++Idx)
    {
        Result.Add(Array[Idx]);
    }
    
    Targets = Result;
    return *this;
}

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

FilterByClassType() [1/2]

template<typename TActorClass >

TargetableQueryContext & TargetableQueryContext::FilterByClassType ( TSubclassOf< TActorClass >  ClassType )

inline

    {
        return FilterByClassType(ClassType.Get());
    }

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

FilterByClassType() [2/2]

TargetableQueryContext & TargetableQueryContext::FilterByClassType

(

UClass *

ClassType

)

{
    checkf(ClassType, TEXT("%s는 nullptr 일 수 없습니다. "), NAMEOF(UClass));
 
    TArray<ITargetableInterface*> ResultArray;
 
    for (ITargetableInterface* Target : Targets)
    {
        const AActor* TargetActor = ITargetableInterface::AsActor(Target);
 
        if (TargetActor == nullptr || TargetActor->IsA(ClassType) == false)
        {
            continue;
        }
 
        ResultArray.Add(Target);
    }
 
    Targets = ResultArray;
    return *this;
}

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

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

FilterByLineOfSight()

TargetableQueryContext & TargetableQueryContext::FilterByLineOfSight

(

)

{
    if (World == nullptr || Targets.IsEmpty())
    {
        return *this;
    }
 
    const APlayerController* PC = GEngine->GetFirstLocalPlayerController(World);
 
    if (PC == nullptr || PC->PlayerCameraManager == nullptr)
    {
        return *this;
    }
 
    FCollisionQueryParams Params(SCENE_QUERY_STAT(FilterByLineOfSight), false);
 
    if (IsValid(PC->GetPawn()))
    {
        Params.AddIgnoredActor(PC->GetPawn());
    }
 
    TArray<ITargetableInterface*> ResultArray;
    const FVector Offset = FVector(100.f, 0.0f, 0.0f);
    const FVector TraceStart = PC->PlayerCameraManager->GetCameraLocation();
 
    for (ITargetableInterface* Target : Targets)
    {
        if (Target->IsTargetValid() == false || Target->IsTargetable() == false)
        {
            continue;
        }
 
        const FVector TargetLocation = Target->GetTargetedActorLocation() + Offset;
        TArray<FHitResult> HitResults;
 
        World->LineTraceMultiByChannel
        (
            HitResults,
            TraceStart,
            TargetLocation,
            ECC_Visibility,
            Params
        );
 
        if (CheckLineOfSight(Target, HitResults))
        {
            continue;
        }
 
        ResultArray.Add(Target);
    }
 
    Targets = ResultArray;
    return *this;
}

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

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

FindDirectionNearestEnemy()

TargetableQueryContext & TargetableQueryContext::FindDirectionNearestEnemy	(	const FVector &	Origin,
		const FVector &	Direction,
		float	MaxRange
	)

{
    float NearestDistSq = FMath::Square(MaxRange);
    ITargetableInterface* Result = nullptr;
 
    for (ITargetableInterface* Target : Targets)
    {
        if (Target->IsTargetValid() == false || Target->IsTargetable() == false)
        {
            continue;
        }
 
        const FVector ToTarget = Target->GetTargetedActorLocation() - Origin;
        const float DistSq = ToTarget.SizeSquared();
 
        if (DistSq > FMath::Square(MaxRange))
        {
            continue;
        }
 
        FVector ToTargetFlat(ToTarget.X, ToTarget.Y, 0.f);
        ToTargetFlat.Normalize();
 
        // 입력 방향과의 각도가 임계값 미만이면 해당 방향에 없는 적으로 판정.
        if (FVector::DotProduct(Direction, ToTargetFlat) < CK_Definitions::INPUT_DIR_THRESHOLD)
        {
            continue;
        }
 
        // 입력 방향 안에 있는 적 중 가장 가까운 적을 선택.
        if (DistSq > NearestDistSq)
        {
            continue;
        }
 
        NearestDistSq = DistSq;
        Result = Target;
    }
 
    Targets.Reset();
 
    if (Result)
    {
        Targets.Add(Result);
    }
 
    return *this;
}

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

FindDistanceNearestEnemy()

TargetableQueryContext & TargetableQueryContext::FindDistanceNearestEnemy	(	const FVector &	Origin,
		float	MaxRange
	)

{
    ITargetableInterface* Result = nullptr;
    float NearestDistSq = FMath::Square(MaxRange);
 
    for (ITargetableInterface* Target : Targets)
    {
        if (Target->IsTargetValid() == false || Target->IsTargetable() == false)
        {
            continue;
        }
 
        const float DistSq = FVector::DistSquared(Target->GetTargetedActorLocation(), Origin);
 
        if (DistSq >= NearestDistSq)
        {
            continue;
        }
 
        NearestDistSq = DistSq;
        Result = Target;
    }
 
    Targets.Reset();
 
    if (Result)
    {
        Targets.Add(Result);
    }
 
    return *this;
}

GatherCandidates()

TargetableQueryContext & TargetableQueryContext::GatherCandidates

(

float

MaxLockOnDistance

)

{
    TArray<ITargetableInterface*> ResultArray;
 
    if (World == nullptr)
    {
        return *this;
    }
 
    const APlayerController* PC = GEngine->GetFirstLocalPlayerController(World);
 
    if (PC == nullptr || PC->PlayerCameraManager == nullptr)
    {
        return *this;
    }
 
    const FVector CameraLocation = PC->PlayerCameraManager->GetCameraLocation();
    const float MaxDistSq = FMath::Square(MaxLockOnDistance);
 
    for (ITargetableInterface* Target : Targets)
    {
        if (Target->IsTargetValid() == false || Target->IsTargetable() == false)
        {
            continue;
        }
 
        const FVector ToTarget = Target->GetTargetedActorLocation() - CameraLocation;
        const float DistSq = ToTarget.SizeSquared();
 
        if (DistSq > MaxDistSq || DistSq <= KINDA_SMALL_NUMBER)
        {
            continue;
        }
 
        ResultArray.Add(Target);
    }
 
    Targets = ResultArray;
    return *this;
}

GetCachedTarget()

ITargetableInterface * TargetableQueryContext::GetCachedTarget ( const int32  Index = 0 )

inline

    {
        return CachedTargets.IsEmpty() ? nullptr : CachedTargets.IsValidIndex(Index) ? CachedTargets[Index] : nullptr;
    }

GetCachedTargets() [1/2]

TArray< ITargetableInterface * > TargetableQueryContext::GetCachedTargets ( )

inline

    {
        return CachedTargets;
    }

GetCachedTargets() [2/2]

TArray< ITargetableInterface * > TargetableQueryContext::GetCachedTargets ( const int32  StartIdx, const int32  EndIdx  )

inline

    {
        return FilterByArrayRange(CachedTargets, StartIdx, EndIdx).GetTargets();;
    }

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

GetInitialTargets()

TArray< ITargetableInterface * > TargetableQueryContext::GetInitialTargets ( ) const

inline

    {
        return InitialTargets;
    }

GetTarget()

ITargetableInterface * TargetableQueryContext::GetTarget ( const int32  Index = 0 )

inline

    {
        return Targets.IsEmpty() ? nullptr : Targets.IsValidIndex(Index) ? Targets[Index] : nullptr;
    }

GetTargets() [1/3]

TArray< ITargetableInterface * > TargetableQueryContext::GetTargets ( ) const

inline

    {
        return Targets;
    }

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

GetTargets() [2/3]

TArray< ITargetableInterface * > TargetableQueryContext::GetTargets ( const int32  Count )

inline

    {
        return GetTargets(0, Count);
    }

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

GetTargets() [3/3]

TArray< ITargetableInterface * > TargetableQueryContext::GetTargets ( const int32  StartIdx, const int32  EndIdx  )

inline

    {
        return FilterByArrayRange(Targets, StartIdx, EndIdx).GetTargets();
    }

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

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

IsCached()

bool TargetableQueryContext::IsCached ( ) const

inline

    {
        return !CachedTargets.IsEmpty();
    }

PickClosestFromCenter()

TargetableQueryContext & TargetableQueryContext::PickClosestFromCenter

(

)

{
    if (Targets.IsEmpty() || World == nullptr)
    {
        return *this;
    }
 
    const APlayerController* PC = GEngine->GetFirstLocalPlayerController(World);
 
    if (PC == nullptr || PC->PlayerCameraManager == nullptr)
    {
        return *this;
    }
 
    const FVector CameraLocation = PC->PlayerCameraManager->GetCameraLocation();
    const FVector CameraForward = PC->PlayerCameraManager->GetCameraRotation().Vector();
 
    ITargetableInterface* Best = nullptr;
    float BestDot = -2.0f;
    float BestDistSq = TNumericLimits<float>::Max();
 
    for (ITargetableInterface* Target : Targets)
    {
        if (Target->IsTargetValid() == false || Target->IsTargetable() == false)
        {
            continue;
        }
 
        const FVector ToTarget = Target->GetTargetedActorLocation() - CameraLocation;
        const float DistSq = ToTarget.SizeSquared();
 
        if (DistSq < KINDA_SMALL_NUMBER)
        {
            continue;
        }
 
        const FVector ToTargetDir = ToTarget / FMath::Sqrt(DistSq);
        const float Dot = FVector::DotProduct(CameraForward, ToTargetDir);
 
        // 1순위: 화면 중앙에 더 가까운 적 (Dot이 큰 쪽)
        // 2순위: 동률(혹은 매우 근소한 차이)일 때 더 가까운 적
 
        if (FMath::IsNearlyEqual(Dot, BestDot, KINDA_SMALL_NUMBER) ? (DistSq < BestDistSq) : (Dot > BestDot))
        {
            Best = Target;
            BestDot = Dot;
            BestDistSq = DistSq;
        }
    }
 
    Targets.Reset();
 
    if (Best)
    {
        Targets.Add(Best);
    }
 
    return *this;
}

ResetCachedResult()

TargetableQueryContext & TargetableQueryContext::ResetCachedResult

(

)

{
    Targets = InitialTargets;
    CachedTargets.Reset();
    return *this;
}

멤버 데이터 문서화

CachedTargets

TArray<ITargetableInterface*> TargetableQueryContext::CachedTargets

private

InitialTargets

TArray<ITargetableInterface*> TargetableQueryContext::InitialTargets

private

Targets

TArray<ITargetableInterface*> TargetableQueryContext::Targets

private

World

TObjectPtr<UWorld> TargetableQueryContext::World

private

---

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

• Source/CK_UE/Query/TargetableQuery.h
• Source/CK_UE/Query/TargetableQuery.cpp