UEnemyDespawnDefinition 클래스 참조

#include <EnemyDespawnDefinition.h>

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

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

Public 멤버 함수
bool	StartEnemyDespawnFlow (AEnemyCharacterBase *InEnemyCharacter)
bool	StartEnemyDespawnFlow (AEnemyCharacterBase *InEnemyCharacter, TFunction< void()> &&InOnFlowFinished)
FORCEINLINE FMaterialOpacityTransition	GetDespawnMaterialTransition () const
UFlowDefinitionBase(으)로부터 상속된 Public 멤버 함수
bool	StartFlow (UObject *InFlowOwner)
void	FinishFlow ()
void	ResetFlow ()
FORCEINLINE bool	IsRunning () const
FORCEINLINE UObject *	GetFlowOwner () const

Protected 멤버 함수
virtual void	HandleFlowStarted (UObject *InFlowOwner) override
virtual void	HandleFlowFinished () override
virtual void	HandleFlowReset () override
virtual void	PlayDespawnFlow_Implementation (AEnemyCharacterBase *InEnemyCharacter)
void	PlayDespawnFlow (AEnemyCharacterBase *InEnemyCharacter)
UFlowDefinitionBase(으)로부터 상속된 Protected 멤버 함수
void	StopFlow ()
void	ReceiveFlowStarted (UObject *InFlowOwner)
void	ReceiveFlowFinished ()
void	ReceiveFlowReset ()

Protected 속성
TObjectPtr< UNiagaraSystem >	DespawnNiagaraSystem
FName	SkeletalMeshUserParameterName = TEXT("User.SkeletalMesh")
float	DespawnNiagaraPlayTime = 2.0f
FMaterialOpacityTransition	DespawnMaterialTransition = FMaterialOpacityTransition(1.0f, 0.0f)

Private 멤버 함수
void	ApplyMaterialTransition (AEnemyCharacterBase *InEnemyCharacter, const FMaterialOpacityTransition &InTransition)
void	PrepareDespawnNiagara (AEnemyCharacterBase *InEnemyCharacter)
void	ActivateDespawnNiagara ()
void	CompleteMaterialTransition ()
USkeletalMeshComponent *	CreateCopyPoseProxyMesh (AEnemyCharacterBase *InEnemyCharacter)
void	ScheduleCopyPoseProxyCleanup ()
void	DestroyCopyPoseProxy ()
void	UpdateMaterialTransition ()
void	ClearMaterialTransitionTimer ()
void	RestoreMaterialSlots ()

Private 속성
TWeakObjectPtr< AEnemyCharacterBase >	ActiveEnemyCharacter
TWeakObjectPtr< UWorld >	ActiveWorld
TArray< int32 >	ActiveMaterialSlotIndices
TArray< TObjectPtr< UMaterialInterface > >	OriginalMaterials
TArray< TObjectPtr< UMaterialInstanceDynamic > >	DynamicMaterials
TObjectPtr< AActor >	ActiveCopyPoseProxyActor
TObjectPtr< USkeletalMeshComponent >	ActiveCopyPoseProxyMesh
TWeakObjectPtr< UWorld >	ActiveCopyPoseProxyWorld
FTimerHandle	MaterialTransitionTimerHandle
FTimerHandle	CopyPoseProxyCleanupTimerHandle
float	MaterialTransitionStartTime = 0.0f
float	ActiveTransitionDurationSeconds = 0.0f
float	ActiveTransitionStartOpacity = 1.0f
float	ActiveTransitionEndOpacity = 0.0f
FName	ActiveOpacityParameterName = TEXT("Opacity")
TFunction< void()>	OnDespawnFlowFinished

멤버 함수 문서화

ActivateDespawnNiagara()

void UEnemyDespawnDefinition::ActivateDespawnNiagara ( )

private

{
    AEnemyCharacterBase* EnemyCharacter = ActiveEnemyCharacter.Get();
    if (EnemyCharacter == nullptr || DespawnNiagaraSystem == nullptr || ActiveCopyPoseProxyMesh == nullptr)
    {
        FinishFlow();
        return;
    }
 
    const FTransform NiagaraTransform = ActiveCopyPoseProxyMesh->GetComponentTransform();
 
    if (ActiveCopyPoseProxyActor)
    {
        ActiveCopyPoseProxyActor->SetActorTransform(NiagaraTransform);
    }
 
    ActiveCopyPoseProxyMesh->SetWorldTransform(NiagaraTransform);
 
    UNiagaraComponent* NiagaraComponent = UNiagaraFunctionLibrary::SpawnSystemAtLocation
    (
        EnemyCharacter,
        DespawnNiagaraSystem,
        NiagaraTransform.GetLocation(),
        NiagaraTransform.Rotator(),
        NiagaraTransform.GetScale3D(),
        true,
        false
    );
 
    if (NiagaraComponent == nullptr)
    {
        DestroyCopyPoseProxy();
        FinishFlow();
        return;
    }
 
    UNiagaraFunctionLibrary::OverrideSystemUserVariableSkeletalMeshComponent(NiagaraComponent, SkeletalMeshUserParameterName.ToString(), ActiveCopyPoseProxyMesh);
    NiagaraComponent->Activate(true);
 
    ScheduleCopyPoseProxyCleanup();
    FinishFlow();
}

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

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

ApplyMaterialTransition()

void UEnemyDespawnDefinition::ApplyMaterialTransition ( AEnemyCharacterBase *  InEnemyCharacter, const FMaterialOpacityTransition &  InTransition  )

private

{
    ClearMaterialTransitionTimer();
    RestoreMaterialSlots();
 
    if (InEnemyCharacter == nullptr)
    {
        FinishFlow();
        return;
    }
 
    USkeletalMeshComponent* MeshComp = InEnemyCharacter->GetMesh();
 
    if (MeshComp == nullptr)
    {
        FinishFlow();
        return;
    }
 
    UWorld* World = InEnemyCharacter->GetWorld();
 
    if (World == nullptr)
    {
        FinishFlow();
        return;
    }
 
    ActiveEnemyCharacter = InEnemyCharacter;
    ActiveWorld = World;
    ActiveOpacityParameterName = InTransition.OpacityParameterName;
    ActiveTransitionDurationSeconds = FMath::Max(InTransition.DurationSeconds, 0.0f);
    ActiveTransitionStartOpacity = InTransition.StartOpacity;
    ActiveTransitionEndOpacity = InTransition.EndOpacity;
 
    const int32 NumMaterials = MeshComp->GetNumMaterials();
 
    auto ApplyMaterialToSlot = [&](int32 InSlotIndex, UMaterialInterface* InSourceMaterial)
    {
        if (InSlotIndex < 0 || InSlotIndex >= NumMaterials)
        {
            return;
        }
 
        if (InSourceMaterial == nullptr)
        {
            return;
        }
 
        UMaterialInstanceDynamic* DynamicMaterial = UMaterialInstanceDynamic::Create(InSourceMaterial, this);
 
        if (DynamicMaterial == nullptr)
        {
            return;
        }
 
        DynamicMaterial->SetScalarParameterValue(ActiveOpacityParameterName, ActiveTransitionStartOpacity);
 
        ActiveMaterialSlotIndices.Add(InSlotIndex);
        OriginalMaterials.Add(MeshComp->GetMaterial(InSlotIndex));
        DynamicMaterials.Add(DynamicMaterial);
        MeshComp->SetMaterial(InSlotIndex, DynamicMaterial);
    };
 
    if (const FMaterialSlotOverrideWhole* WholeOverride = InTransition.OverrideMaterial.GetPtr<FMaterialSlotOverrideWhole>())
    {
        for (int32 SlotIndex = 0; SlotIndex < NumMaterials; ++SlotIndex)
        {
            ApplyMaterialToSlot(SlotIndex, WholeOverride->OverrideMaterial.Get());
        }
    }
    else if (const FMaterialSlotOverrideByIndex* IndexedOverride = InTransition.OverrideMaterial.GetPtr<FMaterialSlotOverrideByIndex>())
    {
        for (int32 SlotIndex = 0; SlotIndex < IndexedOverride->OverrideMaterials.Num(); ++SlotIndex)
        {
            ApplyMaterialToSlot(SlotIndex, IndexedOverride->OverrideMaterials[SlotIndex].Get());
        }
    }
 
    if (DynamicMaterials.IsEmpty())
    {
        CompleteMaterialTransition();
        return;
    }
 
    if (ActiveTransitionDurationSeconds > 0.0f)
    {
        MaterialTransitionStartTime = World->GetTimeSeconds();
        FTimerManager& WorldTimerManager = World->GetTimerManager();
        WorldTimerManager.SetTimer(MaterialTransitionTimerHandle, this, &ThisClass::UpdateMaterialTransition, 0.01f, true);
        return;
    }
 
    for (UMaterialInstanceDynamic* DynamicMaterial : DynamicMaterials)
    {
        DynamicMaterial->SetScalarParameterValue(ActiveOpacityParameterName, ActiveTransitionEndOpacity);
    }
 
    CompleteMaterialTransition();
}

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

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

ClearMaterialTransitionTimer()

void UEnemyDespawnDefinition::ClearMaterialTransitionTimer ( )

private

{
    if (ActiveWorld.IsValid() == false)
    {
        return;
    }
 
    FTimerManager& WorldTimerManager = ActiveWorld->GetTimerManager();
    WorldTimerManager.ClearTimer(MaterialTransitionTimerHandle);
}

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

CompleteMaterialTransition()

void UEnemyDespawnDefinition::CompleteMaterialTransition ( )

private

{
    if (DespawnNiagaraSystem)
    {
        ActivateDespawnNiagara();
        return;
    }
 
    FinishFlow();
}

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

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

CreateCopyPoseProxyMesh()

USkeletalMeshComponent * UEnemyDespawnDefinition::CreateCopyPoseProxyMesh ( AEnemyCharacterBase *  InEnemyCharacter )

private

{
    DestroyCopyPoseProxy();
 
    if (InEnemyCharacter == nullptr)
    {
        return nullptr;
    }
 
    USkeletalMeshComponent* SourceMesh = InEnemyCharacter->GetMesh();
    if (SourceMesh == nullptr || SourceMesh->GetSkeletalMeshAsset() == nullptr)
    {
        return nullptr;
    }
 
    UWorld* World = InEnemyCharacter->GetWorld();
    if (World == nullptr)
    {
        return nullptr;
    }
 
    AActor* ProxyActor = World->SpawnActor<AActor>(AActor::StaticClass(), SourceMesh->GetComponentTransform());
    if (ProxyActor == nullptr)
    {
        return nullptr;
    }
 
#if WITH_EDITOR
    ProxyActor->SetFolderPath(FName(TEXT("EffectProxy/EnemyDespawn")));
#endif
 
    USkeletalMeshComponent* ProxyMesh = NewObject<USkeletalMeshComponent>(ProxyActor, TEXT("EnemyDespawnCopyPoseMesh"));
    if (ProxyMesh == nullptr)
    {
        ProxyActor->Destroy();
        return nullptr;
    }
 
    ProxyActor->SetRootComponent(ProxyMesh);
    ProxyActor->AddInstanceComponent(ProxyMesh);
    ProxyMesh->RegisterComponent();
    ProxyMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    ProxyMesh->SetReceivesDecals(false);
    ProxyMesh->SetCastShadow(false);
    ProxyMesh->bCastDynamicShadow = false;
    ProxyMesh->SetSkeletalMesh(SourceMesh->GetSkeletalMeshAsset(), false);
    ProxyMesh->SetWorldTransform(SourceMesh->GetComponentTransform());
    ProxyMesh->AttachToComponent(SourceMesh, FAttachmentTransformRules::KeepWorldTransform);
    ProxyMesh->SetAnimationMode(EAnimationMode::AnimationBlueprint);
    ProxyMesh->SetAnimInstanceClass(UEnemyDespawnCopyPoseAnimInstance::StaticClass());
    ProxyMesh->TickAnimation(0.0f, false);
    ProxyMesh->RefreshBoneTransforms();
    ProxyMesh->DetachFromComponent(FDetachmentTransformRules::KeepWorldTransform);
    ProxyMesh->SetWorldTransform(SourceMesh->GetComponentTransform());
    ProxyMesh->SetComponentTickEnabled(false);
    ProxyMesh->SetVisibility(false, false);
    ProxyMesh->SetHiddenInGame(true, false);
 
    ActiveCopyPoseProxyActor = ProxyActor;
    ActiveCopyPoseProxyMesh = ProxyMesh;
    ActiveCopyPoseProxyWorld = World;
    return ProxyMesh;
}

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

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

DestroyCopyPoseProxy()

void UEnemyDespawnDefinition::DestroyCopyPoseProxy ( )

private

{
    if (ActiveCopyPoseProxyWorld.IsValid())
    {
        FTimerManager& WorldTimerManager = ActiveCopyPoseProxyWorld->GetTimerManager();
        WorldTimerManager.ClearTimer(CopyPoseProxyCleanupTimerHandle);
    }
 
    if (ActiveCopyPoseProxyActor)
    {
        ActiveCopyPoseProxyActor->Destroy();
    }
 
    ActiveCopyPoseProxyActor = nullptr;
    ActiveCopyPoseProxyMesh = nullptr;
    ActiveCopyPoseProxyWorld.Reset();
}

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

GetDespawnMaterialTransition()

FORCEINLINE FMaterialOpacityTransition UEnemyDespawnDefinition::GetDespawnMaterialTransition ( ) const

inline

    {
        return DespawnMaterialTransition;
    }

HandleFlowFinished()

void UEnemyDespawnDefinition::HandleFlowFinished ( )

overrideprotectedvirtual

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

{
    Super::HandleFlowFinished();
    ClearMaterialTransitionTimer();
    RestoreMaterialSlots();
 
    TFunction<void()> FinishedCallback = MoveTemp(OnDespawnFlowFinished);
    OnDespawnFlowFinished = nullptr;
 
    if (FinishedCallback)
    {
        FinishedCallback();
    }
}

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

HandleFlowReset()

void UEnemyDespawnDefinition::HandleFlowReset ( )

overrideprotectedvirtual

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

{
    Super::HandleFlowReset();
    ClearMaterialTransitionTimer();
    DestroyCopyPoseProxy();
    RestoreMaterialSlots();
    OnDespawnFlowFinished = nullptr;
}

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

HandleFlowStarted()

void UEnemyDespawnDefinition::HandleFlowStarted ( UObject *  InFlowOwner )

overrideprotectedvirtual

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

{
    Super::HandleFlowStarted(InFlowOwner);
    PlayDespawnFlow(Cast<AEnemyCharacterBase>(InFlowOwner));
}

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

PlayDespawnFlow()

void UEnemyDespawnDefinition::PlayDespawnFlow ( AEnemyCharacterBase *  InEnemyCharacter )

protected

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

PlayDespawnFlow_Implementation()

void UEnemyDespawnDefinition::PlayDespawnFlow_Implementation ( AEnemyCharacterBase *  InEnemyCharacter )

protectedvirtual

{
    PrepareDespawnNiagara(InEnemyCharacter);
    ApplyMaterialTransition(InEnemyCharacter, DespawnMaterialTransition);
}

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

PrepareDespawnNiagara()

void UEnemyDespawnDefinition::PrepareDespawnNiagara ( AEnemyCharacterBase *  InEnemyCharacter )

private

{
    if (DespawnNiagaraSystem == nullptr)
    {
        return;
    }
 
    const USkeletalMeshComponent* ProxyMesh = CreateCopyPoseProxyMesh(InEnemyCharacter);
    
    if (ProxyMesh)
    {
        return;
    }
    
    LOG_ERROR(LogCK, "%s 를 생성하지 못했습니다. ", NAMEOF_VAR(ProxyMesh));
}

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

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

RestoreMaterialSlots()

void UEnemyDespawnDefinition::RestoreMaterialSlots ( )

private

{
    AEnemyCharacterBase* EnemyCharacter = ActiveEnemyCharacter.Get();
 
    if (USkeletalMeshComponent* MeshComp = EnemyCharacter ? EnemyCharacter->GetMesh() : nullptr)
    {
        for (int32 Index = 0; Index < ActiveMaterialSlotIndices.Num(); ++Index)
        {
            if (OriginalMaterials.IsValidIndex(Index))
            {
                MeshComp->SetMaterial(ActiveMaterialSlotIndices[Index], OriginalMaterials[Index]);
            }
        }
    }
 
    ActiveEnemyCharacter.Reset();
    ActiveWorld.Reset();
    ActiveMaterialSlotIndices.Reset();
    OriginalMaterials.Reset();
    DynamicMaterials.Reset();
}

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

ScheduleCopyPoseProxyCleanup()

void UEnemyDespawnDefinition::ScheduleCopyPoseProxyCleanup ( )

private

{
    if (ActiveCopyPoseProxyWorld.IsValid() == false || DespawnNiagaraPlayTime <= 0.0f)
    {
        DestroyCopyPoseProxy();
        return;
    }
 
    FTimerManager& WorldTimerManager = ActiveCopyPoseProxyWorld->GetTimerManager();
    WorldTimerManager.SetTimer(CopyPoseProxyCleanupTimerHandle, this, &ThisClass::DestroyCopyPoseProxy, DespawnNiagaraPlayTime, false);
}

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

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

StartEnemyDespawnFlow() [1/2]

bool UEnemyDespawnDefinition::StartEnemyDespawnFlow

(

AEnemyCharacterBase *

InEnemyCharacter

)

{
    return StartEnemyDespawnFlow(InEnemyCharacter, TFunction<void()>());
}

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

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

StartEnemyDespawnFlow() [2/2]

bool UEnemyDespawnDefinition::StartEnemyDespawnFlow	(	AEnemyCharacterBase *	InEnemyCharacter,
		TFunction< void()> &&	InOnFlowFinished
	)

{
    OnDespawnFlowFinished = MoveTemp(InOnFlowFinished);
 
    if (StartFlow(InEnemyCharacter))
    {
        return true;
    }
 
    TFunction<void()> FailedCallback = MoveTemp(OnDespawnFlowFinished);
    OnDespawnFlowFinished = nullptr;
 
    if (FailedCallback)
    {
        FailedCallback();
    }
 
    return false;
}

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

UpdateMaterialTransition()

void UEnemyDespawnDefinition::UpdateMaterialTransition ( )

private

{
    AEnemyCharacterBase* EnemyCharacter = ActiveEnemyCharacter.Get();
 
    if (EnemyCharacter == nullptr)
    {
        FinishFlow();
        return;
    }
 
    UWorld* World = EnemyCharacter->GetWorld();
 
    if (World == nullptr)
    {
        FinishFlow();
        return;
    }
 
    const float ElapsedSeconds = World->GetTimeSeconds() - MaterialTransitionStartTime;
 
    float Alpha = 0.0f;
 
    if (ActiveTransitionDurationSeconds > 0.0f)
    {
        Alpha = FMath::Clamp(ElapsedSeconds / ActiveTransitionDurationSeconds, 0.0f, 1.0f);
    }
    else
    {
        Alpha = 1.0f;
    }
 
    const float Opacity = FMath::Lerp(ActiveTransitionStartOpacity, ActiveTransitionEndOpacity, Alpha);
 
    for (UMaterialInstanceDynamic* DynamicMaterial : DynamicMaterials)
    {
        DynamicMaterial->SetScalarParameterValue(ActiveOpacityParameterName, Opacity);
    }
 
    if (Alpha + KINDA_SMALL_NUMBER < 1.0f)
    {
        return;
    }
 
    CompleteMaterialTransition();
}

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

멤버 데이터 문서화

ActiveCopyPoseProxyActor

TObjectPtr<AActor> UEnemyDespawnDefinition::ActiveCopyPoseProxyActor

private

ActiveCopyPoseProxyMesh

TObjectPtr<USkeletalMeshComponent> UEnemyDespawnDefinition::ActiveCopyPoseProxyMesh

private

ActiveCopyPoseProxyWorld

TWeakObjectPtr<UWorld> UEnemyDespawnDefinition::ActiveCopyPoseProxyWorld

private

ActiveEnemyCharacter

TWeakObjectPtr<AEnemyCharacterBase> UEnemyDespawnDefinition::ActiveEnemyCharacter

private

ActiveMaterialSlotIndices

TArray<int32> UEnemyDespawnDefinition::ActiveMaterialSlotIndices

private

ActiveOpacityParameterName

FName UEnemyDespawnDefinition::ActiveOpacityParameterName = TEXT("Opacity")

private

ActiveTransitionDurationSeconds

float UEnemyDespawnDefinition::ActiveTransitionDurationSeconds = 0.0f

private

ActiveTransitionEndOpacity

float UEnemyDespawnDefinition::ActiveTransitionEndOpacity = 0.0f

private

ActiveTransitionStartOpacity

float UEnemyDespawnDefinition::ActiveTransitionStartOpacity = 1.0f

private

ActiveWorld

TWeakObjectPtr<UWorld> UEnemyDespawnDefinition::ActiveWorld

private

CopyPoseProxyCleanupTimerHandle

FTimerHandle UEnemyDespawnDefinition::CopyPoseProxyCleanupTimerHandle

private

DespawnMaterialTransition

FMaterialOpacityTransition UEnemyDespawnDefinition::DespawnMaterialTransition = FMaterialOpacityTransition(1.0f, 0.0f)

protected

DespawnNiagaraPlayTime

float UEnemyDespawnDefinition::DespawnNiagaraPlayTime = 2.0f

protected

DespawnNiagaraSystem

TObjectPtr<UNiagaraSystem> UEnemyDespawnDefinition::DespawnNiagaraSystem

protected

DynamicMaterials

TArray<TObjectPtr<UMaterialInstanceDynamic> > UEnemyDespawnDefinition::DynamicMaterials

private

MaterialTransitionStartTime

float UEnemyDespawnDefinition::MaterialTransitionStartTime = 0.0f

private

MaterialTransitionTimerHandle

FTimerHandle UEnemyDespawnDefinition::MaterialTransitionTimerHandle

private

OnDespawnFlowFinished

TFunction<void()> UEnemyDespawnDefinition::OnDespawnFlowFinished

private

OriginalMaterials

TArray<TObjectPtr<UMaterialInterface> > UEnemyDespawnDefinition::OriginalMaterials

private

SkeletalMeshUserParameterName

FName UEnemyDespawnDefinition::SkeletalMeshUserParameterName = TEXT("User.SkeletalMesh")

protected

---

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

• Source/CK_UE/Data/Flow/Enemy/EnemyDespawnDefinition.h
• Source/CK_UE/Data/Flow/Enemy/EnemyDespawnDefinition.cpp