Fixed name clashes between Character and Ragdoll static inline functions when compiling a single compilation unit build (aka Unity build)

Jolt/Physics/Character/Character.cpp

@@ -13,17 +13,17 @@
 
 JPH_NAMESPACE_BEGIN
 
-static inline const BodyLockInterface &sGetBodyLockInterface(const PhysicsSystem *inSystem, bool inLockBodies)
+static inline const BodyLockInterface &sCharacterGetBodyLockInterface(const PhysicsSystem *inSystem, bool inLockBodies)
 {
 	return inLockBodies? static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterface()) : static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterfaceNoLock());
 }
 
-static inline BodyInterface &sGetBodyInterface(PhysicsSystem *inSystem, bool inLockBodies)
+static inline BodyInterface &sCharacterGetBodyInterface(PhysicsSystem *inSystem, bool inLockBodies)
 {
 	return inLockBodies? inSystem->GetBodyInterface() : inSystem->GetBodyInterfaceNoLock();
 }
 
-static inline const NarrowPhaseQuery &sGetNarrowPhaseQuery(const PhysicsSystem *inSystem, bool inLockBodies)
+static inline const NarrowPhaseQuery &sCharacterGetNarrowPhaseQuery(const PhysicsSystem *inSystem, bool inLockBodies)
 {
 	return inLockBodies? inSystem->GetNarrowPhaseQuery() : inSystem->GetNarrowPhaseQueryNoLock();
 }
@@ -54,17 +54,17 @@ Character::~Character()
 
 void Character::AddToPhysicsSystem(EActivation inActivationMode, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).AddBody(mBodyID, inActivationMode);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddBody(mBodyID, inActivationMode);
 }
 
 void Character::RemoveFromPhysicsSystem(bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).RemoveBody(mBodyID);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).RemoveBody(mBodyID);
 }
 
 void Character::Activate(bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).ActivateBody(mBodyID);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).ActivateBody(mBodyID);
 }
 
 void Character::CheckCollision(RMat44Arg inCenterOfMassTransform, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const
@@ -95,7 +95,7 @@ void Character::CheckCollision(RMat44Arg inCenterOfMassTransform, Vec3Arg inMove
 	settings.mActiveEdgeMovementDirection = inMovementDirection;
 	settings.mBackFaceMode = EBackFaceMode::IgnoreBackFaces;
 
-	sGetNarrowPhaseQuery(mSystem, inLockBodies).CollideShape(inShape, Vec3::sOne(), inCenterOfMassTransform, settings, inBaseOffset, ioCollector, broadphase_layer_filter, object_layer_filter, body_filter);
+	sCharacterGetNarrowPhaseQuery(mSystem, inLockBodies).CollideShape(inShape, Vec3::sOne(), inCenterOfMassTransform, settings, inBaseOffset, ioCollector, broadphase_layer_filter, object_layer_filter, body_filter);
 }
 
 void Character::CheckCollision(RVec3Arg inPosition, QuatArg inRotation, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const
@@ -112,7 +112,7 @@ void Character::CheckCollision(const Shape *inShape, float inMaxSeparationDistan
 	RMat44 query_transform;
 	Vec3 velocity;
 	{
-		BodyLockRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
+		BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
 		if (!lock.Succeeded())
 			return;
 
@@ -133,7 +133,7 @@ void Character::PostSimulation(float inMaxSeparationDistance, bool inLockBodies)
 	Quat char_rot;
 	Vec3 char_vel;
 	{
-		BodyLockRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
+		BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
 		if (!lock.Succeeded())
 			return;
 		const Body &body = lock.GetBody();
@@ -186,7 +186,7 @@ void Character::PostSimulation(float inMaxSeparationDistance, bool inLockBodies)
 	mGroundNormal = collector.mGroundNormal;
 
 	// Get additional data from body
-	BodyLockRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mGroundBodyID);
+	BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mGroundBodyID);
 	if (lock.Succeeded())
 	{
 		const Body &body = lock.GetBody();
@@ -216,74 +216,74 @@ void Character::PostSimulation(float inMaxSeparationDistance, bool inLockBodies)
 
 void Character::SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).SetLinearAndAngularVelocity(mBodyID, inLinearVelocity, inAngularVelocity);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetLinearAndAngularVelocity(mBodyID, inLinearVelocity, inAngularVelocity);
 }
 
 Vec3 Character::GetLinearVelocity(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetLinearVelocity(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetLinearVelocity(mBodyID);
 }
 
 void Character::SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).SetLinearVelocity(mBodyID, inLinearVelocity);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetLinearVelocity(mBodyID, inLinearVelocity);
 }
 
 void Character::AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).AddLinearVelocity(mBodyID, inLinearVelocity);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddLinearVelocity(mBodyID, inLinearVelocity);
 }
 
 void Character::AddImpulse(Vec3Arg inImpulse, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).AddImpulse(mBodyID, inImpulse);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddImpulse(mBodyID, inImpulse);
 }
 
 void Character::GetPositionAndRotation(RVec3 &outPosition, Quat &outRotation, bool inLockBodies) const
 {
-	sGetBodyInterface(mSystem, inLockBodies).GetPositionAndRotation(mBodyID, outPosition, outRotation);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).GetPositionAndRotation(mBodyID, outPosition, outRotation);
 }
 
 void Character::SetPositionAndRotation(RVec3Arg inPosition, QuatArg inRotation, EActivation inActivationMode, bool inLockBodies) const
 {
-	sGetBodyInterface(mSystem, inLockBodies).SetPositionAndRotation(mBodyID, inPosition, inRotation, inActivationMode);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetPositionAndRotation(mBodyID, inPosition, inRotation, inActivationMode);
 }
 
 RVec3 Character::GetPosition(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetPosition(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetPosition(mBodyID);
 }
 
 void Character::SetPosition(RVec3Arg inPosition, EActivation inActivationMode, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).SetPosition(mBodyID, inPosition, inActivationMode);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetPosition(mBodyID, inPosition, inActivationMode);
 }
 
 Quat Character::GetRotation(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetRotation(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetRotation(mBodyID);
 }
 
 void Character::SetRotation(QuatArg inRotation, EActivation inActivationMode, bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).SetRotation(mBodyID, inRotation, inActivationMode);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetRotation(mBodyID, inRotation, inActivationMode);
 }
 
 RVec3 Character::GetCenterOfMassPosition(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetCenterOfMassPosition(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetCenterOfMassPosition(mBodyID);
 }
 
 RMat44 Character::GetWorldTransform(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetWorldTransform(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetWorldTransform(mBodyID);
 }
 
 void Character::SetLayer(ObjectLayer inLayer, bool inLockBodies)
 {
 	mLayer = inLayer;
 
-	sGetBodyInterface(mSystem, inLockBodies).SetObjectLayer(mBodyID, inLayer);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetObjectLayer(mBodyID, inLayer);
 }
 
 bool Character::SetShape(const Shape *inShape, float inMaxPenetrationDepth, bool inLockBodies)
@@ -321,13 +321,13 @@ bool Character::SetShape(const Shape *inShape, float inMaxPenetrationDepth, bool
 
 	// Switch the shape
 	mShape = inShape;
-	sGetBodyInterface(mSystem, inLockBodies).SetShape(mBodyID, mShape, false, EActivation::Activate);
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetShape(mBodyID, mShape, false, EActivation::Activate);
 	return true;
 }
 
 TransformedShape Character::GetTransformedShape(bool inLockBodies) const
 {
-	return sGetBodyInterface(mSystem, inLockBodies).GetTransformedShape(mBodyID);
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetTransformedShape(mBodyID);
 }
 
 JPH_NAMESPACE_END

Jolt/Physics/Ragdoll/Ragdoll.cpp

@@ -39,12 +39,12 @@ JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(RagdollSettings)
 	JPH_ADD_ATTRIBUTE(RagdollSettings, mAdditionalConstraints)
 }
 
-static inline BodyInterface &sGetBodyInterface(PhysicsSystem *inSystem, bool inLockBodies)
+static inline BodyInterface &sRagdollGetBodyInterface(PhysicsSystem *inSystem, bool inLockBodies)
 {
 	return inLockBodies? inSystem->GetBodyInterface() : inSystem->GetBodyInterfaceNoLock();
 }
 
-static inline const BodyLockInterface &sGetBodyLockInterface(const PhysicsSystem *inSystem, bool inLockBodies)
+static inline const BodyLockInterface &sRagdollGetBodyLockInterface(const PhysicsSystem *inSystem, bool inLockBodies)
 {
 	return inLockBodies? static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterface()) : static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterfaceNoLock());
 }
@@ -477,7 +477,7 @@ void Ragdoll::AddToPhysicsSystem(EActivation inActivationMode, bool inLockBodies
 		memcpy(bodies, mBodyIDs.data(), num_bodies * sizeof(BodyID));
 
 		// Insert bodies as a batch
-		BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+		BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 		BodyInterface::AddState add_state = bi.AddBodiesPrepare(bodies, num_bodies);
 		bi.AddBodiesFinalize(bodies, num_bodies, add_state, inActivationMode);
 	}
@@ -499,20 +499,20 @@ void Ragdoll::RemoveFromPhysicsSystem(bool inLockBodies)
 		memcpy(bodies, mBodyIDs.data(), num_bodies * sizeof(BodyID));
 
 		// Remove all bodies as a batch
-		sGetBodyInterface(mSystem, inLockBodies).RemoveBodies(bodies, num_bodies);
+		sRagdollGetBodyInterface(mSystem, inLockBodies).RemoveBodies(bodies, num_bodies);
 	}
 }
 
 void Ragdoll::Activate(bool inLockBodies)
 {
-	sGetBodyInterface(mSystem, inLockBodies).ActivateBodies(mBodyIDs.data(), (int)mBodyIDs.size());
+	sRagdollGetBodyInterface(mSystem, inLockBodies).ActivateBodies(mBodyIDs.data(), (int)mBodyIDs.size());
 }
 
 bool Ragdoll::IsActive(bool inLockBodies) const
 {
 	// Lock the bodies
 	int body_count = (int)mBodyIDs.size();
-	BodyLockMultiRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
+	BodyLockMultiRead lock(sRagdollGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
 
 	// Test if any body is active
 	for (int b = 0; b < body_count; ++b)
@@ -529,7 +529,7 @@ void Ragdoll::SetGroupID(CollisionGroup::GroupID inGroupID, bool inLockBodies)
 {
 	// Lock the bodies
 	int body_count = (int)mBodyIDs.size();
-	BodyLockMultiWrite lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
+	BodyLockMultiWrite lock(sRagdollGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
 
 	// Update group ID
 	for (int b = 0; b < body_count; ++b)
@@ -549,7 +549,7 @@ void Ragdoll::SetPose(const SkeletonPose &inPose, bool inLockBodies)
 void Ragdoll::SetPose(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, bool inLockBodies)
 {
 	// Move bodies instantly into the correct position
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (int i = 0; i < (int)mBodyIDs.size(); ++i)
 	{
 		const Mat44 &joint = inJointMatrices[i];
@@ -572,7 +572,7 @@ void Ragdoll::GetPose(RVec3 &outRootOffset, Mat44 *outJointMatrices, bool inLock
 	int body_count = (int)mBodyIDs.size();
 	if (body_count == 0)
 		return;
-	BodyLockMultiRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
+	BodyLockMultiRead lock(sRagdollGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
 
 	// Get root matrix
 	const Body *root = lock.GetBody(0);
@@ -605,7 +605,7 @@ void Ragdoll::DriveToPoseUsingKinematics(const SkeletonPose &inPose, float inDel
 void Ragdoll::DriveToPoseUsingKinematics(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, float inDeltaTime, bool inLockBodies)
 {
 	// Move bodies into the correct position using kinematics
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (int i = 0; i < (int)mBodyIDs.size(); ++i)
 	{
 		const Mat44 &joint = inJointMatrices[i];
@@ -650,35 +650,35 @@ void Ragdoll::DriveToPoseUsingMotors(const SkeletonPose &inPose)
 
 void Ragdoll::SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies)
 {
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (BodyID body_id : mBodyIDs)
 		bi.SetLinearAndAngularVelocity(body_id, inLinearVelocity, inAngularVelocity);
 }
 
 void Ragdoll::SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
 {
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (BodyID body_id : mBodyIDs)
 		bi.SetLinearVelocity(body_id, inLinearVelocity);
 }
 
 void Ragdoll::AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
 {
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (BodyID body_id : mBodyIDs)
 		bi.AddLinearVelocity(body_id, inLinearVelocity);
 }
 
 void Ragdoll::AddImpulse(Vec3Arg inImpulse, bool inLockBodies)
 {
-	BodyInterface &bi = sGetBodyInterface(mSystem, inLockBodies);
+	BodyInterface &bi = sRagdollGetBodyInterface(mSystem, inLockBodies);
 	for (BodyID body_id : mBodyIDs)
 		bi.AddImpulse(body_id, inImpulse);
 }
 
 void Ragdoll::GetRootTransform(RVec3 &outPosition, Quat &outRotation, bool inLockBodies) const
 {
-	BodyLockRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs[0]);
+	BodyLockRead lock(sRagdollGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs[0]);
 	if (lock.Succeeded())
 	{
 		const Body &body = lock.GetBody();
@@ -696,7 +696,7 @@ AABox Ragdoll::GetWorldSpaceBounds(bool inLockBodies) const
 {
 	// Lock the bodies
 	int body_count = (int)mBodyIDs.size();
-	BodyLockMultiRead lock(sGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
+	BodyLockMultiRead lock(sRagdollGetBodyLockInterface(mSystem, inLockBodies), mBodyIDs.data(), body_count);
 
 	// Encapsulate all bodies
 	AABox bounds;