PropActorFactory.cpp

Go to the documentation of this file.

// Copyright (c) 2026 Computer Vision Center (CVC) at the Universitat Autonoma
// de Barcelona (UAB).
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
 
#include "Carla/Actor/Factory/PropActorFactory.h"
#include "Carla/Actor/ActorBlueprintFunctionLibrary.h"
#include "Carla/Actor/CarlaBlueprintRegistry.h"
#include "Carla/ContentPacks/ContentPackManager.h"
#include "Carla/Actor/ActorDefinition.h"
#include "Carla/Game/CarlaEpisode.h"
 
#include <util/ue-header-guard-begin.h>
#include "Json.h"
#include "JsonUtilities.h"
#include "Misc/FileHelper.h"
#include "Misc/Paths.h"
#include "Engine/StaticMeshActor.h"
#include "Components/StaticMeshComponent.h"
#include <util/ue-header-guard-end.h>
 
TArray<FActorDefinition> APropActorFactory::GetDefinitions()
{
  // Rebuilt from scratch every episode, otherwise entries accumulate.
  Definitions.Reset();
  PropsParams.Reset();
  LoadPropParametersArrayFromFile("PropParameters.json", PropsParams);
  // Content packs: <Pack>/Content/Config/PropParameters.json, later packs
  // override earlier entries with the same Name.
  for (const FString &PackFile : UCarlaContentPackManager::FindPackCatalogFiles("PropParameters.json"))
  {
    TArray<FPropParameters> PackPropsParams;
    LoadPropParametersArrayFromFile(PackFile, PackPropsParams);
    UCarlaContentPackManager::MergeCatalog(PropsParams, PackPropsParams,
        [](const FPropParameters &P) { return P.Name; });
  }
  // Content packs may also ship the registry format
  // (<Pack>/Content/Config/<Pack>.Package.json: {"props": [{name, path, size}]}).
  {
    TArray<FPropParameters> PackRegistryProps;
    UCarlaBlueprintRegistry::LoadPropDefinitionsFromFiles(
        UCarlaBlueprintRegistry::FindContentPackPropFiles(), PackRegistryProps);
    UCarlaContentPackManager::MergeCatalog(PropsParams, PackRegistryProps,
        [](const FPropParameters &P) { return P.Name; });
  }
 
  MeshCacheByPath.Reset();
  for (const FPropParameters& Params : PropsParams)
  {
    if (Params.Mesh.IsNull())
    {
      continue;
    }
    const FString MeshPath = Params.Mesh.ToSoftObjectPath().ToString();
    UStaticMesh* Mesh = Params.Mesh.LoadSynchronous();
    if (Mesh != nullptr)
    {
      MeshCacheByPath.Add(MeshPath, Mesh);
    }
  }
 
  UActorBlueprintFunctionLibrary::MakePropDefinitions(PropsParams, Definitions);
  return Definitions;
}
 
FActorSpawnResult APropActorFactory::SpawnActor(
    const FTransform &SpawnAtTransform,
    const FActorDescription &ActorDescription)
{
  FActorSpawnResult SpawnResult;
  if(!IsValid(ActorDescription.Class))
  {
    UE_LOG(LogCarla, Error, TEXT("Actor Description Class is null."));
    SpawnResult.Status = EActorSpawnResultStatus::InvalidDescription;
    return SpawnResult;
  }
 
  FActorSpawnParameters SpawnParameters;
  SpawnParameters.SpawnCollisionHandlingOverride =
      ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
 
  AStaticMeshActor* StaticMeshActor = GetWorld()->SpawnActor<AStaticMeshActor>(
      ActorDescription.Class, SpawnAtTransform, SpawnParameters);
 
  SpawnResult.Actor = StaticMeshActor;
 
  if(StaticMeshActor == nullptr)
  {
    SpawnResult.Status = EActorSpawnResultStatus::Collision;
    return SpawnResult;
  }
 
  UStaticMeshComponent* StaticMeshComponent = Cast<UStaticMeshComponent>(
      StaticMeshActor->GetRootComponent());
 
  if (!StaticMeshComponent)
  {
    UE_LOG(LogCarla, Error, TEXT("Prop spawn failed: StaticMeshComponent is null for actor %s"),
        *ActorDescription.Id);
    StaticMeshActor->Destroy();
    SpawnResult.Status = EActorSpawnResultStatus::UnknownError;
    return SpawnResult;
  }
 
  if (!ActorDescription.Variations.Contains("mesh_path"))
  {
    UE_LOG(LogCarla, Error, TEXT("Prop spawn failed: No mesh_path variation found for actor %s"),
        *ActorDescription.Id);
    StaticMeshActor->Destroy();
    SpawnResult.Status = EActorSpawnResultStatus::InvalidDescription;
    return SpawnResult;
  }
 
  FString MeshPath = UActorBlueprintFunctionLibrary::ActorAttributeToString(
      ActorDescription.Variations["mesh_path"], "");
 
  if (MeshPath.IsEmpty())
  {
    UE_LOG(LogCarla, Error, TEXT("Prop spawn failed: mesh_path is empty for actor %s"),
        *ActorDescription.Id);
    StaticMeshActor->Destroy();
    SpawnResult.Status = EActorSpawnResultStatus::InvalidDescription;
    return SpawnResult;
  }
 
  UStaticMesh* Mesh = nullptr;
  if (TObjectPtr<UStaticMesh>* Cached = MeshCacheByPath.Find(MeshPath))
  {
    Mesh = Cached->Get();
  }
  else
  {
    UE_LOG(LogCarla, Warning,
        TEXT("PropActorFactory: mesh cache miss for '%s' (actor %s); falling back to synchronous LoadObject."),
        *MeshPath, *ActorDescription.Id);
    Mesh = LoadObject<UStaticMesh>(nullptr, *MeshPath);
    if (Mesh != nullptr)
    {
      MeshCacheByPath.Add(MeshPath, Mesh);
    }
  }
 
  if (Mesh == nullptr)
  {
    UE_LOG(LogCarla, Error, TEXT("Prop spawn failed: Failed to load mesh '%s' for actor %s"),
        *MeshPath, *ActorDescription.Id);
    StaticMeshActor->Destroy();
    SpawnResult.Status = EActorSpawnResultStatus::UnknownError;
    return SpawnResult;
  }
 
  StaticMeshComponent->SetMobility(EComponentMobility::Movable);
  if (!StaticMeshComponent->SetStaticMesh(Mesh))
  {
    UE_LOG(LogCarla, Error, TEXT("Prop spawn failed: Failed to set mesh '%s' for actor %s"),
        *MeshPath, *ActorDescription.Id);
    StaticMeshActor->Destroy();
    SpawnResult.Status = EActorSpawnResultStatus::UnknownError;
    return SpawnResult;
  }
 
  PostProcessProp(StaticMeshActor, ActorDescription);
  SpawnResult.Status = EActorSpawnResultStatus::Success;
  return SpawnResult;
}
 
void APropActorFactory::ReleaseContentPack(const FString &MountPoint)
{
  Definitions.RemoveAll([&](const FActorDefinition &D) { return DefinitionReferencesPath(D, MountPoint); });
  PropsParams.RemoveAll([&](const FPropParameters &P) {
    return P.Mesh.ToSoftObjectPath().ToString().StartsWith(MountPoint);
  });
  for (auto It = MeshCacheByPath.CreateIterator(); It; ++It)
  {
    if (It.Key().StartsWith(MountPoint))
    {
      It.RemoveCurrent();
    }
  }
}
 
TSharedPtr<FJsonObject> APropActorFactory::FPropParametersToJsonObject(const FPropParameters& PropParams)
{
  TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject);
 
  JsonObject->SetStringField(TEXT("Name"), PropParams.Name);
  JsonObject->SetStringField(TEXT("Mesh"), PropParams.Mesh.ToSoftObjectPath().ToString());
 
  FString PropSizeString;
  switch(PropParams.Size)
  {
    case EPropSize::Tiny:
        PropSizeString = FString("Tiny");
        break;
    case EPropSize::Small:
        PropSizeString = FString("Small");
        break;
    case EPropSize::Medium:
        PropSizeString = FString("Medium");
        break;
    case EPropSize::Big:
        PropSizeString = FString("Big");
        break;
    case EPropSize::Huge:
        PropSizeString = FString("Huge");
        break;
    default:
        PropSizeString = FString("INVALID");
        break;
  }
  JsonObject->SetStringField(TEXT("Size"), PropSizeString);
 
  JsonObject->SetStringField(TEXT("BaseType"), PropParams.BaseType);
  JsonObject->SetStringField(TEXT("SubType"), PropParams.SubType);
  return JsonObject;
}
 
FString APropActorFactory::FPropParametersArrayToJson(const TArray<FPropParameters>& PropParamsArray)
{
  TArray<TSharedPtr<FJsonValue>> JsonArray;
 
  for (const FPropParameters& PropParams : PropParamsArray)
  {
      // Convert each FPropParameters to a JSON object
      TSharedPtr<FJsonObject> JsonObject = FPropParametersToJsonObject(PropParams);
      JsonArray.Add(MakeShareable(new FJsonValueObject(JsonObject)));
  }
 
  // Convert the array of JSON objects into a single JSON object
  TSharedRef<FJsonObject> RootObject = MakeShareable(new FJsonObject);
  RootObject->SetArrayField(TEXT("Props"), JsonArray);
 
  // Serialize the JSON object into an FString
  FString OutputString;
  TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
  FJsonSerializer::Serialize(RootObject, Writer);
 
  return OutputString;
}
 
void APropActorFactory::SavePropParametersArrayToFile(const TArray<FPropParameters>& PropParametersArray, const FString& FileName)
{
    FString FilePath = FPaths::ProjectContentDir() + TEXT("Carla/Config/") + FileName;
    // Convert the array to an FString in JSON format
  FString JsonContent = FPropParametersArrayToJson(PropParametersArray);
 
    // Save the JSON to a file
    if (FFileHelper::SaveStringToFile(JsonContent, *FilePath))
    {
        UE_LOG(LogCarla, Log, TEXT("JSON file successfully saved at: %s"), *FilePath);
    }
    else
    {
        UE_LOG(LogCarla, Error, TEXT("Failed to save JSON file at: %s"), *FilePath);
    }
}
 
bool APropActorFactory::JsonToFPropParameters(const TSharedPtr<FJsonObject> JsonObject, FPropParameters& OutPropParams)
{
    if (!JsonObject.IsValid()) return false;
 
    JsonObject->TryGetStringField(TEXT("Name"), OutPropParams.Name);
 
    // Build the soft reference from the path string; the actual UStaticMesh
    // load is deferred to MakePropDefinition / the factory cache seed so the
    // JSON parse itself does not block on disk I/O.
    FString MeshPath;
    JsonObject->TryGetStringField(TEXT("Mesh"), MeshPath);
    OutPropParams.Mesh = TSoftObjectPtr<UStaticMesh>(FSoftObjectPath(MeshPath));
 
    FString PropSizeString;
    JsonObject->TryGetStringField(TEXT("Size"), PropSizeString);
 
    // Optional fields: catalogs written before the prop types keep the struct
    // default (empty) when absent.
    JsonObject->TryGetStringField(TEXT("BaseType"), OutPropParams.BaseType);
    JsonObject->TryGetStringField(TEXT("SubType"), OutPropParams.SubType);
 
    if(PropSizeString == FString("Tiny")){
        OutPropParams.Size = EPropSize::Tiny;
    }
    else if(PropSizeString == FString("Small"))
    {
        OutPropParams.Size = EPropSize::Small;
    }
    else if(PropSizeString == FString("Medium"))
    {
        OutPropParams.Size = EPropSize::Medium;
    }
    else if(PropSizeString == FString("Big"))
    {
        OutPropParams.Size = EPropSize::Big;
    }
    else if(PropSizeString == FString("Huge"))
    {
        OutPropParams.Size = EPropSize::Huge;
    }
    else
    {
        OutPropParams.Size = EPropSize::INVALID;
    }
 
    return true;
}
 
bool APropActorFactory::JsonToFPropParametersArray(const FString& JsonString, TArray<FPropParameters>& OutPropParamsArray)
{
    TSharedPtr<FJsonObject> RootObject;
    TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(JsonString);
 
    if (!FJsonSerializer::Deserialize(Reader, RootObject) || !RootObject.IsValid())
    {
        UE_LOG(LogCarla, Error, TEXT("Failed to parse JSON."));
        return false;
    }
 
    // Get the "Props" array from the JSON root object
    const TArray<TSharedPtr<FJsonValue>>* PropsArray;
    if (RootObject->TryGetArrayField(TEXT("Props"), PropsArray))
    {
        OutPropParamsArray.Empty();
        for (const TSharedPtr<FJsonValue>& PropValue : *PropsArray)
        {
            TSharedPtr<FJsonObject> PropObject = PropValue->AsObject();
            if (PropObject.IsValid())
            {
                FPropParameters PropParams;
                if (JsonToFPropParameters(PropObject, PropParams))
                {
                    OutPropParamsArray.Add(PropParams);
                }
            }
        }
    }
 
    return true;
}
 
void APropActorFactory::LoadPropParametersArrayFromFile(const FString& FileName, TArray<FPropParameters>& OutPropParamsArray)
{
  FString JsonString;
  // A relative name is resolved against the project catalog dir; an absolute
  // path (content pack catalogs) is used as is.
  FString FilePath = FPaths::IsRelative(FileName)
      ? FPaths::ProjectContentDir() + TEXT("Carla/Config/") + FileName
      : FileName;
  FString JsonContent;
 
  // Load the JSON file content into an FString
  if (FFileHelper::LoadFileToString(JsonContent, *FilePath))
  {
      // Parse the JSON and populate the TArray<FPropParameters>
      if (JsonToFPropParametersArray(JsonContent, OutPropParamsArray))
      {
          UE_LOG(LogCarla, Log, TEXT("Prop parameters loaded successfully from %s"), *FilePath);
      }
      else
      {
          UE_LOG(LogCarla, Error, TEXT("Failed to parse Prop parameters from %s"), *FilePath);
      }
  }
  else
  {
      UE_LOG(LogCarla, Error, TEXT("Failed to load file: %s"), *FilePath);
  }
}