First pass on physics constraint management component

ParkourGame/Source/ParkourGame/ParkourGameCharacter.cpp

@@ -1,6 +1,10 @@
 // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
 
 #include "ParkourGameCharacter.h"
+
+#include "Private/Physics/ConstraintManager.h"
+
+// Engine
 #include "HeadMountedDisplayFunctionLibrary.h"
 #include "Camera/CameraComponent.h"
 #include "Components/CapsuleComponent.h"
@@ -45,6 +49,8 @@ AParkourGameCharacter::AParkourGameCharacter()
 
 	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
 	// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
+
+	ConstraintManager = CreateDefaultSubobject<UConstraintManager>(TEXT("ConstraintManager"));
 }
 
 //////////////////////////////////////////////////////////////////////////

ParkourGame/Source/ParkourGame/ParkourGameCharacter.h

@@ -18,6 +18,9 @@ class AParkourGameCharacter : public ACharacter
 	/** Follow camera */
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
 	class UCameraComponent* FollowCamera;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
+	class UConstraintManager* ConstraintManager;
 public:
 	AParkourGameCharacter();
 

ParkourGame/Source/ParkourGame/Private/Physics/ConstraintManager.cpp

@@ -0,0 +1,95 @@
+#include "ConstraintManager.h"
+
+#include "PhysicsEngine/PhysicsConstraintActor.h"
+#include "PhysicsEngine/PhysicsConstraintComponent.h"
+
+
+// Sets default values for this component's properties
+UConstraintManager::UConstraintManager()
+{
+	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
+	// off to improve performance if you don't need them.
+	PrimaryComponentTick.bCanEverTick = false;
+}
+
+
+// Called when the game starts
+void UConstraintManager::BeginPlay()
+{
+	Super::BeginPlay();
+
+
+}
+
+FGuid UConstraintManager::CreateConstraint(const FName& Bone, UPrimitiveComponent* OtherComp, const FName& OtherBone /*= NAME_None*/)
+{
+	UWorld* WorldPtr = GetWorld();
+
+	if (!OtherComp || Bone == NAME_None || !WorldPtr)
+		return FGuid();
+
+	// Create constraint comp
+	USkeletalMeshComponent* SkelMeshComp = GetSkeletalMeshComp();
+	UPhysicsConstraintComponent* NewConstraintComp = NewObject<UPhysicsConstraintComponent>(OtherComp->GetOwner());
+
+	if (!ensure(NewConstraintComp) || !ensure(SkelMeshComp))
+		return FGuid();
+
+	// Setup the constraint actor
+	FConstraintInstance ConstraintInstance;
+	NewConstraintComp->ConstraintInstance = ConstraintInstance;
+
+	NewConstraintComp->SetWorldLocation(OtherComp->GetOwner()->GetActorLocation());
+	NewConstraintComp->AttachToComponent (OtherComp, FAttachmentTransformRules::KeepWorldTransform, OtherBone);
+	NewConstraintComp->SetConstrainedComponents(OtherComp, OtherBone, SkelMeshComp, Bone);
+
+	// @TODO : Bind to constraint broken event and handle that case
+
+	// Add to our list of managed constraints
+	FManagedPhysicsConstraint& NewConstraint = m_ActiveConstraints[m_ActiveConstraints.AddDefaulted()];
+
+	NewConstraint.ConstraintID.NewGuid();
+	NewConstraint.ConstraintComp = NewConstraintComp;
+	NewConstraint.TargetBone = Bone;
+	NewConstraint.OtherComp = OtherComp;
+	NewConstraint.OtherBone = OtherBone;
+
+	return NewConstraint.ConstraintID;
+}
+
+void UConstraintManager::DestroyConstraint(const FGuid& Constraint)
+{
+	int32 RemoveIndex = m_ActiveConstraints.FindLastByPredicate([&](const FManagedPhysicsConstraint& QueryConstraint) {
+		return QueryConstraint.ConstraintID == Constraint;
+	});
+
+	if (RemoveIndex == INDEX_NONE)
+		return;
+
+	UPhysicsConstraintComponent* ConstraintCompPtr = m_ActiveConstraints[RemoveIndex].ConstraintComp.Get();
+
+	if (ConstraintCompPtr)
+	{
+		// @TODO Unbind from constrain broken event
+		ConstraintCompPtr->BreakConstraint();
+		ConstraintCompPtr->DestroyComponent();
+	}
+
+	m_ActiveConstraints.RemoveAtSwap(RemoveIndex);
+}
+
+void UConstraintManager::GetConstraintByTargetBone(const FName& Bone, TArray<FGuid>& outConstraints) const
+{
+	GetConstraintsByPredicate([&](const FManagedPhysicsConstraint& Constraint) {
+		return Constraint.TargetBone == Bone;
+	}, outConstraints);
+}
+
+USkeletalMeshComponent* UConstraintManager::GetSkeletalMeshComp()
+{
+	USkeletalMeshComponent* CompPtr = m_SkeletalMeshComp.Get();
+
+	if (CompPtr) return CompPtr;
+
+	return Cast<USkeletalMeshComponent>(GetOwner()->GetComponentByClass(USkeletalMeshComponent::StaticClass()));
+}

ParkourGame/Source/ParkourGame/Private/Physics/ConstraintManager.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "ConstraintManager.generated.h"
+
+
+// @TODO: have a lookup table of constraint profile data we can reference for different situations
+
+//typedef FGuid FConstraintID;
+
+class UPhysicsConstraintComponent;
+
+struct FManagedPhysicsConstraint
+{
+public:
+	FGuid ConstraintID;
+
+	TWeakObjectPtr<UPhysicsConstraintComponent> ConstraintComp;
+
+	FName TargetBone = NAME_None;
+
+	TWeakObjectPtr<USceneComponent> OtherComp;
+	FName OtherBone = NAME_None;
+};
+
+
+UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
+class UConstraintManager : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:	
+	// Sets default values for this component's properties
+	UConstraintManager();
+
+	// Called when the game starts
+	virtual void BeginPlay() override;
+
+public:
+
+	UFUNCTION(BlueprintCallable, Category = "ConstraintManager", meta = (AutoCreateRefTerm="Bone,OtherBone"))
+	FGuid CreateConstraint(const FName& Bone, UPrimitiveComponent* OtherComp, const FName& OtherBone = NAME_None);
+
+	UFUNCTION(BlueprintCallable, Category = "ConstraintManager")
+	void DestroyConstraint(const FGuid& Constraint);
+
+	template<typename Func>
+	void GetConstraintsByPredicate(Func Predicate, TArray<FGuid>& outConstraints) const
+	{
+		for (const FManagedPhysicsConstraint& Constraint : m_ActiveConstraints)
+		{
+			if (Predicate(Constraint))
+				outConstraints.Add(Constraint.ConstraintID);
+		}
+	}
+
+	UFUNCTION(BlueprintCallable, Category = "ConstraintManager", meta = (AutoCreateRefTerm="Bone"))
+	void GetConstraintByTargetBone(const FName& Bone, TArray<FGuid>& outConstraints) const;
+
+private:
+
+	USkeletalMeshComponent* GetSkeletalMeshComp();
+
+	TWeakObjectPtr<USkeletalMeshComponent> m_SkeletalMeshComp;
+	TArray<FManagedPhysicsConstraint> m_ActiveConstraints;
+};

ParkourGame/Source/ParkourGame/Private/Utils/ParkourGameLogging.cpp

@@ -0,0 +1,3 @@
+#include "ParkourGameLogging.h"
+
+DEFINE_LOG_CATEGORY(ParkourGame);

ParkourGame/Source/ParkourGame/Public/Utils/ParkourGameLogging.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "CoreMinimal.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(ParkourGame, Log, All);