HighlightComponent.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "Utilities/HighlightComponent.h"
#include "Kismet/GameplayStatics.h"
 
// Sets default values for this component's properties
UHighlightComponent::UHighlightComponent()
{
    // Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
    // off to improve performance if you don't need them.
    PrimaryComponentTick.bCanEverTick = false;
 
    ColorMap.Add(EHighlightColor::None, FLinearColor(0.0f, 0.0f, 0.0f));
    ColorMap.Add(EHighlightColor::Blue, FLinearColor(0.0f, 0.866382f, 1.0f));
    ColorMap.Add(EHighlightColor::Green, FLinearColor(0.061116f, 1.0f, 0.0f));
    ColorMap.Add(EHighlightColor::Yellow, FLinearColor(1.0f, 0.850555f, 0.0f));
    ColorMap.Add(EHighlightColor::Red, FLinearColor(1.0f, 0.0f, 0.0f));
    ColorMap.Add(EHighlightColor::White, FLinearColor(1.0f, 1.0f, 1.0f));
    ColorMap.Add(EHighlightColor::Orange, FLinearColor(1.0f, 0.1f, 0.0f));
}
 
// Called when the game starts
void UHighlightComponent::BeginPlay()
{
    Super::BeginPlay();
}
 
void UHighlightComponent::UpdateHighlightValue(EHighlightColor HighlightColor)
{
    if (IsShowHighlight)
    {
        CurrentHighlight = HighlightColor;
        OnHighlightValueChanged.Broadcast();
        auto Color = [this]()->FVector{return FVector(*ColorMap.Find(CurrentHighlight));};
        UpdatedOwnerMeshComponents();
        if (AffectedMaterialIndexes.Num())
            ChangeHighlightSpecificMaterialColor(Color, OwnerMeshComponents, AffectedMaterialIndexes);
        else
            ChangeHighlightMaterialColor(Color, OwnerMeshComponents);
    }
}
 
void UHighlightComponent::ActivatePulseHighlight(bool Activate)
{
    if (!Activate)
    {
        if (PulseHighlightTimerHandle.IsValid())
        {
            HighlightTime = 0.0;
            PulseDirection = 0.0;
            PulseHighlightTimerHandle.Invalidate();
            BlockPulsing = true;
            AffectedMaterialIndexes.Empty();
        }
        UpdateHighlightValue(EHighlightColor::None);
    }
    else
    {
        HighlightTime = 1.0;
        PulseDirection = -1.0;
        UpdatedOwnerMeshComponents();
        PerformPulseHighlight();
    }
    OnHighlightChanged.Broadcast();
}
 
void UHighlightComponent::ManuallyActivatePulseHighlight(bool Activate, TArray<UMeshComponent*> TargetComponent)
{
    if (!Activate)
    {
        if (PulseHighlightTimerHandle.IsValid())
        {
            HighlightTime = 0.0;
            PulseDirection = 0.0;
            PulseHighlightTimerHandle.Invalidate();
            BlockPulsing = true;
            AffectedMaterialIndexes.Empty();
        }
        UpdateHighlightValue(EHighlightColor::None);
    }
    else
    {
        HighlightTime = 1.0;
        PulseDirection = -1.0;
        OwnerMeshComponents.Empty();
        for (auto const Component : TargetComponent)
        {
            OwnerMeshComponents.Add(Component);
        }
        PerformPulseHighlight();
    }
    OnHighlightChanged.Broadcast();
}
 
void UHighlightComponent::ManuallyActivatePulseHighlightOnSpecificMaterials(bool Activate,
    TArray<UMeshComponent*> TargetComponent, TArray<int> TargetMaterialIndexes)
{
    if (Activate)
        AffectedMaterialIndexes = TargetMaterialIndexes;
    else
        AffectedMaterialIndexes.Empty();
 
    ManuallyActivatePulseHighlight(Activate, TargetComponent);
}
 
void UHighlightComponent::PerformPulseHighlight()
{
    auto Color = [this]()->FVector
    {
        return FVector(FMath::Lerp(*ColorMap.Find(EHighlightColor::None), *ColorMap.Find(EHighlightColor::Blue), HighlightTime));;
    };
    
    if (AffectedMaterialIndexes.Num())
        ChangeHighlightSpecificMaterialColor(Color, OwnerMeshComponents, AffectedMaterialIndexes);
    else
        ChangeHighlightMaterialColor(Color, OwnerMeshComponents);
    
    HighlightTime = HighlightTime + (0.05 * PulseDirection);
    if (HighlightTime > 1.0)
    {
        HighlightTime = 1.0;
        PulseDirection = -1.0;
    }
    else if (HighlightTime < 0.0)
    {
        HighlightTime = 0.0;
        PulseDirection = 1.0;
    }
    if (BlockPulsing)
    {
        BlockPulsing = false;
        return;
    }
    GetWorld()->GetTimerManager().SetTimer( PulseHighlightTimerHandle,this, &UHighlightComponent::PerformPulseHighlight, 0.1);
}
 
void UHighlightComponent::ChangeHighlightMaterialColor(const TFunctionRef<FVector()> Color,  TArray<TWeakObjectPtr<UMeshComponent>> TargetMeshes)
{
    for (TWeakObjectPtr<UMeshComponent> Mesh : TargetMeshes)
    {
        if (DeactivatedMeshes.Find(Cast<UStaticMeshComponent>(Mesh.Get())) != INDEX_NONE)
        {
            continue;
        }
 
        if (UGameplayStatics::GetPlatformName() == TEXT("Android") || AlwaysEmissiveHighlight)
        {
            if (Cast<UStaticMeshComponent>(Mesh.Get()))
            {
                Mesh.Get()->SetVectorParameterValueOnMaterials(TEXT("EmissiveColor"), Color());
            }
            else if (Cast<USkeletalMeshComponent>(Mesh.Get()))
            {
                Mesh->SetVectorParameterValueOnMaterials(TEXT("EmissiveColor"), Color());
            }
        }
            
        else
        {
            if (CurrentHighlight == EHighlightColor::None)
                Mesh->SetRenderCustomDepth(false);
            else
                Mesh->SetRenderCustomDepth(true);
 
            Mesh->SetCustomDepthStencilValue((uint8)CurrentHighlight);
        }
    }
}
 
void UHighlightComponent::ChangeHighlightSpecificMaterialColor(const TFunctionRef<FVector()> Color,
    TArray<TWeakObjectPtr<UMeshComponent>> TargetMeshes, TArray<int> MaterialIndexes)
{
    for (TWeakObjectPtr<UMeshComponent> Mesh : TargetMeshes)
    {
        if (DeactivatedMeshes.Find(Cast<UStaticMeshComponent>(Mesh.Get())) != INDEX_NONE)
        {
            continue;
        }
        
        if (UGameplayStatics::GetPlatformName() == TEXT("Android") || AlwaysEmissiveHighlight)
        {
            if (Cast<UStaticMeshComponent>(Mesh.Get()))
            {
                for (int Index : MaterialIndexes)
                {
                    UMaterialInstanceDynamic* DynamicMaterial = Cast<UMaterialInstanceDynamic>(Mesh.Get()->GetMaterial(Index));
                    if (!DynamicMaterial)
                    {
                        DynamicMaterial = Mesh.Get()->CreateAndSetMaterialInstanceDynamic(Index);
                    }
                    DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), Color());
                }
            }
            else if (Cast<USkeletalMeshComponent>(Mesh.Get()))
            {
                for (int Index : MaterialIndexes)
                {
                    UMaterialInstanceDynamic* DynamicMaterial = Cast<UMaterialInstanceDynamic>(Mesh.Get()->GetMaterial(Index));
                    if (!DynamicMaterial)
                    {
                        DynamicMaterial = Mesh.Get()->CreateAndSetMaterialInstanceDynamic(Index);
                    }
                    DynamicMaterial->SetVectorParameterValue(TEXT("EmissiveColor"), Color());
                }
            }
        }
    }
}
 
void UHighlightComponent::UpdatedOwnerMeshComponents()
{
    OwnerMeshComponents.Empty();
    TArray<UStaticMeshComponent*> StaticMeshes;
    GetOwner()->GetComponents<UStaticMeshComponent>(StaticMeshes);
    TArray<USkeletalMeshComponent*> SkeletalMeshes;
    GetOwner()->GetComponents<USkeletalMeshComponent>(SkeletalMeshes);
    OwnerMeshComponents.Append(StaticMeshes);
    OwnerMeshComponents.Append(SkeletalMeshes);
}