ActorData.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/ActorData.h"
#include "Carla/Game/CarlaEpisode.h"
#include "Carla/Traffic/TrafficLightBase.h"
#include "Carla/Traffic/SignComponent.h"
#include "Carla/Traffic/TrafficLightComponent.h"
#include "Carla/Traffic/TrafficLightController.h"
#include "Carla/Game/CarlaGameModeBase.h"
#include "Carla/Game/CarlaStatics.h"
#include "Carla/Vehicle/CarlaWheeledVehicle.h"
#include "Carla/Walker/WalkerController.h"
#include "Carla/Walker/WalkerBase.h"
#include "Carla/Sensor/Sensor.h"
#include "CarlaActor.h"
 
#include <util/ue-header-guard-begin.h>
#include "Components/SkinnedMeshComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include <util/ue-header-guard-end.h>
 
FActorRigSnapshot FActorRigSnapshot::FromActor(const AActor *Actor)
{
  FActorRigSnapshot Rig;
  if (Actor == nullptr)
  {
    return Rig;
  }
  const FTransform ActorToWorld = Actor->GetActorTransform();
 
  TArray<UActorComponent *> Components;
  Actor->GetComponents(Components);
  for (UActorComponent *ActorComponent : Components)
  {
    // Scene components only: the others have no transform to report.
    USceneComponent *SceneComponent = Cast<USceneComponent>(ActorComponent);
    if (SceneComponent == nullptr)
    {
      continue;
    }
    Rig.ComponentNames.Add(SceneComponent->GetName());
    Rig.ComponentTransforms.Add(
        SceneComponent->GetComponentTransform().GetRelativeTransform(ActorToWorld));
 
    // Authored sockets only. A skinned mesh also reports each of its bones as a
    // socket, which duplicates the bone lists and can repeat a name.
    TArray<FComponentSocketDescription> Sockets;
    SceneComponent->QuerySupportedSockets(Sockets);
    for (const FComponentSocketDescription &Socket : Sockets)
    {
      if (Socket.Type != EComponentSocketType::Socket)
      {
        continue;
      }
      Rig.SocketNames.Add(Socket.Name.ToString());
      Rig.SocketTransforms.Add(
          SceneComponent->GetSocketTransform(Socket.Name, ERelativeTransformSpace::RTS_Actor));
    }
  }
 
  TArray<USkinnedMeshComponent *> SkinnedMeshComponents;
  Actor->GetComponents<USkinnedMeshComponent>(SkinnedMeshComponents);
  for (USkinnedMeshComponent *SkinnedMeshComponent : SkinnedMeshComponents)
  {
    const FTransform ComponentToWorld = SkinnedMeshComponent->GetComponentTransform();
    TArray<FName> BoneNames;
    SkinnedMeshComponent->GetBoneNames(BoneNames);
    // GetBoneNames walks the reference skeleton in bone-index order, the same
    // order as GetBoneTransform, so names and transforms stay index-aligned.
    const int32 NumBones = FMath::Min(BoneNames.Num(), SkinnedMeshComponent->GetNumBones());
    for (int32 BoneIndex = 0; BoneIndex < NumBones; ++BoneIndex)
    {
      Rig.BoneNames.Add(BoneNames[BoneIndex].ToString());
      Rig.BoneTransforms.Add(
          SkinnedMeshComponent->GetBoneTransform(BoneIndex, ComponentToWorld)
              .GetRelativeTransform(ActorToWorld));
    }
  }
  return Rig;
}
 
AActor* FActorData::RespawnActor(UCarlaEpisode* CarlaEpisode, const FActorInfo& Info)
{
  FTransform SpawnTransform = GetLocalTransform(CarlaEpisode);
  // hack to prevent wheel intersection with geometry
  SpawnTransform.AddToTranslation(FVector(0,0,15));
  return CarlaEpisode->ReSpawnActorWithInfo(SpawnTransform, Info.Description);
}
 
void FActorData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  AActor* Actor = CarlaActor->GetActor();
  FTransform Transform = Actor->GetTransform();
  Location = FDVector(Transform.GetLocation()) + CarlaEpisode->GetCurrentMapOrigin();
  Rotation = Transform.GetRotation();
  Scale = Transform.GetScale3D();
  UPrimitiveComponent* Component = Cast<UPrimitiveComponent>(Actor->GetRootComponent());
  if (Component)
  {
    bSimulatePhysics = Component->IsSimulatingPhysics();
    AngularVelocity = Component->GetPhysicsAngularVelocityInDegrees();
  }
  Velocity = Actor->GetVelocity();
  // The AActor is destroyed right after this, so the rig has to be kept here or
  // every component, bone and socket query fails for as long as it is dormant.
  Rig = FActorRigSnapshot::FromActor(Actor);
}
 
void FActorData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  AActor* Actor = CarlaActor->GetActor();
  Actor->SetActorTransform(GetLocalTransform(CarlaEpisode));
  UPrimitiveComponent* Component = Cast<UPrimitiveComponent>(Actor->GetRootComponent());
  if (Component)
  {
    Component->SetPhysicsLinearVelocity(
        Velocity, false, "None");
    Component->SetPhysicsAngularVelocityInDegrees(
        AngularVelocity, false, "None");
  }
  auto* Character = Cast<ACharacter>(Actor);
  auto* CarlaVehicle = Cast<ACarlaWheeledVehicle>(Actor);
  // The physics in the vehicles works in a different way so to disable them.
  if (CarlaVehicle != nullptr){
    CarlaVehicle->SetSimulatePhysics(bSimulatePhysics);
  }
  // The physics in the walkers also works in a different way so to disable them,
  // we need to do it in the UCharacterMovementComponent.
  else if (Character != nullptr)
  {
 
  }
  // In the rest of actors, the physics is controlled with the UPrimitiveComponent, so we use
  // that for disable it.
  else
  {
    auto RootComponent = Component;
    if (RootComponent != nullptr)
    {
      RootComponent->SetSimulatePhysics(bSimulatePhysics);
      RootComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    }
  }
}
 
FTransform FActorData::GetLocalTransform(UCarlaEpisode* CarlaEpisode) const
{
  FVector LocalLocation = (Location - CarlaEpisode->GetCurrentMapOrigin()).ToFVector();
  return FTransform(Rotation, LocalLocation, Scale);
}
 
void FVehicleData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RecordActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  ACarlaWheeledVehicle* Vehicle = Cast<ACarlaWheeledVehicle>(Actor);
  if (bSimulatePhysics)
  {
    PhysicsControl = Vehicle->GetVehiclePhysicsControl();
  }
  Control = Vehicle->GetVehicleControl();
  AckermannControl = Vehicle->GetVehicleAckermannControl();
  bAckermannControlActive = Vehicle->IsAckermannControlActive();
  AckermannControllerSettings = Vehicle->GetAckermannControllerSettings();
  LightState = Vehicle->GetVehicleLightState();
  auto Controller = Cast<AWheeledVehicleAIController>(Vehicle->GetController());
  if (Controller)
  {
    SpeedLimit = Controller->GetSpeedLimit();
  }
  FailureState = Vehicle->GetFailureState();
}
 
void FVehicleData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RestoreActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  ACarlaWheeledVehicle* Vehicle = Cast<ACarlaWheeledVehicle>(Actor);
  Vehicle->SetSimulatePhysics(bSimulatePhysics);
  if (bSimulatePhysics)
  {
    Vehicle->ApplyVehiclePhysicsControl(PhysicsControl);
  }
  Vehicle->ApplyAckermannControllerSettings(AckermannControllerSettings);
  if (!bAckermannControlActive)
  {
    Vehicle->ApplyVehicleControl(Control, EVehicleInputPriority::Client);
  }
  else
  {
    Vehicle->ApplyVehicleAckermannControl(AckermannControl, EVehicleInputPriority::Client);
  }
  Vehicle->SetVehicleLightState(LightState);
  auto Controller = Cast<AWheeledVehicleAIController>(Vehicle->GetController());
  if (Controller)
  {
    Controller->SetSpeedLimit(SpeedLimit);
  }
  Vehicle->SetFailureState(FailureState);
}
 
void FWalkerData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RecordActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  auto Walker = Cast<AWalkerBase>(Actor);
  auto Controller = Walker != nullptr ? Cast<AWalkerController>(Walker->GetController()) : nullptr;
  if (Controller != nullptr)
  {
    WalkerControl = carla::rpc::WalkerControl{Controller->GetWalkerControl()};
  }
  bAlive = Walker->bAlive;
}
 
void FWalkerData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RestoreActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  auto Walker = Cast<ACharacter>(Actor);
  auto Controller = Walker != nullptr ? Cast<AWalkerController>(Walker->GetController()) : nullptr;
  if (Controller != nullptr)
  {
    Controller->ApplyWalkerControl(WalkerControl);
  }
  auto CharacterMovement = Cast<UCharacterMovementComponent>(Walker->GetCharacterMovement());
  // TODO: Handle death timer
}
 
AActor* FTrafficSignData::RespawnActor(UCarlaEpisode* CarlaEpisode, const FActorInfo& Info)
{
  FTransform SpawnTransform = GetLocalTransform(CarlaEpisode);
  FActorSpawnParameters SpawnParams;
  SpawnParams.SpawnCollisionHandlingOverride =
      ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
  return CarlaEpisode->GetWorld()->SpawnActor<ATrafficSignBase>(
        Model,
        SpawnTransform,
        SpawnParams);
}
 
void FTrafficSignData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RecordActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  Model = Actor->GetClass();
  ATrafficSignBase* TrafficSign = Cast<ATrafficSignBase>(Actor);
  USignComponent* TrafficSignComponent =
        Cast<USignComponent>(TrafficSign->FindComponentByClass<USignComponent>());
  if (TrafficSignComponent)
  {
    SignModel = TrafficSignComponent->GetClass();
    SignId = TrafficSignComponent->GetSignId();
  }
}
 
void FTrafficSignData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  AActor* Actor = CarlaActor->GetActor();
  if (SignId.Len())
  {
    USignComponent* SignComponent =
        NewObject<USignComponent>(Actor, SignModel);
    SignComponent->SetSignId(SignId);
    SignComponent->RegisterComponent();
    SignComponent->AttachToComponent(
        Actor->GetRootComponent(),
        FAttachmentTransformRules::KeepRelativeTransform);
    ACarlaGameModeBase *GameMode = UCarlaStatics::GetGameMode(CarlaEpisode->GetWorld());
    SignComponent->InitializeSign(GameMode->GetMap().value());
  }
}
 
AActor* FTrafficLightData::RespawnActor(UCarlaEpisode* CarlaEpisode, const FActorInfo& Info)
{
  FTransform SpawnTransform = GetLocalTransform(CarlaEpisode);
  FActorSpawnParameters SpawnParams;
  SpawnParams.SpawnCollisionHandlingOverride =
      ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
  return CarlaEpisode->GetWorld()->SpawnActor<ATrafficLightBase>(
        Model,
        SpawnTransform,
        SpawnParams);
}
 
void FTrafficLightData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RecordActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  Model = Actor->GetClass();
  ATrafficLightBase* TrafficLight = Cast<ATrafficLightBase>(Actor);
  UTrafficLightComponent* Component = TrafficLight->GetTrafficLightComponent();
  SignId = Component->GetSignId();
  Controller = Component->GetController();
  Controller->RemoveTrafficLight(Component);
  Controller->AddCarlaActorTrafficLight(CarlaActor);
  LightState = TrafficLight->GetTrafficLightState();
  PoleIndex = TrafficLight->GetPoleIndex();
}
 
void FTrafficLightData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  AActor* Actor = CarlaActor->GetActor();
  ATrafficLightBase* TrafficLight = Cast<ATrafficLightBase>(Actor);
  UTrafficLightComponent* Component = TrafficLight->GetTrafficLightComponent();
  Component->SetSignId(SignId);
  Controller->RemoveCarlaActorTrafficLight(CarlaActor);
  Controller->AddTrafficLight(Component);
  ACarlaGameModeBase *GameMode = UCarlaStatics::GetGameMode(CarlaEpisode->GetWorld());
  Component->InitializeSign(GameMode->GetMap().value());
  Component->SetLightState(Controller->GetCurrentState().State);
  TrafficLight->SetPoleIndex(PoleIndex);
  TrafficLight->SetTrafficLightState(LightState);
}
 
void FActorSensorData::RecordActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RecordActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  ASensor* Sensor = Cast<ASensor>(Actor);
  Stream = Sensor->MoveDataStream();
}
 
void FActorSensorData::RestoreActorData(FCarlaActor* CarlaActor, UCarlaEpisode* CarlaEpisode)
{
  FActorData::RestoreActorData(CarlaActor, CarlaEpisode);
  AActor* Actor = CarlaActor->GetActor();
  ASensor* Sensor = Cast<ASensor>(Actor);
  Sensor->SetDataStream(std::move(Stream));
}