InstancedActor.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "InstancedActor.h"
#include "InstancedRenderer.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Engine/World.h"
 
#include "Kismet/GameplayStatics.h"
#include "TimerManager.h"
 
AInstancedActor::AInstancedActor(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMeshComponent"));
    RootComponent = StaticMeshComponent;
    PrimaryActorTick.bCanEverTick = false;
    InteractableName = NSLOCTEXT("Agrarsense", "StaticInstancedActorInteractableName", "Prop");
}
 
void AInstancedActor::BeginPlay()
{
    Super::BeginPlay();
 
    if (StaticMeshComponent) 
    {
        // Check if Custom Depth has been setup in Editor, if not Tagger.cpp needs to do this runtime.
        CustomDepthSetup = (StaticMeshComponent->bRenderCustomDepth && StaticMeshComponent->CustomDepthStencilValue == 0) ? true : false;
    }
    
    PreviousTransform = GetActorTransform();
 
    AddToInstancedRendering();
}
 
void AInstancedActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
    
    if (EndPlayReason != EEndPlayReason::Type::EndPlayInEditor)
    {
        RemoveFromInstancedRendering(false);
 
        if (StaticMeshComponent)
        {
            StaticMeshComponent->UnregisterComponent();
            StaticMeshComponent->DestroyComponent();
            StaticMeshComponent = nullptr;
        }
    }
}
 
void AInstancedActor::RemoveFromInstancedRendering(bool EnableStaticMeshComponent)
{
    if (AddedToInstancedRenderer)
    {
        AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(GetWorld());
        if (InstanceRenderer)
        {
            InstanceRenderer->RemoveInstance(ComponentIndex, InstanceNumber);
        }
    }
 
    AddedToInstancedRenderer = false;
 
    if (EnableStaticMeshComponent && StaticMeshComponent)
    {
        StaticMeshComponent->SetVisibility(true);
        StaticMeshComponent->SetComponentTickEnabled(true);
    }
}
 
bool AInstancedActor::AddToInstancedRendering()
{
    if (AddedToInstancedRenderer)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedActor.cpp: Already added to instanced rendering."));
#endif
        return false;
    }
 
    if (!AddToInstancedRenderer)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedActor.cpp: %s Actor is not being renderered by UInstancedStaticMeshComponent. If you did not mean to do this, make sure AddToInstancedRenderer is set to true in blueprint."), *this->GetName());;
#endif
        return false;
    }
 
    AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(GetWorld());
    if (InstanceRenderer)
    {
        return InstanceRenderer->AddActorToInstancedRendering(this);
    }
 
    return false;
}
 
void AInstancedActor::InstanceAdded(int32 CompIndex, int32 InstanceNum)
{
    // Hide StaticMeshComponent Visibility since InstancedRenderer
    // is now resposible for rendering this Actor's mesh.
    // Note. StaticMeshComponent is still resposible for collisions.
    if (StaticMeshComponent)
    {
        StaticMeshComponent->SetVisibility(false);
        StaticMeshComponent->SetComponentTickEnabled(false);
    }
 
    ComponentIndex = CompIndex;
    InstanceNumber = InstanceNum;
    AddedToInstancedRenderer = true;
}
 
void AInstancedActor::UpdateIndex(int32 UpdatedIndex)
{
    if (UpdatedIndex > InstanceNumber)
    {
        return;
    }
 
    --InstanceNumber;
}
 
void AInstancedActor::UpdateTransformPosition()
{
    if (ShouldUpdateTransformAutomatically) 
    {
        return;
    }
 
    AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(GetWorld());
    if (InstanceRenderer)
    {
        InstanceRenderer->UpdateInstanceTransform(ComponentIndex, InstanceNumber, GetActorTransform());
    }
}
 
void AInstancedActor::SetUpdateTransformAutomatically(bool UpdateAutomatically)
{
    if (ShouldUpdateTransformAutomatically == UpdateAutomatically || !AddedToInstancedRenderer)
    {
        // No change, return
        return;
    }
 
    ShouldUpdateTransformAutomatically = UpdateAutomatically;
 
    AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(GetWorld());
    if (InstanceRenderer)
    {
        InstanceRenderer->AddOrRemoveActorFromAutomaticTransformUpdates(ShouldUpdateTransformAutomatically, this);
    }
}
 
bool AInstancedActor::IsTreeActor() const
{
    if (StaticMeshComponent)
    {
        UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
        if (Mesh) 
        {
            FString Path = Mesh->GetPathName();
            if (Path.Contains("Tree"))
            {
                return true;
            }
        }
    }
 
    return false;
}