seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #106346 from mihe/jolt/scu-support

Browse Source 
Fix SCU build issues related to Jolt Physics
This commit is contained in:
Thaddeus Crews
2025-05-13 16:22:26 -05:00
parent 2053f8d6bf 9cea7ebc91
commit f70420a8b1
10 changed files with 185 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
thirdparty/jolt_physics/Jolt/Physics/Character/Character.cpp vendored
View File

@ -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

32
thirdparty/jolt_physics/Jolt/Physics/Ragdoll/Ragdoll.cpp vendored
View File

@ -38,12 +38,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());
}
@ -476,7 +476,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);
}
@ -498,20 +498,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)
@ -528,7 +528,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)
@ -548,7 +548,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];
@ -571,7 +571,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);
@ -604,7 +604,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];
@ -643,35 +643,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();
@ -689,7 +689,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;