SensorUtilities.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 "SensorUtilities.h"
#include "Kismet/GameplayStatics.h"
#include "Components/SceneCaptureComponent2D.h"
#include "Components/PrimitiveComponent.h"
 
#include "Agrarsense/Sensor/SensorsManagerComponent.h"
#include "Agrarsense/Sensor/Camera/Camera.h"
#include "Agrarsense/Vehicle/Vehicle.h"
#include "Agrarsense/Sensor/Sensor.h"
 
void USensorUtilities::EnableAllSensors(const UObject* WorldContextObject)
{
    SetSimulateAllSensors(WorldContextObject, true);
}
 
void USensorUtilities::DisableAllSensors(const UObject* WorldContextObject)
{
    SetSimulateAllSensors(WorldContextObject, false);
}
 
void USensorUtilities::SetSimulateAllSensors(const UObject* WorldContextObject, bool SimulateSensors)
{
    // Get all ASensor actors from the level
    TArray<AActor*> Sensors;
    UGameplayStatics::GetAllActorsOfClass(WorldContextObject, ASensor::StaticClass(), Sensors);
 
    for (AActor* SensorActor : Sensors)
    {
        ASensor* sensor = Cast<ASensor>(SensorActor);
        if (sensor != nullptr)
        {
            sensor->SetSimulateSensor(SimulateSensors);
        }
    }
}
 
void USensorUtilities::DestroyAllSensors(const UObject* WorldContextObject, bool DestroyDefaultVehicleSensors)
{
    // Most sensors should be attached to Vehicle(s)
    // Get all Vehicles from the level and destroy the sensors through USensorsManagerComponent
    TArray<AActor*> Vehicles;
    UGameplayStatics::GetAllActorsOfClass(WorldContextObject, AVehicle::StaticClass(), Vehicles);
    for (AActor* Actor : Vehicles)
    {
        AVehicle* Vehicle = Cast<AVehicle>(Actor);
        if (Vehicle)
        {
            auto* SensorManager = Vehicle->GetSensorsManager();
            if (SensorManager)
            {
                SensorManager->DestroyAllSensors();
            }
        }
    }
 
    Vehicles.Empty();
 
    // Destroy remaining sensors if they exist
    TArray<AActor*> Sensors;
    UGameplayStatics::GetAllActorsOfClass(WorldContextObject, ASensor::StaticClass(), Sensors);
    for (AActor* SensorActor : Sensors)
    {
        ASensor* Sensor = Cast<ASensor>(SensorActor);
        if (Sensor)
        {
            bool AllowedToDestroy = true;
            if (!DestroyDefaultVehicleSensors)
            {
                // We might not want to destroy these sensors,
                // as these sensors cannot be spawned back any in way at the moment.
                // These sensors are spawned automatically by Vehicle.cpp to each vehicle.
                ESensorTypes SensorType = Sensor->GetSensorType();
                if (SensorType == ESensorTypes::Overlap
                    || SensorType == ESensorTypes::Transform
                    || SensorType == ESensorTypes::Collision)
                {
                    AllowedToDestroy = false;
                }
            }
 
            if (AllowedToDestroy)
            {
                Sensor->Destroy();
            }
        }
    }
 
    Sensors.Empty();
}
 
void USensorUtilities::EnableSensorsAttachedToVehicle(AVehicle* Vehicle)
{
    SetSimulateSensorsAttachedToVehicle(Vehicle, true);
}
 
void USensorUtilities::DisableSensorsAttachedToVehicle(AVehicle* Vehicle)
{
    SetSimulateSensorsAttachedToVehicle(Vehicle, false);
}
 
void USensorUtilities::SetSimulateSensorsAttachedToVehicle(AVehicle* Vehicle, bool SimulateSensors)
{
    if (Vehicle == nullptr)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("vehicle is nullptr. Returning."));
#endif
        return;
    }
 
    // Get all Actors attached to Vehicle actor
    TArray<AActor*> Actors;
    Vehicle->GetAttachedActors(Actors);
 
    for (AActor* actor : Actors)
    {
        ASensor* sensor = Cast<ASensor>(actor);
        if (sensor)
        {
            sensor->SetSimulateSensor(SimulateSensors);
        }
    }
}
 
void USensorUtilities::HideComponentForAllCameraSensors(UPrimitiveComponent* PrimitiveComponent)
{
    if (PrimitiveComponent)
    {
        ASensor::HideComponentForAllCameras(PrimitiveComponent);
    }
}