ATA_WeaponSphereTrace 클래스 참조

#include <TA_WeaponSphereTrace.h>

ATA_WeaponSphereTrace에 대한 상속 다이어그램 :

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

Public 멤버 함수
	ATA_WeaponSphereTrace ()
ATA_Trace(으)로부터 상속된 Public 멤버 함수
	ATA_Trace ()
virtual void	ConfirmTargetingAndContinue () override
virtual void	Tick (float DeltaSeconds) override
FORCEINLINE void	SetCombatDataLevel (float InCombatDataLevel)
FORCEINLINE void	SetTraceChannel (ECollisionChannel InChannel)
FORCEINLINE void	SetSingleTrace (bool bInSingleTrace)
FORCEINLINE void	SetMaxHitCountPerTarget (int32 InCount)
FORCEINLINE void	SetMultiHitProfile (UDA_MultiHitProfile *InProfile)
FORCEINLINE void	SetOverrideTraceTransform (const FTransform &InTraceTransform)

Protected 멤버 함수
virtual void	StartTargeting (UGameplayAbility *Ability) override
virtual void	PerformTrace (TArray< FHitResult > &OutHits) override
virtual void	StopTargeting () override
ATA_Trace(으)로부터 상속된 Protected 멤버 함수
FTransform	ResolveTraceTransform () const
bool	IsDebugEnabled () const

Protected 속성
EWeaponTraceMeshSource	MeshSource = EWeaponTraceMeshSource::CharacterMesh
FName	MeshComponentTag = FName("WeaponTrace")
FName	StartSocketName = FName("BN_Weapon01")
FName	EndSocketName = FName("BN_Weapon03_end")
float	TraceRadius = 30.0f
uint8	bUseSubstepSweep: 1 = true
int32	MaxSubsteps = 8
uint8	bAddTrailSweeps: 1 = false
FVector	PrevStart = FVector::ZeroVector
FVector	PrevEnd = FVector::ZeroVector
bool	bTraceSocketReady = false
bool	bHasPrevPos = false
ATA_Trace(으)로부터 상속된 Protected 속성
virtual void PerformTrace(TArray< FHitResult > &OutHits) PURE_VIRTUAL(ATA_Trace bool	ProcessTraceResults ()
float	CombatDataLevel = 1.0f
ECollisionChannel	TraceChannel
bool	bSingleTrace = false
int32	MaxHitCountPerTarget = 1
TObjectPtr< UDA_MultiHitProfile >	MultiHitProfile
TMap< TWeakObjectPtr< AActor >, FMultiHitTargetState >	HitMap
TObjectPtr< ACharacter >	Character
TObjectPtr< USkeletalMeshComponent >	CharacterMesh
FTransform	OverrideTraceTransform = FTransform::Identity
uint8	bHasOverrideTraceTransform: 1 = false

Private 멤버 함수
USkeletalMeshComponent *	ResolveTraceMeshComponent () const

Private 속성
TObjectPtr< USkeletalMeshComponent >	TraceMeshComp

추가로 상속된 멤버들
ATA_Trace(으)로부터 상속된 Public 속성
FFinisherTargetDataDelegate	OnFinisherTargetDataDelegate

생성자 & 소멸자 문서화

ATA_WeaponSphereTrace()

ATA_WeaponSphereTrace::ATA_WeaponSphereTrace

(

)

{
    TraceRadius = 30.0f;
}

멤버 함수 문서화

PerformTrace()

void ATA_WeaponSphereTrace::PerformTrace ( TArray< FHitResult > &  OutHits )

overrideprotectedvirtual

{
    if (bTraceSocketReady == false || IsValid(TraceMeshComp) == false)
    {
        return;
    }
 
    const FVector CurrStart = TraceMeshComp->GetSocketLocation(StartSocketName);
    const FVector CurrEnd = TraceMeshComp->GetSocketLocation(EndSocketName);
 
    if (CurrStart.Equals(CurrEnd, 1.0f))
    {
        return;
    }
 
    FCollisionQueryParams Params(SCENE_QUERY_STAT(ATA_WeaponSphereTrace), false, SourceActor);
    const FCollisionShape Shape = FCollisionShape::MakeSphere(TraceRadius);
 
    if (bHasPrevPos == false || bUseSubstepSweep == false)
    {
        GetWorld()->SweepMultiByChannel(OutHits, CurrStart, CurrEnd, FQuat::Identity, TraceChannel, Shape, Params);
    }
    else
    {
        const float StartMotion = FVector::Dist(PrevStart, CurrStart);
        const float EndMotion = FVector::Dist(PrevEnd, CurrEnd);
        const float MaxMotion = FMath::Max(StartMotion, EndMotion);
 
        const float DesiredStepDist = FMath::Max(TraceRadius * 0.5f, 5.0f);
        const int32 Substeps = FMath::Clamp(FMath::CeilToInt(MaxMotion / DesiredStepDist), 1, MaxSubsteps);
 
        for (int32 i = 1; i <= Substeps; ++i)
        {
            const float T = (1.0f * i) / Substeps;
            const FVector LerpStart = FMath::Lerp(PrevStart, CurrStart, T);
            const FVector LerpEnd = FMath::Lerp(PrevEnd, CurrEnd, T);
 
            TArray<FHitResult> SubHits;
            GetWorld()->SweepMultiByChannel(SubHits, LerpStart, LerpEnd, FQuat::Identity, TraceChannel, Shape, Params);
            OutHits.Append(SubHits);
        }
 
        if (bAddTrailSweeps)
        {
            TArray<FHitResult> TrailStartHits;
            if (StartMotion > TraceRadius)
            {
                GetWorld()->SweepMultiByChannel(TrailStartHits, PrevStart, CurrStart, FQuat::Identity, TraceChannel, Shape, Params);
            }
            OutHits.Append(TrailStartHits);
 
            TArray<FHitResult> TrailEndHits;
            GetWorld()->SweepMultiByChannel(TrailEndHits, PrevEnd, CurrEnd, FQuat::Identity, TraceChannel, Shape, Params);
            OutHits.Append(TrailEndHits);
 
#if ENABLE_DRAW_DEBUG
            if (IsDebugEnabled())
            {
                const FVector StartCenter = (PrevStart + CurrStart) * 0.5f;
                const float StartHalfHeight = (CurrStart - PrevStart).Size() * 0.5f;
                if (StartHalfHeight > KINDA_SMALL_NUMBER)
                {
                    const FQuat StartRot = FRotationMatrix::MakeFromZ(CurrStart - PrevStart).ToQuat();
                    const FColor StartColor = TrailStartHits.Num() > 0 ? FColor::Green : FColor::Cyan;
                    DrawDebugCapsule(GetWorld(), StartCenter, StartHalfHeight, TraceRadius, StartRot, StartColor, false, 0.5f);
                }
 
                const FVector EndCenter = (PrevEnd + CurrEnd) * 0.5f;
                const float EndHalfHeight = (CurrEnd - PrevEnd).Size() * 0.5f;
                if (EndHalfHeight > KINDA_SMALL_NUMBER)
                {
                    const FQuat EndRot = FRotationMatrix::MakeFromZ(CurrEnd - PrevEnd).ToQuat();
                    const FColor EndColor = TrailEndHits.Num() > 0 ? FColor::Green : FColor::Orange;
                    DrawDebugCapsule(GetWorld(), EndCenter, EndHalfHeight, TraceRadius, EndRot, EndColor, false, 0.5f);
                }
 
                DrawDebugLine(GetWorld(), PrevStart, PrevEnd, FColor::White, false, 0.5f, 0, 1.0f);
                DrawDebugLine(GetWorld(), CurrStart, CurrEnd, FColor::White, false, 0.5f, 0, 1.0f);
                DrawDebugLine(GetWorld(), PrevStart, CurrStart, FColor::Cyan, false, 0.5f, 0, 1.5f);
                DrawDebugLine(GetWorld(), PrevEnd, CurrEnd, FColor::Orange, false, 0.5f, 0, 1.5f);
            }
#endif
        }
    }
 
    PrevStart = CurrStart;
    PrevEnd = CurrEnd;
    bHasPrevPos = true;
}

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

ResolveTraceMeshComponent()

USkeletalMeshComponent * ATA_WeaponSphereTrace::ResolveTraceMeshComponent ( ) const

private

{
    if (MeshSource == EWeaponTraceMeshSource::CharacterMesh)
    {
        return CharacterMesh;
    }
 
    if (SourceActor == nullptr || MeshComponentTag.IsNone())
    {
        return nullptr;
    }
 
    TArray<USkeletalMeshComponent*> MeshComponents;
    SourceActor->GetComponents<USkeletalMeshComponent>(MeshComponents);
 
    for (USkeletalMeshComponent* MeshComp : MeshComponents)
    {
        if (MeshComp && MeshComp->ComponentHasTag(MeshComponentTag))
        {
            return MeshComp;
        }
    }
 
    return nullptr;
}

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

StartTargeting()

void ATA_WeaponSphereTrace::StartTargeting ( UGameplayAbility *  Ability )

overrideprotectedvirtual

ATA_Trace(으)로부터 재구현되었습니다.

{
    Super::StartTargeting(Ability);
    bHasPrevPos = false;
 
    TraceMeshComp = ResolveTraceMeshComponent();
 
    bTraceSocketReady = IsValid(TraceMeshComp)
        && TraceMeshComp->GetSkeletalMeshAsset() != nullptr
        && TraceMeshComp->DoesSocketExist(StartSocketName)
        && TraceMeshComp->DoesSocketExist(EndSocketName);
 
    if (bTraceSocketReady == false)
    {
        LOG_ERROR(LogCKCharacter, "ATA_WeaponSphereTrace failed to resolve trace mesh or sockets");
    }
}

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

StopTargeting()

void ATA_WeaponSphereTrace::StopTargeting ( )

overrideprotectedvirtual

ATA_Trace(으)로부터 재구현되었습니다.

{
    Super::StopTargeting();
    bTraceSocketReady = false;
    TraceMeshComp = nullptr;
}

멤버 데이터 문서화

bAddTrailSweeps

uint8 ATA_WeaponSphereTrace::bAddTrailSweeps

protected

bHasPrevPos

bool ATA_WeaponSphereTrace::bHasPrevPos = false

protected

bTraceSocketReady

bool ATA_WeaponSphereTrace::bTraceSocketReady = false

protected

bUseSubstepSweep

uint8 ATA_WeaponSphereTrace::bUseSubstepSweep

protected

EndSocketName

FName ATA_WeaponSphereTrace::EndSocketName = FName("BN_Weapon03_end")

protected

MaxSubsteps

int32 ATA_WeaponSphereTrace::MaxSubsteps = 8

protected

MeshComponentTag

FName ATA_WeaponSphereTrace::MeshComponentTag = FName("WeaponTrace")

protected

MeshSource

EWeaponTraceMeshSource ATA_WeaponSphereTrace::MeshSource = EWeaponTraceMeshSource::CharacterMesh

protected

PrevEnd

FVector ATA_WeaponSphereTrace::PrevEnd = FVector::ZeroVector

protected

PrevStart

FVector ATA_WeaponSphereTrace::PrevStart = FVector::ZeroVector

protected

StartSocketName

FName ATA_WeaponSphereTrace::StartSocketName = FName("BN_Weapon01")

protected

TraceMeshComp

TObjectPtr<USkeletalMeshComponent> ATA_WeaponSphereTrace::TraceMeshComp

private

TraceRadius

float ATA_WeaponSphereTrace::TraceRadius = 30.0f

protected

---

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

• Source/CK_UE/GAS/GA/TA/TA_WeaponSphereTrace.h
• Source/CK_UE/GAS/GA/TA/TA_WeaponSphereTrace.cpp