FadingComponent.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Utilities/FadingComponent.h"
 
// Sets default values for this component's properties
UFadingComponent::UFadingComponent()
{
    PrimaryComponentTick.bCanEverTick = true;
 
    static ConstructorHelpers::FObjectFinder<UCurveFloat> FadeOpacityCurveAsset(TEXT("CurveFloat'/PixoCore/Blueprints/FadeOpacityCurve.FadeOpacityCurve'"));
    ChangingFadeOpacityCurve = FadeOpacityCurveAsset.Object;
}
 
void UFadingComponent::FadeStaticMeshes(TArray<UStaticMeshComponent*> StaticMeshes, float TimeForFade, float DesiredOpacity)
{
    FadeDuration = TimeForFade;
 
    FinalOpacity = FMath::Clamp(DesiredOpacity, 0.0f, 1.0f);
 
    if (FinalOpacity > CurrentOpacity)
    {
        FadeType = FadeOut;
    }
    else if (FinalOpacity < CurrentOpacity)
    {
        FadeType = FadeIn;
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: FinalOpacity equals CurrentOpacity"));
        return;
    }
 
    if (StaticMeshes.Num() == 0)
    {
        UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: TargetMeshes array is empty"));
        return;
    }
 
    MaterialData.Empty();
 
    for (UStaticMeshComponent* Mesh : StaticMeshes)
    {
        if (!Mesh->IsValidLowLevelFast())
        {
            UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: Mesh isn't valid"));
        }
 
        AActor* Owner = Mesh->GetOwner();
        if (Owner->Implements<UPixoVRStoryObject>())
        {
            TArray<FTransparentMaterialData> MaterialDataTemp = IPixoVRStoryObject::Execute_GetActorTransparentMaterialData(Owner);
 
            if (MaterialDataTemp.Num() != 0)
            {
                FTransparentMaterialData* MeshData = MaterialDataTemp.FindByPredicate([Mesh](const FTransparentMaterialData& MeshDataIt)
                {
                    return MeshDataIt.MeshRef == Mesh;
                });
                
                if (MeshData)
                    MaterialData.Add(*MeshData);
                else
                    UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: There is no MaterialData for %s mesh"), *Mesh->GetName());
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: Actor has no transparent data!"));
                GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "UFadingComponent::FadeStaticMeshes: Actor has no transparent data!");
            }
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("UFadingComponent::FadeStaticMeshes: Actor doesn't implement interface!"));
            GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "UFadingComponent::FadeStaticMeshes: Actor doesn't implement interface!");
        }
    }
 
    Fade();
}
 
void UFadingComponent::FadeStaticMeshesFromTo(TArray<UStaticMeshComponent*> StaticMeshes, float TimeForFade,float FromOpacity, float ToOpacity)
{
    CurrentOpacity = FMath::Clamp(FromOpacity, 0.0f, 1.0f);
    FadeStaticMeshes(StaticMeshes, TimeForFade, ToOpacity);
}
 
void UFadingComponent::FadeActor(AActor* Actor, float TimeForFade, float DesiredOpacity)
{
    TArray<UStaticMeshComponent*> ActorStaticMeshes;
    Actor->GetComponents<UStaticMeshComponent>(ActorStaticMeshes);
    FadeStaticMeshes(ActorStaticMeshes, TimeForFade, DesiredOpacity);
}
 
void UFadingComponent::FadeCompleted()
{
    SetOpacity(FinalOpacity);
    
    if (CurrentOpacity == 1.0f)
        SetOpaqueMaterial();
    else if (CurrentOpacity == 0.0f)
        SetMeshesHidden(true);
}
 
// Called when the game starts
void UFadingComponent::BeginPlay()
{
    Super::BeginPlay();
 
    if (ChangingFadeOpacityCurve != nullptr)
    {
        FOnTimelineFloat TimelineProgress;
        TimelineProgress.BindUFunction(this, FName("FadeOpacityTimelineProcess"));
        FadeTimeline.AddInterpFloat(ChangingFadeOpacityCurve, TimelineProgress);
 
        FadeTimeline.SetLooping(false);
 
        OnFadeCompleted.AddDynamic(this, &UFadingComponent::FadeCompleted);
    }
    else
    {
        GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, "UFadingComponent::BeginPlay Setup ChangingFadeOpacityCurve");
    }
}
 
void UFadingComponent::SetOpaqueMaterial()
{
    for (FTransparentMaterialData TransparentMaterialData : MaterialData)
    {
        for (int MaterialIndex = 0; MaterialIndex < TransparentMaterialData.MI_OpaqueMaterials.Num(); MaterialIndex++)
        {
            TransparentMaterialData.MeshRef->SetMaterial(MaterialIndex, TransparentMaterialData.MI_OpaqueMaterials[MaterialIndex]);
        }
    }
}
 
void UFadingComponent::SetMeshesHidden(bool Hidden)
{
    for (const FTransparentMaterialData & TransparentMaterialData : MaterialData)
    {
        TransparentMaterialData.MeshRef->SetHiddenInGame(Hidden);
    }
}
 
void UFadingComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
 
    FadeTimeline.TickTimeline(DeltaTime);
}
 
void UFadingComponent::Fade()
{
    for (FTransparentMaterialData TransparentMaterialData : MaterialData)
    {
        for (int MaterialIndex = 0; MaterialIndex < TransparentMaterialData.MI_TransparentMaterials.Num(); MaterialIndex++)
        {
            TransparentMaterialData.MeshRef->SetMaterial(MaterialIndex, TransparentMaterialData.MI_TransparentMaterials[MaterialIndex]);
        }
    }
    SetMeshesHidden(false);
    
    FadeTimeline.SetNewTime(CurrentOpacity);
    if (FadeDuration > MIN_flt)
    {
        FadeTimeline.SetPlayRate(1.0f / FadeDuration);
 
        switch (FadeType)
        {
        case FadeIn:
            FadeTimeline.Reverse();
            break;
        case FadeOut:
            FadeTimeline.Play();
            break;
        }
    }
    else
    {
        FadeCompleted();
    }
}
 
void UFadingComponent::SetOpacity(const float Value)
{
    for (const FTransparentMaterialData & TransparentMaterialData : MaterialData)
    {
        TransparentMaterialData.MeshRef->SetScalarParameterValueOnMaterials("Opacity", Value);
        CurrentOpacity = Value;
    }
}
 
void UFadingComponent::FadeOpacityTimelineProcess(float Value)
{
    switch (FadeType)
    {
    case FadeIn:
        if (Value <= FinalOpacity)
        {
            FadeTimeline.Stop();
            OnFadeCompleted.Broadcast();
        }
        else
        {
            SetOpacity(Value);
        }
        break;
    case FadeOut:
        if (Value >= FinalOpacity)
        {
            FadeTimeline.Stop();
            OnFadeCompleted.Broadcast();
        }
        else
        {
            SetOpacity(Value);
        }
        break;
    }
}