Rename spawners to factories

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Actor/ActorDispatcher.cpp

@@ -8,7 +8,7 @@
 #include "Carla/Actor/ActorDispatcher.h"
 
 #include "Carla/Actor/ActorBlueprintFunctionLibrary.h"
-#include "Carla/Actor/ActorSpawner.h"
+#include "Carla/Actor/CarlaActorFactory.h"
 
 void FActorDispatcher::Bind(FActorDefinition Definition, SpawnFunctionType Functor)
 {
@@ -25,12 +25,12 @@ void FActorDispatcher::Bind(FActorDefinition Definition, SpawnFunctionType Funct
   }
 }
 
-void FActorDispatcher::Bind(AActorSpawner &ActorSpawner)
+void FActorDispatcher::Bind(ACarlaActorFactory &ActorFactory)
 {
-  for (const auto &Definition : ActorSpawner.MakeDefinitions())
+  for (const auto &Definition : ActorFactory.GetDefinitions())
   {
     Bind(Definition, [&](const FTransform &Transform, const FActorDescription &Description) {
-      return ActorSpawner.SpawnActor(Transform, Description);
+      return ActorFactory.SpawnActor(Transform, Description);
     });
   }
 }

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Actor/ActorDispatcher.h

@@ -14,7 +14,7 @@
 #include "Containers/Array.h"
 #include "Templates/Function.h"
 
-class AActorSpawner;
+class ACarlaActorFactory;
 
 /// Actor in charge of binding ActorDefinitions to spawn functions, as well as
 /// keeping the registry of all the actors spawned.
@@ -30,10 +30,10 @@ public:
   /// @warning Invalid definitions are ignored.
   void Bind(FActorDefinition Definition, SpawnFunctionType SpawnFunction);
 
-  /// Bind all the definitions of @a ActorSpawner to its spawn function.
+  /// Bind all the definitions of @a ActorFactory to its spawn function.
   ///
   /// @warning Invalid definitions are ignored.
-  void Bind(AActorSpawner &ActorSpawner);
+  void Bind(ACarlaActorFactory &ActorFactory);
 
   /// Spawns an actor based on @a ActorDescription at @a Transform. To properly
   /// despawn an actor created with this function call DestroyActor.

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Actor/CarlaActorFactory.h

@@ -13,24 +13,24 @@
 #include "Containers/Array.h"
 #include "GameFramework/Actor.h"
 
-#include "ActorSpawner.generated.h"
+#include "CarlaActorFactory.generated.h"
 
-/// Base class for Carla actor spawners.
+/// Base class for Carla actor factories.
 UCLASS(Abstract)
-class CARLA_API AActorSpawner : public AActor
+class CARLA_API ACarlaActorFactory : public AActor
 {
   GENERATED_BODY()
 
 public:
 
-  AActorSpawner(const FObjectInitializer& ObjectInitializer)
+  ACarlaActorFactory(const FObjectInitializer& ObjectInitializer)
     : Super(ObjectInitializer)
   {
     PrimaryActorTick.bCanEverTick = false;
   }
 
   /// Retrieve the list of actor definitions that this class is able to spawn.
-  virtual TArray<FActorDefinition> MakeDefinitions() {
+  virtual TArray<FActorDefinition> GetDefinitions() {
     unimplemented();
     return {};
   }
@@ -38,7 +38,7 @@ public:
   /// Spawn an actor based on @a ActorDescription and @a Transform.
   ///
   /// @pre ActorDescription is expected to be derived from one of the
-  /// definitions retrieved with MakeDefinitions.
+  /// definitions retrieved with GetDefinitions.
   virtual FActorSpawnResult SpawnActor(
       const FTransform &SpawnAtTransform,
       const FActorDescription &ActorDescription) {

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Actor/CarlaActorFactoryBlueprint.h

@@ -6,25 +6,25 @@
 
 #pragma once
 
-#include "Carla/Actor/ActorSpawner.h"
 #include "Carla/Actor/ActorSpawnResult.h"
+#include "Carla/Actor/CarlaActorFactory.h"
 
 #include "GameFramework/Actor.h"
 
-#include "ActorSpawnerBlueprint.generated.h"
+#include "CarlaActorFactoryBlueprint.generated.h"
 
-/// Base class for Blueprints implementing AActorSpawner interface.
+/// Base class for Blueprints implementing ACarlaActorFactory interface.
 ///
 /// Blueprints deriving from this class are expected to override
-/// GenerateDefinitions and SpawnActor functions.
+/// GetDefinitions and SpawnActor functions.
 UCLASS(Abstract, BlueprintType, Blueprintable)
-class CARLA_API AActorSpawnerBlueprint : public AActorSpawner
+class CARLA_API ACarlaActorFactoryBlueprint : public ACarlaActorFactory
 {
   GENERATED_BODY()
 
 public:
 
-  TArray<FActorDefinition> MakeDefinitions() final
+  TArray<FActorDefinition> GetDefinitions() final
   {
     return GenerateDefinitions();
   }

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaEpisode.h

@@ -31,9 +31,9 @@ public:
     return MapName;
   }
 
-  void RegisterActorSpawner(AActorSpawner &ActorSpawner)
+  void RegisterActorFactory(ACarlaActorFactory &ActorFactory)
   {
-    ActorDispatcher.Bind(ActorSpawner);
+    ActorDispatcher.Bind(ActorFactory);
   }
 
   /// Return the list of actor definitions that are available to be spawned this

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaGameModeBase.cpp

@@ -12,8 +12,8 @@
 #include "Game/CarlaPlayerState.h"
 #include "Game/Tagger.h"
 #include "Game/TaggerDelegate.h"
+#include "Sensor/OldSensorFactory.h"
 #include "Sensor/Sensor.h"
-#include "Sensor/SensorFactory.h"
 #include "Settings/CarlaSettings.h"
 #include "Settings/CarlaSettingsDelegate.h"
 #include "Util/RandomEngine.h"

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/TheNewCarlaGameModeBase.cpp

@@ -32,7 +32,7 @@ void ATheNewCarlaGameModeBase::InitGame(
       GameInstance != nullptr,
       TEXT("GameInstance is not a UCarlaGameInstance, did you forget to set it in the project settings?"));
 
-  SpawnActorSpawners();
+  SpawnActorFactories();
 }
 
 void ATheNewCarlaGameModeBase::BeginPlay()
@@ -56,20 +56,20 @@ void ATheNewCarlaGameModeBase::EndPlay(const EEndPlayReason::Type EndPlayReason)
   Super::EndPlay(EndPlayReason);
 }
 
-void ATheNewCarlaGameModeBase::SpawnActorSpawners()
+void ATheNewCarlaGameModeBase::SpawnActorFactories()
 {
   auto *World = GetWorld();
   check(World != nullptr);
 
-  for (auto &SpawnerClass : ActorSpawners)
+  for (auto &FactoryClass : ActorFactories)
   {
-    if (SpawnerClass != nullptr)
+    if (FactoryClass != nullptr)
     {
-      auto *Spawner = World->SpawnActor<AActorSpawner>(SpawnerClass);
-      if (Spawner != nullptr)
+      auto *Factory = World->SpawnActor<ACarlaActorFactory>(FactoryClass);
+      if (Factory != nullptr)
       {
-        Episode->RegisterActorSpawner(*Spawner);
-        ActorSpawnerInstances.Add(Spawner);
+        Episode->RegisterActorFactory(*Factory);
+        ActorFactoryInstances.Add(Factory);
       }
       else
       {

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/TheNewCarlaGameModeBase.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "Carla/Actor/ActorSpawner.h"
+#include "Carla/Actor/CarlaActorFactory.h"
 #include "Carla/Game/CarlaEpisode.h"
 
 #include "CoreMinimal.h"
@@ -36,7 +36,7 @@ protected:
 
 private:
 
-  void SpawnActorSpawners();
+  void SpawnActorFactories();
 
   UPROPERTY()
   UCarlaGameInstance *GameInstance = nullptr;
@@ -47,8 +47,8 @@ private:
   /// List of actor spawners that will be used to define and spawn the actors
   /// available in game.
   UPROPERTY(EditAnywhere)
-  TSet<TSubclassOf<AActorSpawner>> ActorSpawners;
+  TSet<TSubclassOf<ACarlaActorFactory>> ActorFactories;
 
   UPROPERTY()
-  TArray<AActorSpawner *> ActorSpawnerInstances;
+  TArray<ACarlaActorFactory *> ActorFactoryInstances;
 };

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/OldSensorFactory.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) 2017 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>.
+
+#pragma once
+
+#include "Carla.h"
+#include "OldSensorFactory.h"
+
+#include "Sensor/Lidar.h"
+#include "Sensor/SceneCaptureCamera.h"
+#include "Settings/CameraDescription.h"
+#include "Settings/LidarDescription.h"
+
+template <typename T, typename D>
+static T *SpawnSensor(const D &Description, UWorld &World)
+{
+  FActorSpawnParameters Params;
+  Params.Name = FName(*Description.Name);
+  return World.SpawnActor<T>(Description.Position, Description.Rotation, Params);
+}
+
+ASensor *FSensorFactory::Make(
+    const USensorDescription &Description,
+    UWorld &World)
+{
+  FSensorFactory Visitor(World);
+  Description.AcceptVisitor(Visitor);
+  check(Visitor.Sensor != nullptr);
+  return Visitor.Sensor;
+}
+
+FSensorFactory::FSensorFactory(UWorld &World) : World(World) {}
+
+void FSensorFactory::Visit(const UCameraDescription &Description)
+{
+  auto Camera = SpawnSensor<ASceneCaptureCamera>(Description, World);
+  Camera->Set(Description);
+  UE_LOG(
+      LogCarla,
+      Log,
+      TEXT("Created Capture Camera %d with postprocess \"%s\""),
+      Camera->GetId(),
+      *PostProcessEffect::ToString(Camera->GetPostProcessEffect()));
+  Sensor = Camera;
+}
+
+void FSensorFactory::Visit(const ULidarDescription &Description)
+{
+  auto Lidar = SpawnSensor<ALidar>(Description, World);
+  Lidar->Set(Description);
+  UE_LOG(
+      LogCarla,
+      Log,
+      TEXT("Created Lidar %d"),
+      Lidar->GetId());
+  Sensor = Lidar;
+}

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/OldSensorFactory.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2017 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>.
+
+#pragma once
+
+#include "Settings/SensorDescriptionVisitor.h"
+
+class ASensor;
+class UWorld;
+
+class FSensorFactory : private ISensorDescriptionVisitor
+{
+public:
+
+  static ASensor *Make(
+      const USensorDescription &Description,
+      UWorld &World);
+
+private:
+
+  FSensorFactory(UWorld &World);
+
+  virtual void Visit(const UCameraDescription &) final;
+
+  virtual void Visit(const ULidarDescription &) final;
+
+  UWorld &World;
+
+  ASensor *Sensor = nullptr;
+};

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorFactory.cpp

@@ -4,57 +4,69 @@
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.
 
-#pragma once
-
 #include "Carla.h"
-#include "SensorFactory.h"
+#include "Carla/Sensor/SensorFactory.h"
 
-#include "Sensor/Lidar.h"
-#include "Sensor/SceneCaptureCamera.h"
-#include "Settings/CameraDescription.h"
-#include "Settings/LidarDescription.h"
+#include "Carla/Sensor/SceneCaptureCamera.h"
 
-template <typename T, typename D>
-static T *SpawnSensor(const D &Description, UWorld &World)
+template <typename T>
+static FActorDefinition MakeSensorDefinition(const FString &Id)
+{
+  FActorDefinition Definition;
+  Definition.Id = Id;
+  Definition.Class = T::StaticClass();
+  Definition.Tags = TEXT("sensor,") + Id;
+  return Definition;
+}
+
+TArray<FActorDefinition> ASensorFactory::GetDefinitions()
+{
+  // Cameras.
+  auto Cameras = MakeSensorDefinition<ASceneCaptureCamera>("camera");
+  {
+    FActorVariation PostProcessing;
+    PostProcessing.Id = TEXT("PostProcessing");
+    PostProcessing.Type = EActorAttributeType::String;
+    PostProcessing.RecommendedValues = {
+        TEXT("None"),
+        TEXT("SceneFinal"),
+        TEXT("Depth"),
+        TEXT("SemanticSegmentation")
+    };
+    PostProcessing.bRestrictToRecommended = true;
+    FActorVariation FOV;
+    FOV.Id = TEXT("FOV");
+    FOV.Type = EActorAttributeType::Float;
+    FOV.RecommendedValues = { TEXT("90.0") };
+    FOV.bRestrictToRecommended = false;
+    FActorVariation ResX;
+    ResX.Id = TEXT("ImageSizeX");
+    ResX.Type = EActorAttributeType::Int;
+    ResX.RecommendedValues = { TEXT("800") };
+    ResX.bRestrictToRecommended = false;
+    FActorVariation ResY;
+    ResY.Id = TEXT("ImageSizeY");
+    ResY.Type = EActorAttributeType::Int;
+    ResY.RecommendedValues = { TEXT("600") };
+    ResY.bRestrictToRecommended = false;
+    Cameras.Variations = {PostProcessing, ResX, ResY, FOV};
+  }
+  return {Cameras};
+}
+
+FActorSpawnResult ASensorFactory::SpawnActor(
+    const FTransform &Transform,
+    const FActorDescription &Description)
 {
   FActorSpawnParameters Params;
-  Params.Name = FName(*Description.Name);
-  return World.SpawnActor<T>(Description.Position, Description.Rotation, Params);
-}
-
-ASensor *FSensorFactory::Make(
-    const USensorDescription &Description,
-    UWorld &World)
-{
-  FSensorFactory Visitor(World);
-  Description.AcceptVisitor(Visitor);
-  check(Visitor.Sensor != nullptr);
-  return Visitor.Sensor;
-}
-
-FSensorFactory::FSensorFactory(UWorld &World) : World(World) {}
-
-void FSensorFactory::Visit(const UCameraDescription &Description)
-{
-  auto Camera = SpawnSensor<ASceneCaptureCamera>(Description, World);
-  Camera->Set(Description);
-  UE_LOG(
-      LogCarla,
-      Log,
-      TEXT("Created Capture Camera %d with postprocess \"%s\""),
-      Camera->GetId(),
-      *PostProcessEffect::ToString(Camera->GetPostProcessEffect()));
-  Sensor = Camera;
-}
-
-void FSensorFactory::Visit(const ULidarDescription &Description)
-{
-  auto Lidar = SpawnSensor<ALidar>(Description, World);
-  Lidar->Set(Description);
-  UE_LOG(
-      LogCarla,
-      Log,
-      TEXT("Created Lidar %d"),
-      Lidar->GetId());
-  Sensor = Lidar;
+  static int32 COUNTER = 0u;
+  Params.Name = FName(*(Description.Id + FString::FromInt(++COUNTER)));
+  auto *World = GetWorld();
+  if (World == nullptr)
+  {
+    return {};
+  }
+  auto *Sensor = World->SpawnActor<ASensor>(Description.Class, Transform, Params);
+  /// @todo Set description: Actor->Set(Description);
+  return FActorSpawnResult{Sensor};
 }

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorFactory.h

@@ -6,28 +6,20 @@
 
 #pragma once
 
-#include "Settings/SensorDescriptionVisitor.h"
+#include "Carla/Actor/ActorSpawnResult.h"
+#include "Carla/Actor/CarlaActorFactory.h"
 
-class ASensor;
-class UWorld;
+#include "SensorFactory.generated.h"
 
-class FSensorFactory : private ISensorDescriptionVisitor
+/// Object in charge of spawning sensors.
+UCLASS()
+class CARLA_API ASensorFactory : public ACarlaActorFactory
 {
-public:
+  GENERATED_BODY()
 
-  static ASensor *Make(
-      const USensorDescription &Description,
-      UWorld &World);
+  TArray<FActorDefinition> GetDefinitions() final;
 
-private:
-
-  FSensorFactory(UWorld &World);
-
-  virtual void Visit(const UCameraDescription &) final;
-
-  virtual void Visit(const ULidarDescription &) final;
-
-  UWorld &World;
-
-  ASensor *Sensor = nullptr;
+  FActorSpawnResult SpawnActor(
+      const FTransform &SpawnAtTransform,
+      const FActorDescription &ActorDescription) final;
 };

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorSpawner.cpp

@@ -1,72 +0,0 @@
-// Copyright (c) 2017 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.h"
-#include "Carla/Sensor/SensorSpawner.h"
-
-#include "Carla/Sensor/SceneCaptureCamera.h"
-
-template <typename T>
-static FActorDefinition MakeSensorDefinition(const FString &Id)
-{
-  FActorDefinition Definition;
-  Definition.Id = Id;
-  Definition.Class = T::StaticClass();
-  Definition.Tags = TEXT("sensor,") + Id;
-  return Definition;
-}
-
-TArray<FActorDefinition> ASensorSpawner::MakeDefinitions()
-{
-  // Cameras.
-  auto Cameras = MakeSensorDefinition<ASceneCaptureCamera>("camera");
-  {
-    FActorVariation PostProcessing;
-    PostProcessing.Id = TEXT("PostProcessing");
-    PostProcessing.Type = EActorAttributeType::String;
-    PostProcessing.RecommendedValues = {
-        TEXT("None"),
-        TEXT("SceneFinal"),
-        TEXT("Depth"),
-        TEXT("SemanticSegmentation")
-    };
-    PostProcessing.bRestrictToRecommended = true;
-    FActorVariation FOV;
-    FOV.Id = TEXT("FOV");
-    FOV.Type = EActorAttributeType::Float;
-    FOV.RecommendedValues = { TEXT("90.0") };
-    FOV.bRestrictToRecommended = false;
-    FActorVariation ResX;
-    ResX.Id = TEXT("ImageSizeX");
-    ResX.Type = EActorAttributeType::Int;
-    ResX.RecommendedValues = { TEXT("800") };
-    ResX.bRestrictToRecommended = false;
-    FActorVariation ResY;
-    ResY.Id = TEXT("ImageSizeY");
-    ResY.Type = EActorAttributeType::Int;
-    ResY.RecommendedValues = { TEXT("600") };
-    ResY.bRestrictToRecommended = false;
-    Cameras.Variations = {PostProcessing, ResX, ResY, FOV};
-  }
-  return {Cameras};
-}
-
-FActorSpawnResult ASensorSpawner::SpawnActor(
-    const FTransform &Transform,
-    const FActorDescription &Description)
-{
-  FActorSpawnParameters Params;
-  static int32 COUNTER = 0u;
-  Params.Name = FName(*(Description.Id + FString::FromInt(++COUNTER)));
-  auto *World = GetWorld();
-  if (World == nullptr)
-  {
-    return {};
-  }
-  auto *Sensor = World->SpawnActor<ASensor>(Description.Class, Transform, Params);
-  /// @todo Set description: Actor->Set(Description);
-  return FActorSpawnResult{Sensor};
-}

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Sensor/SensorSpawner.h

@@ -1,27 +0,0 @@
-// Copyright (c) 2017 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>.
-
-#pragma once
-
-#include "Carla/Actor/ActorSpawner.h"
-#include "Carla/Actor/ActorSpawnResult.h"
-
-#include "GameFramework/Actor.h"
-
-#include "SensorSpawner.generated.h"
-
-/// Object in charge of spawning sensors.
-UCLASS()
-class CARLA_API ASensorSpawner : public AActorSpawner
-{
-  GENERATED_BODY()
-
-  TArray<FActorDefinition> MakeDefinitions() final;
-
-  FActorSpawnResult SpawnActor(
-      const FTransform &SpawnAtTransform,
-      const FActorDescription &ActorDescription) final;
-};