UEnemySpawnDefinition 클래스 참조

#include <EnemySpawnDefinition.h>

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

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

Public 멤버 함수
bool	StartEnemySpawnFlow (AEnemyCharacterBase *InEnemyCharacter)
FORCEINLINE FMaterialOpacityTransition	GetSpawnEnterMaterialTransition () 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	PlaySpawnFlow_Implementation (AEnemyCharacterBase *InEnemyCharacter)
void	PlaySpawnFlow (AEnemyCharacterBase *InEnemyCharacter)
UFlowDefinitionBase(으)로부터 상속된 Protected 멤버 함수
void	StopFlow ()
void	ReceiveFlowStarted (UObject *InFlowOwner)
void	ReceiveFlowFinished ()
void	ReceiveFlowReset ()

Protected 속성
FMaterialOpacityTransition	SpawnEnterMaterialTransition

Private 멤버 함수
void	ApplyMaterialTransition (AEnemyCharacterBase *InEnemyCharacter, const FMaterialOpacityTransition &InTransition)
void	UpdateMaterialTransition ()
void	ClearMaterialTransitionTimer ()
void	RestoreMaterialSlots ()

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

멤버 함수 문서화

ApplyMaterialTransition()

void UEnemySpawnDefinition::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())
    {
        FinishFlow();
        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);
    }
 
    FinishFlow();
}

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

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

ClearMaterialTransitionTimer()

void UEnemySpawnDefinition::ClearMaterialTransitionTimer ( )

private

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

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

GetSpawnEnterMaterialTransition()

FORCEINLINE FMaterialOpacityTransition UEnemySpawnDefinition::GetSpawnEnterMaterialTransition ( ) const

inline

    {
        return SpawnEnterMaterialTransition;
    }

HandleFlowFinished()

void UEnemySpawnDefinition::HandleFlowFinished ( )

overrideprotectedvirtual

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

{
    Super::HandleFlowFinished();
    ClearMaterialTransitionTimer();
    RestoreMaterialSlots();
}

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

HandleFlowReset()

void UEnemySpawnDefinition::HandleFlowReset ( )

overrideprotectedvirtual

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

{
    Super::HandleFlowReset();
    ClearMaterialTransitionTimer();
    RestoreMaterialSlots();
}

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

HandleFlowStarted()

void UEnemySpawnDefinition::HandleFlowStarted ( UObject *  InFlowOwner )

overrideprotectedvirtual

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

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

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

PlaySpawnFlow()

void UEnemySpawnDefinition::PlaySpawnFlow ( AEnemyCharacterBase *  InEnemyCharacter )

protected

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

PlaySpawnFlow_Implementation()

void UEnemySpawnDefinition::PlaySpawnFlow_Implementation ( AEnemyCharacterBase *  InEnemyCharacter )

protectedvirtual

{
    ApplyMaterialTransition(InEnemyCharacter, SpawnEnterMaterialTransition);
}

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

RestoreMaterialSlots()

void UEnemySpawnDefinition::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();
}

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

StartEnemySpawnFlow()

bool UEnemySpawnDefinition::StartEnemySpawnFlow

(

AEnemyCharacterBase *

InEnemyCharacter

)

{
    return StartFlow(InEnemyCharacter);
}

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

UpdateMaterialTransition()

void UEnemySpawnDefinition::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;
    }
 
    // Enter 전이 완료. FinishFlow → HandleFlowFinished → RestoreMaterialSlots로 원본 머테리얼을 복원한다.
    FinishFlow();
}

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

멤버 데이터 문서화

ActiveEnemyCharacter

TWeakObjectPtr<AEnemyCharacterBase> UEnemySpawnDefinition::ActiveEnemyCharacter

private

ActiveMaterialSlotIndices

TArray<int32> UEnemySpawnDefinition::ActiveMaterialSlotIndices

private

ActiveOpacityParameterName

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

private

ActiveTransitionDurationSeconds

float UEnemySpawnDefinition::ActiveTransitionDurationSeconds = 0.0f

private

ActiveTransitionEndOpacity

float UEnemySpawnDefinition::ActiveTransitionEndOpacity = 1.0f

private

ActiveTransitionStartOpacity

float UEnemySpawnDefinition::ActiveTransitionStartOpacity = 0.0f

private

ActiveWorld

TWeakObjectPtr<UWorld> UEnemySpawnDefinition::ActiveWorld

private

DynamicMaterials

TArray<TObjectPtr<UMaterialInstanceDynamic> > UEnemySpawnDefinition::DynamicMaterials

private

MaterialTransitionStartTime

float UEnemySpawnDefinition::MaterialTransitionStartTime = 0.0f

private

MaterialTransitionTimerHandle

FTimerHandle UEnemySpawnDefinition::MaterialTransitionTimerHandle

private

OriginalMaterials

TArray<TObjectPtr<UMaterialInterface> > UEnemySpawnDefinition::OriginalMaterials

private

SpawnEnterMaterialTransition

FMaterialOpacityTransition UEnemySpawnDefinition::SpawnEnterMaterialTransition

protected

---

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

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