feature/openplx-integration

Source/AGXCommon/Public/OpenPLX/PLX_Inputs.h

@@ -0,0 +1,48 @@
+// Copyright 2024, Algoryx Simulation AB.
+
+#pragma once
+
+// Unreal Engine includes.
+#include "CoreMinimal.h"
+#include "UObject/Class.h"
+
+#include "PLX_Inputs.generated.h"
+
+USTRUCT(BlueprintType)
+struct AGXCOMMON_API FPLX_Input
+{
+	GENERATED_BODY()
+
+	FPLX_Input() = default;
+	explicit FPLX_Input(const FString& InName)
+		: Name(InName)
+	{
+	}
+
+	virtual ~FPLX_Input() = default;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "OpenPXL")
+	FString Name;
+
+	virtual UScriptStruct* GetType() const
+	{
+		return FPLX_Input::StaticStruct();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct AGXCOMMON_API FPLX_LinearVelocity1DInput : public FPLX_Input
+{
+	GENERATED_BODY()
+
+	FPLX_LinearVelocity1DInput() = default;
+	explicit FPLX_LinearVelocity1DInput(const FString& InName)
+		: FPLX_Input(InName)
+	{
+	}
+
+	virtual UScriptStruct* GetType() const override
+	{
+		return FPLX_LinearVelocity1DInput::StaticStruct();
+	}
+};

Source/AGXCommon/Public/OpenPLX/PLX_Outputs.h

@@ -0,0 +1,48 @@
+// Copyright 2024, Algoryx Simulation AB.
+
+#pragma once
+
+// Unreal Engine includes.
+#include "CoreMinimal.h"
+#include "UObject/Class.h"
+
+#include "PLX_Outputs.generated.h"
+
+USTRUCT(BlueprintType)
+struct AGXCOMMON_API FPLX_Output
+{
+	GENERATED_BODY()
+
+	FPLX_Output() = default;
+	explicit FPLX_Output(const FString& InName)
+		: Name(InName)
+	{
+	}
+
+	virtual ~FPLX_Output() = default;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "OpenPXL")
+	FString Name;
+
+	virtual UScriptStruct* GetType() const
+	{
+		return FPLX_Output::StaticStruct();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct AGXCOMMON_API FPLX_AngleOutput : public FPLX_Output
+{
+	GENERATED_BODY()
+
+	FPLX_AngleOutput() = default;
+	explicit FPLX_AngleOutput(const FString& InName)
+		: FPLX_Output(InName)
+	{
+	}
+
+	virtual UScriptStruct* GetType() const override
+	{
+		return FPLX_AngleOutput::StaticStruct();
+	}
+};

Source/AGXUnreal/Private/AGX_Simulation.cpp

@@ -664,12 +664,8 @@ void UAGX_Simulation::Deinitialize()
 #endif
 
 	Super::Deinitialize();
-	if (!HasNative())
-	{
-		return;
-	}
-
-	ReleaseNative();
+	if (HasNative())
+		ReleaseNative();
 }
 
 #if WITH_EDITOR

Source/AGXUnreal/Private/Constraints/AGX_ConstraintController.cpp

@@ -39,6 +39,7 @@ FAGX_ConstraintController& FAGX_ConstraintController::operator=(
 	SpookDamping = Other.SpookDamping;
 	ForceRange = Other.ForceRange;
 	bRotational = Other.bRotational;
+	Name = Other.Name;
 	return *this;
 }
 
@@ -201,6 +202,7 @@ void FAGX_ConstraintController::UpdateNativeProperties()
 	NativeBarrier->SetCompliance(Compliance);
 	NativeBarrier->SetSpookDamping(SpookDamping);
 	NativeBarrier->SetForceRange(ForceRange);
+	NativeBarrier->SetName(Name);
 	UpdateNativePropertiesImpl();
 }
 
@@ -224,10 +226,14 @@ void FAGX_ConstraintController::CopyFrom(
 
 		if (ForceOverwriteInstances || Instance->ForceRange == ForceRange)
 			Instance->ForceRange = Source.GetForceRange();
+
+		if (ForceOverwriteInstances || Instance->Name == Name)
+			Instance->Name = Source.GetName();
 	}
 
 	bEnable = Source.GetEnable();
 	Compliance = Source.GetCompliance();
 	SpookDamping = Source.GetSpookDamping();
 	ForceRange = Source.GetForceRange();
+	Name = Source.GetName();
 }

Source/AGXUnreal/Private/OpenPLX/PLX_ModelRegistry.cpp

@@ -0,0 +1,46 @@
+// Copyright 2024, Algoryx Simulation AB.
+
+#pragma once
+
+#include "OpenPLX/PLX_ModelRegistry.h"
+
+
+UPLX_ModelRegistry* UPLX_ModelRegistry::GetFrom(UWorld* World)
+{
+	if (World == nullptr || !World->IsGameWorld())
+		return nullptr;
+
+	return World->GetSubsystem<UPLX_ModelRegistry>();
+}
+
+bool UPLX_ModelRegistry::HasNative() const
+{
+	return Native.HasNative();
+}
+
+FPLXModelRegistry* UPLX_ModelRegistry::GetNative()
+{
+	if (!HasNative())
+		return nullptr;
+
+	return &Native;
+}
+
+const FPLXModelRegistry* UPLX_ModelRegistry::GetNative() const
+{
+	if (!HasNative())
+		return nullptr;
+
+	return &Native;
+}
+
+void UPLX_ModelRegistry::Initialize(FSubsystemCollectionBase& Collection)
+{
+	Super::Initialize(Collection);
+}
+
+void UPLX_ModelRegistry::Deinitialize()
+{
+	Native.ReleaseNative();
+	Super::Deinitialize();
+}

Source/AGXUnreal/Private/OpenPLX/PLX_SignalHandlerComponent.cpp

@@ -0,0 +1,106 @@
+// Copyright 2024, Algoryx Simulation AB.
+
+#include "OpenPLX/PLX_SignalHandlerComponent.h"
+
+// AGX Dynamics for Unreal includes.
+#include "AGX_Simulation.h"
+#include "Constraints/AGX_ConstraintComponent.h"
+#include "Import/AGX_ModelSourceComponent.h"
+#include "OpenPLX/PLX_ModelRegistry.h"
+#include "Utilities/AGX_ObjectUtilities.h"
+#include "Utilities/AGX_StringUtilities.h"
+
+UPLX_SignalHandlerComponent::UPLX_SignalHandlerComponent()
+{
+	PrimaryComponentTick.bCanEverTick = false;
+}
+
+bool UPLX_SignalHandlerComponent::Send(const FPLX_LinearVelocity1DInput& Input, double Value)
+{
+	if (!SignalHandler.IsInitialized())
+		return false;
+
+	return SignalHandler.Send(Input, Value);
+}
+
+namespace PLX_SignalHandlerComponent_helpers
+{
+	TArray<FConstraintBarrier*> CollectConstraintBarriers(AActor* Owner)
+	{
+		if (Owner == nullptr)
+			return TArray<FConstraintBarrier*>();
+
+		TArray<UAGX_ConstraintComponent*> ConstraintsInThisActor =
+			FAGX_ObjectUtilities::Filter<UAGX_ConstraintComponent>(Owner->GetComponents());
+		TArray<FConstraintBarrier*> ConstraintBarriers;
+		for (UAGX_ConstraintComponent* Constraint : ConstraintsInThisActor)
+		{
+			if (auto CBarrier = Constraint->GetOrCreateNative())
+			{
+				if (CBarrier->HasNative())
+					ConstraintBarriers.Add(CBarrier);
+			}
+		}
+
+		return ConstraintBarriers;
+	}
+
+	TOptional<FString> GetPLXFilePath(AActor* Owner)
+	{
+		if (Owner == nullptr)
+			return {};
+
+		auto ModelSource = Owner->GetComponentByClass<UAGX_ModelSourceComponent>();
+		if (ModelSource == nullptr)
+			return {};
+
+		// Todo: this must point to the corresponding PLX file in the project files, copied from
+		// import, not the source file itself. This is to ensure portability of standalone-projects.
+		return ModelSource->FilePath;
+	}
+}
+
+bool UPLX_SignalHandlerComponent::Receive(const FPLX_AngleOutput& Output, double& OutValue)
+{
+	return SignalHandler.Receive(Output, OutValue);
+}
+
+void UPLX_SignalHandlerComponent::BeginPlay()
+{
+	using namespace PLX_SignalHandlerComponent_helpers;
+	Super::BeginPlay();
+
+	auto PLXFile = GetPLXFilePath(GetOwner());
+	if (!PLXFile.IsSet())
+	{
+		UE_LOG(
+			LogAGX, Warning,
+			TEXT("UPLX_SignalHandlerComponent '%s' in '%s' was unable to get OpenPLX file path "
+				 "from UAGX_ModelSourceComponent. OpenPLX Signals will not work properly."),
+			*GetName(), *GetLabelSafe(GetOwner()));
+		return;
+	}
+
+	auto Sim = UAGX_Simulation::GetFrom(this);
+	auto SimulationBarrier = Sim != nullptr ? Sim->GetNative() : nullptr;
+	if (SimulationBarrier == nullptr)
+	{
+		// todo: log warning.
+		return;
+	}
+
+	auto PLXModelRegistry = UPLX_ModelRegistry::GetFrom(GetWorld());
+	auto PLXModelRegistryBarrier =
+		PLXModelRegistry != nullptr ? PLXModelRegistry->GetNative() : nullptr;
+	if (PLXModelRegistryBarrier == nullptr)
+	{
+		// Todo: log warning.
+		return;
+	}
+
+	// Collect all Constraints in the same AActor as us.
+	TArray<FConstraintBarrier*> ConstraintBarriers = CollectConstraintBarriers(GetOwner());
+
+	// Initialize SignalHandler in Barrier module.
+	SignalHandler.Init(*PLXFile, *SimulationBarrier, *PLXModelRegistryBarrier, ConstraintBarriers);
+}

Source/AGXUnreal/Public/Constraints/AGX_ConstraintController.h

@@ -90,6 +90,9 @@ struct AGXUNREAL_API FAGX_ConstraintController
 
 	double GetForce();
 
+	UPROPERTY(EditAnywhere, Category = "AGX Constraint Controller")
+	FString Name;
+
 	/**
 	 * Handle serialization backwards compatibility. May be overridden by subclasses as long as they
 	 * call Super::Serialize.

Source/AGXUnrealEditor/Public/AGX_ImportEnums.h → Source/AGXUnreal/Public/Import/AGX_ImportEnums.h

@@ -13,9 +13,12 @@ enum class EAGX_ImportType : uint8
 	/** Imported type is Invalid. */
 	Invalid,
 
-	/** Imported type is AGX Dynamics Archive. */
+	/** Imported type is an AGX Dynamics Archive. */
 	Agx,
 
-	/** Imported type is URDF (Unified Robotic Description Format) model. */
+	/** Imported type is a OpenPLX model. */
+	Plx,
+
+	/** Imported type is a URDF (Unified Robotic Description Format) model. */
 	Urdf
 };

Source/AGXUnreal/Public/AGX_ModelSourceComponent.h → Source/AGXUnreal/Public/Import/AGX_ModelSourceComponent.h

@@ -5,6 +5,7 @@
 // Unreal Engine includes.
 #include "Components/ActorComponent.h"
 #include "CoreMinimal.h"
+#include "Import/AGX_ImportEnums.h"
 
 #include "AGX_ModelSourceComponent.generated.h"
 

Source/AGXUnreal/Public/OpenPLX/PLX_ModelRegistry.h

@@ -0,0 +1,38 @@
+// Copyright 2024, Algoryx Simulation AB.
+
+#pragma once
+
+// AGX Dynamics for Unreal includes.
+#include "OpenPLX/PLXModelRegistry.h"
+
+// Unreal Engine includes.
+#include "CoreMinimal.h"
+#include "LevelInstance/LevelInstanceSubsystem.h"
+#include "Subsystems/GameInstanceSubsystem.h"
+
+#include "PLX_ModelRegistry.generated.h"
+
+
+/**
+ * Todo: add description.
+ */
+UCLASS(ClassGroup = "PLX", Category = "PLX")
+class AGXUNREAL_API UPLX_ModelRegistry : public ULevelInstanceSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	static UPLX_ModelRegistry* GetFrom(UWorld* World);
+
+	bool HasNative() const;
+	FPLXModelRegistry* GetNative();
+	const FPLXModelRegistry* GetNative() const;
+
+private:
+	// ~Begin USubsystem interface.
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+	virtual void Deinitialize() override;
+	// ~End USubsystem interface.
+
+	FPLXModelRegistry Native;
+};