DeletionVolume.cpp

Go to the documentation of this file.

// Copyright (c) 2024 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 "DeletionVolume.h"
 
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/InstancedRendering/InstancedRenderer.h"
#include "Agrarsense/InstancedRendering/InstancedActor.h"
#include "Agrarsense/Logging/SimulatorLog.h"
 
#include "Engine/OverlapResult.h"
#include "Components/PrimitiveComponent.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Engine/World.h"
 
ADeletionVolume::ADeletionVolume()
{
    PrimaryActorTick.bCanEverTick = false;
 
    CollisionBox = CreateDefaultSubobject<UBoxComponent>(TEXT("CollisionBox"));
    CollisionBox->InitBoxExtent(FVector(200.0f, 200.0f, 200.0f));
    CollisionBox->SetGenerateOverlapEvents(true);
    RootComponent = CollisionBox;
 
#if WITH_EDITOR
    VisualizerComponent = CreateDefaultSubobject<UBoundsVisualizerComponent>(TEXT("BoundsVisualizerComponent"));
    VisualizerComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    VisualizerComponent->SetGenerateOverlapEvents(false);
    VisualizerComponent->SetupAttachment(RootComponent);
    VisualizerComponent->SetVisibility(true);
#endif
}
 
void ADeletionVolume::BeginPlay()
{
    Super::BeginPlay();
 
    if (VisualizerComponent)
    {
        VisualizerComponent->SetCubeMesh();
        VisualizerComponent->SetVisibility(true);
    }
}
 
void ADeletionVolume::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (CollisionBox)
    {
        CollisionBox->DestroyComponent();
        CollisionBox = nullptr;
    }
 
    if (VisualizerComponent) 
    {
        VisualizerComponent->DestroyComponent();
        VisualizerComponent = nullptr;
    }
}
 
void ADeletionVolume::ChangeOverlapBounds(FVector Bounds)
{
    if (IsValid(this))
    {
        if (CollisionBox) 
        {
            CollisionBox->SetBoxExtent(Bounds);
        }
        
        if (VisualizerComponent) 
        {
            VisualizerComponent->SetRelativeScale3D(Bounds);
        }
    }
}
 
void ADeletionVolume::DestroyOverlappingActors(bool OnlyTrees)
{
    if (!IsValid(this) || !CollisionBox)
    {
        return;
    }
 
    FVector BoxCenter = CollisionBox->GetComponentLocation();
    FVector BoxExtent = CollisionBox->GetScaledBoxExtent();
 
    TArray<FOverlapResult> Overlaps;
 
    bool HasOverlaps = GetWorld()->OverlapMultiByChannel(
        Overlaps,
        BoxCenter,
        FQuat::Identity,
        ECC_WorldDynamic,
        FCollisionShape::MakeBox(BoxExtent),
        FCollisionQueryParams(NAME_None, false, this)
    );
 
    if (!HasOverlaps)
    {
        SimulatorLog::Log("No overlaps detected.");
        Destroy();
        return;
    }
 
    AInstancedRenderer* Renderer = UAgrarsenseStatics::GetInstancedRenderer(GetWorld());
 
    for (const FOverlapResult& Overlap : Overlaps)
    {
        if (UPrimitiveComponent* Component = Overlap.GetComponent())
        {
            UInstancedStaticMeshComponent* InstancedMesh = Cast<UInstancedStaticMeshComponent>(Component);
            if (InstancedMesh && Renderer)
            {
                // If this overlapped InstancedStaticMeshComponent, 
                // remove overlapping instances through InstancedRenderer
                FBox Box = FBox(BoxCenter - BoxExtent, BoxCenter + BoxExtent);
                Renderer->DestroyOverlappingInstancesBox(InstancedMesh, Box, OnlyTrees);
            }
            else
            {
                if (AActor* Actor = Component->GetOwner())
                {
                    if (AInstancedActor* InstancedActor = Cast<AInstancedActor>(Actor))
                    {
                        bool CanDelete = !OnlyTrees || (OnlyTrees && InstancedActor->IsTreeActor());
                        if (CanDelete)
                        {
                            InstancedActor->Destroy();
                        }
                    }
                }
            }
        }
    }
 
    // Destroy this actor after deleting overlapping actors inside the bounds.
    Destroy();
}