birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

static rigid body and rigid body component use Handles instead of pointers (#662)

Browse Source
This commit is contained in:
amzn-sean
2021-05-13 11:59:22 +01:00
committed by GitHub
parent 112f0d3448
commit d690c3fee4
16 changed files with 358 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.cpp
+6 -2
View File
@@ -99,6 +99,11 @@ namespace AzPhysics
classElement.RemoveElementByName(AZ_CRC_CE("Property Visibility Flags"));
}
if (classElement.GetVersion() <= 4)
{
classElement.RemoveElementByName(AZ_CRC_CE("Simulated"));
}
return true;
}
}
@@ -110,7 +115,7 @@ namespace AzPhysics
if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
{
serializeContext->Class<RigidBodyConfiguration, AzPhysics::SimulatedBodyConfiguration>()
->Version(4, &Internal::RigidBodyVersionConverter)
->Version(5, &Internal::RigidBodyVersionConverter)
->Field("Initial linear velocity", &RigidBodyConfiguration::m_initialLinearVelocity)
->Field("Initial angular velocity", &RigidBodyConfiguration::m_initialAngularVelocity)
->Field("Linear damping", &RigidBodyConfiguration::m_linearDamping)
@@ -119,7 +124,6 @@ namespace AzPhysics
->Field("Start Asleep", &RigidBodyConfiguration::m_startAsleep)
->Field("Interpolate Motion", &RigidBodyConfiguration::m_interpolateMotion)
->Field("Gravity Enabled", &RigidBodyConfiguration::m_gravityEnabled)
->Field("Simulated", &RigidBodyConfiguration::m_simulated)
->Field("Kinematic", &RigidBodyConfiguration::m_kinematic)
->Field("CCD Enabled", &RigidBodyConfiguration::m_ccdEnabled)
->Field("Compute Mass", &RigidBodyConfiguration::m_computeMass)
Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.h
-1
View File
@@ -57,7 +57,6 @@ namespace AzPhysics
bool m_startAsleep = false;
bool m_interpolateMotion = false;
bool m_gravityEnabled = true;
bool m_simulated = true;
bool m_kinematic = false;
bool m_ccdEnabled = false; //!< Whether continuous collision detection is enabled.
float m_ccdMinAdvanceCoefficient = 0.15f; //!< Coefficient affecting how granularly time is subdivided in CCD.
Code/Framework/AzFramework/AzFramework/Physics/SimulatedBodies/RigidBody.h
+1 -1
View File
@@ -62,7 +62,7 @@ namespace AzPhysics
virtual void SetLinearVelocity(const AZ::Vector3& velocity) = 0;
virtual AZ::Vector3 GetAngularVelocity() const = 0;
virtual void SetAngularVelocity(const AZ::Vector3& angularVelocity) = 0;
virtual AZ::Vector3 GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) = 0;
virtual AZ::Vector3 GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) const = 0;
virtual void ApplyLinearImpulse(const AZ::Vector3& impulse) = 0;
virtual void ApplyLinearImpulseAtWorldPoint(const AZ::Vector3& impulse, const AZ::Vector3& worldPoint) = 0;
virtual void ApplyAngularImpulse(const AZ::Vector3& angularImpulse) = 0;
Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp
+1 -1
View File
@@ -241,7 +241,7 @@ namespace Blast
configuration.m_orientation = transform.GetRotation();
configuration.m_scale = transform.GetScale();
configuration.m_ccdEnabled = m_actorConfiguration.m_isCcdEnabled;
configuration.m_simulated = m_actorConfiguration.m_isSimulated;
configuration.m_startSimulationEnabled = m_actorConfiguration.m_isSimulated;
configuration.m_initialAngularVelocity = AZ::Vector3::CreateZero();
BlastActorDesc actorDesc;
Gems/Blast/Code/Tests/Mocks/BlastMocks.h
+1 -1
View File
@@ -424,7 +424,7 @@ namespace Blast
void SetAngularVelocity([[maybe_unused]] const AZ::Vector3& angularVelocity) override {}
AZ::Vector3 GetLinearVelocityAtWorldPoint([[maybe_unused]] const AZ::Vector3& worldPoint) override
AZ::Vector3 GetLinearVelocityAtWorldPoint([[maybe_unused]] const AZ::Vector3& worldPoint) const override
{
return {};
}
Gems/PhysX/Code/Source/EditorRigidBodyComponent.cpp
+62 -36
View File
@@ -282,9 +282,8 @@ namespace PhysX
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
sceneInterface->RemoveSimulatedBody(m_editorSceneHandle, m_rigidBodyHandle);
m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
m_editorBody = nullptr;
sceneInterface->RemoveSimulatedBody(m_editorSceneHandle, m_editorRigidBodyHandle);
m_editorRigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
}
}
@@ -342,12 +341,15 @@ namespace PhysX
[[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo,
AzFramework::DebugDisplayRequests& debugDisplay)
{
if (m_editorBody && m_config.m_centerOfMassDebugDraw)
if (m_config.m_centerOfMassDebugDraw)
{
debugDisplay.DepthTestOff();
debugDisplay.SetColor(m_centerOfMassDebugColor);
debugDisplay.DrawBall(m_editorBody->GetCenterOfMassWorld(), m_centerOfMassDebugSize);
debugDisplay.DepthTestOn();
if (const AzPhysics::RigidBody* body = GetRigidBody())
{
debugDisplay.DepthTestOff();
debugDisplay.SetColor(m_centerOfMassDebugColor);
debugDisplay.DrawBall(body->GetCenterOfMassWorld(), m_centerOfMassDebugSize);
debugDisplay.DepthTestOn();
}
}
}
@@ -366,29 +368,30 @@ namespace PhysX
AZ::Transform colliderTransform = GetWorldTM();
colliderTransform.ExtractScale();
AzPhysics::RigidBodyConfiguration configuration;
AzPhysics::RigidBodyConfiguration configuration = m_config;
configuration.m_orientation = colliderTransform.GetRotation();
configuration.m_position = colliderTransform.GetTranslation();
configuration.m_entityId = GetEntityId();
configuration.m_debugName = GetEntity()->GetName();
configuration.m_centerOfMassOffset = m_config.m_centerOfMassOffset;
configuration.m_computeCenterOfMass = m_config.m_computeCenterOfMass;
configuration.m_computeInertiaTensor = m_config.m_computeInertiaTensor;
configuration.m_inertiaTensor = m_config.m_inertiaTensor;
configuration.m_simulated = false;
configuration.m_kinematic = m_config.m_kinematic;
configuration.m_startSimulationEnabled = false;
configuration.m_colliderAndShapeData = Internal::GetCollisionShapes(GetEntity());
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
m_rigidBodyHandle = sceneInterface->AddSimulatedBody(m_editorSceneHandle, &configuration);
m_editorBody = azdynamic_cast<AzPhysics::RigidBody*>(sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_rigidBodyHandle));
m_editorRigidBodyHandle = sceneInterface->AddSimulatedBody(m_editorSceneHandle, &configuration);
if (auto* body = azdynamic_cast<AzPhysics::RigidBody*>(
sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle)
))
{
// AddSimulatedBody may update mass / CoM / Inertia tensor based on the config, so grab the updated values.
m_config.m_mass = body->GetMass();
m_config.m_centerOfMassOffset = body->GetCenterOfMassLocal();
m_config.m_inertiaTensor = body->GetInverseInertiaLocal();
}
}
m_editorBody->UpdateMassProperties(m_config.GetMassComputeFlags(), &m_config.m_centerOfMassOffset, &m_config.m_inertiaTensor, &m_config.m_mass);
m_config.m_mass = m_editorBody->GetMass();
m_config.m_centerOfMassOffset = m_editorBody->GetCenterOfMassLocal();
m_config.m_inertiaTensor = m_editorBody->GetInverseInertiaLocal();
AZ_Error("EditorRigidBodyComponent",
m_editorRigidBodyHandle != AzPhysics::InvalidSimulatedBodyHandle, "Failed to create editor rigid body");
}
void EditorRigidBodyComponent::OnColliderChanged()
@@ -424,9 +427,8 @@ namespace PhysX
{
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
sceneInterface->RemoveSimulatedBody(m_editorSceneHandle, m_rigidBodyHandle);
m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
m_editorBody = nullptr;
sceneInterface->RemoveSimulatedBody(m_editorSceneHandle, m_editorRigidBodyHandle);
m_editorRigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
CreateEditorWorldRigidBody();
}
@@ -436,46 +438,65 @@ namespace PhysX
void EditorRigidBodyComponent::EnablePhysics()
{
if (!IsPhysicsEnabled())
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
m_editorBody->SetSimulationEnabled(true);
sceneInterface->EnableSimulationOfBody(m_editorSceneHandle, m_editorRigidBodyHandle);
}
}
void EditorRigidBodyComponent::DisablePhysics()
{
m_editorBody->SetSimulationEnabled(false);
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
sceneInterface->DisableSimulationOfBody(m_editorSceneHandle, m_editorRigidBodyHandle);
}
}
bool EditorRigidBodyComponent::IsPhysicsEnabled() const
{
return m_editorBody && m_editorBody->m_simulating;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
if (AzPhysics::SimulatedBody* body =
sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle))
{
return body->m_simulating;
}
}
return false;
}
AZ::Aabb EditorRigidBodyComponent::GetAabb() const
{
if (m_editorBody)
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return m_editorBody->GetAabb();
if (AzPhysics::SimulatedBody* body =
sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle))
{
return body->GetAabb();
}
}
return AZ::Aabb::CreateNull();
}
AzPhysics::SimulatedBody* EditorRigidBodyComponent::GetSimulatedBody()
{
return m_editorBody;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle);
}
return nullptr;
}
AzPhysics::SimulatedBodyHandle EditorRigidBodyComponent::GetSimulatedBodyHandle() const
{
return m_rigidBodyHandle;
return m_editorRigidBodyHandle;
}
AzPhysics::SceneQueryHit EditorRigidBodyComponent::RayCast(const AzPhysics::RayCastRequest& request)
{
if (m_editorBody)
if (AzPhysics::SimulatedBody* body = GetSimulatedBody())
{
return m_editorBody->RayCast(request);
return body->RayCast(request);
}
return AzPhysics::SceneQueryHit();
}
@@ -488,7 +509,12 @@ namespace PhysX
const AzPhysics::RigidBody* EditorRigidBodyComponent::GetRigidBody() const
{
return m_editorBody;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return azdynamic_cast<AzPhysics::RigidBody*>(
sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle));
}
return nullptr;
}
void EditorRigidBodyComponent::SetShouldBeRecreated()
Gems/PhysX/Code/Source/EditorRigidBodyComponent.h
+3 -4
View File
@@ -33,8 +33,8 @@ namespace PhysX
struct EditorRigidBodyConfiguration
: public AzPhysics::RigidBodyConfiguration
{
AZ_CLASS_ALLOCATOR(EditorRigidBodyConfiguration, AZ::SystemAllocator, 0);
AZ_RTTI(EditorRigidBodyConfiguration, "{27297024-5A99-4C58-8614-4EF18137CE69}", AzPhysics::RigidBodyConfiguration);
AZ_CLASS_ALLOCATOR(PhysX::EditorRigidBodyConfiguration, AZ::SystemAllocator, 0);
AZ_RTTI(PhysX::EditorRigidBodyConfiguration, "{27297024-5A99-4C58-8614-4EF18137CE69}", AzPhysics::RigidBodyConfiguration);
static void Reflect(AZ::ReflectContext* context);
@@ -127,8 +127,7 @@ namespace PhysX
Debug::DebugDisplayDataChangedEvent::Handler m_debugDisplayDataChangeHandler;
EditorRigidBodyConfiguration m_config;
AzPhysics::SimulatedBodyHandle m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
AzPhysics::RigidBody* m_editorBody = nullptr;
AzPhysics::SimulatedBodyHandle m_editorRigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
AzPhysics::SceneHandle m_editorSceneHandle = AzPhysics::InvalidSceneHandle;
AZ::Color m_centerOfMassDebugColor = AZ::Colors::White;
Gems/PhysX/Code/Source/RigidBody.cpp
+2 -6
View File
@@ -82,12 +82,8 @@ namespace PhysX
SetName(configuration.m_debugName);
SetGravityEnabled(configuration.m_gravityEnabled);
SetSimulationEnabled(configuration.m_simulated);
SetCCDEnabled(configuration.m_ccdEnabled);
AzPhysics::MassComputeFlags flags = configuration.GetMassComputeFlags();
UpdateMassProperties(flags, &configuration.m_centerOfMassOffset, &configuration.m_inertiaTensor,
&configuration.m_mass);
SetKinematic(configuration.m_kinematic);
if (configuration.m_customUserData)
{
@@ -459,7 +455,7 @@ namespace PhysX
}
}
AZ::Vector3 RigidBody::GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint)
AZ::Vector3 RigidBody::GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) const
{
return m_pxRigidActor ?
GetLinearVelocity() + GetAngularVelocity().Cross(worldPoint - GetCenterOfMassWorld()) :
Gems/PhysX/Code/Source/RigidBody.h
+1 -1
View File
@@ -63,7 +63,7 @@ namespace PhysX
void SetLinearVelocity(const AZ::Vector3& velocity) override;
AZ::Vector3 GetAngularVelocity() const override;
void SetAngularVelocity(const AZ::Vector3& angularVelocity) override;
AZ::Vector3 GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) override;
AZ::Vector3 GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) const override;
void ApplyLinearImpulse(const AZ::Vector3& impulse) override;
void ApplyLinearImpulseAtWorldPoint(const AZ::Vector3& impulse, const AZ::Vector3& worldPoint) override;
void ApplyAngularImpulse(const AZ::Vector3& angularImpulse) override;
Gems/PhysX/Code/Source/RigidBodyComponent.cpp
+214 -64
View File
@@ -185,7 +185,6 @@ namespace PhysX
{
sceneInterface->RemoveSimulatedBody(m_attachedSceneHandle, m_rigidBodyHandle);
m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
m_rigidBody = nullptr;
}
Physics::RigidBodyRequestBus::Handler::BusDisconnect();
@@ -232,20 +231,33 @@ namespace PhysX
// User sets kinematic Target ---> Update transform
// User sets transform ---> Update kinematic target
if (!IsPhysicsEnabled() || (m_rigidBody->IsKinematic() && !m_isLastMovementFromKinematicSource))
if (!IsPhysicsEnabled() || (IsKinematic() && !m_isLastMovementFromKinematicSource))
{
return;
}
auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get();
if (sceneInterface == nullptr)
{
AZ_Error("RigidBodyComponent", false, "PostPhysicsTick, SceneInterface is null");
return;
}
AzPhysics::SimulatedBody* rigidBody =
sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle);
if (rigidBody == nullptr)
{
AZ_Error("RigidBodyComponent", false, "Unable to retrieve simulated rigid body");
return;
}
AZ::Transform transform = rigidBody->GetTransform();
if (m_configuration.m_interpolateMotion)
{
AZ::Transform transform = m_rigidBody->GetTransform();
m_interpolator->SetTarget(transform.GetTranslation(), m_rigidBody->GetOrientation(), fixedDeltaTime);
m_interpolator->SetTarget(transform.GetTranslation(), rigidBody->GetOrientation(), fixedDeltaTime);
}
else
{
AZ::Transform transform = m_rigidBody->GetTransform();
// Maintain scale (this must be precise).
AZ::Transform entityTransform = AZ::Transform::Identity();
AZ::TransformBus::EventResult(entityTransform, GetEntityId(), &AZ::TransformInterface::GetWorldTM);
@@ -261,13 +273,17 @@ namespace PhysX
// Note: OnTransformChanged is not safe at the moment due to TransformComponent design flaw.
// It is called when the parent entity is activated after the children causing rigid body
// to move through the level instantly.
if (IsPhysicsEnabled() && (m_rigidBody->IsKinematic() && !m_isLastMovementFromKinematicSource))
if (AzPhysics::RigidBody* body = GetRigidBody())
{
m_rigidBody->SetKinematicTarget(world);
}
else if (!IsPhysicsEnabled())
{
m_rigidBodyTransformNeedsUpdateOnPhysReEnable = true;
if (body->m_simulating &&
(body->IsKinematic() && !m_isLastMovementFromKinematicSource))
{
body->SetKinematicTarget(world);
}
else if (!body->m_simulating)
{
m_rigidBodyTransformNeedsUpdateOnPhysReEnable = true;
}
}
}
@@ -290,16 +306,9 @@ namespace PhysX
auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get();
if (sceneInterface != nullptr)
{
m_configuration.m_startSimulationEnabled = false; //enable physics will enable this when called.
m_rigidBodyHandle = sceneInterface->AddSimulatedBody(m_attachedSceneHandle, &m_configuration);
m_rigidBody = azdynamic_cast<AzPhysics::RigidBody*>(sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle));
//disable simulating the body until EnablePhysics is called.
sceneInterface->DisableSimulationOfBody(m_attachedSceneHandle, m_rigidBodyHandle);
}
m_rigidBody->SetKinematic(m_configuration.m_kinematic);
AzPhysics::MassComputeFlags flags = m_configuration.GetMassComputeFlags();
m_rigidBody->UpdateMassProperties(flags, &m_configuration.m_centerOfMassOffset, &m_configuration.m_inertiaTensor,
&m_configuration.m_mass);
// Listen to the PhysX system for events concerning this entity.
if (sceneInterface != nullptr)
@@ -319,16 +328,23 @@ namespace PhysX
return;
}
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get();
if (sceneInterface == nullptr)
{
sceneInterface->EnableSimulationOfBody(m_attachedSceneHandle, m_rigidBodyHandle);
AZ_Error("RigidBodyComponent", false, "Unable to enable physics, SceneInterface is null");
return;
}
SetSimulationEnabled(true);
AZ::Transform transform = AZ::Transform::CreateIdentity();
AZ::TransformBus::EventResult(transform, GetEntityId(), &AZ::TransformInterface::GetWorldTM);
if (m_rigidBodyTransformNeedsUpdateOnPhysReEnable)
{
m_rigidBody->SetTransform(transform);
if (AzPhysics::SimulatedBody* body =
sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle))
{
body->SetTransform(transform);
}
m_rigidBodyTransformNeedsUpdateOnPhysReEnable = false;
}
@@ -345,188 +361,322 @@ namespace PhysX
void RigidBodyComponent::DisablePhysics()
{
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
sceneInterface->DisableSimulationOfBody(m_attachedSceneHandle, m_rigidBodyHandle);
}
SetSimulationEnabled(false);
Physics::RigidBodyNotificationBus::Event(GetEntityId(), &Physics::RigidBodyNotificationBus::Events::OnPhysicsDisabled);
}
bool RigidBodyComponent::IsPhysicsEnabled() const
{
return m_rigidBody != nullptr && m_rigidBody->m_simulating;
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->m_simulating;
}
return false;
}
void RigidBodyComponent::ApplyLinearImpulse(const AZ::Vector3& impulse)
{
m_rigidBody->ApplyLinearImpulse(impulse);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->ApplyLinearImpulse(impulse);
}
}
void RigidBodyComponent::ApplyLinearImpulseAtWorldPoint(const AZ::Vector3& impulse, const AZ::Vector3& worldSpacePoint)
{
m_rigidBody->ApplyLinearImpulseAtWorldPoint(impulse, worldSpacePoint);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->ApplyLinearImpulseAtWorldPoint(impulse, worldSpacePoint);
}
}
void RigidBodyComponent::ApplyAngularImpulse(const AZ::Vector3& impulse)
{
m_rigidBody->ApplyAngularImpulse(impulse);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->ApplyAngularImpulse(impulse);
}
}
AZ::Vector3 RigidBodyComponent::GetLinearVelocity() const
{
return m_rigidBody->GetLinearVelocity();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetLinearVelocity();
}
return AZ::Vector3::CreateZero();
}
void RigidBodyComponent::SetLinearVelocity(const AZ::Vector3& velocity)
{
m_rigidBody->SetLinearVelocity(velocity);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetLinearVelocity(velocity);
}
}
AZ::Vector3 RigidBodyComponent::GetAngularVelocity() const
{
return m_rigidBody->GetAngularVelocity();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetAngularVelocity();
}
return AZ::Vector3::CreateZero();
}
void RigidBodyComponent::SetAngularVelocity(const AZ::Vector3& angularVelocity)
{
m_rigidBody->SetAngularVelocity(angularVelocity);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetAngularVelocity(angularVelocity);
}
}
AZ::Vector3 RigidBodyComponent::GetLinearVelocityAtWorldPoint(const AZ::Vector3& worldPoint) const
{
return m_rigidBody->GetLinearVelocityAtWorldPoint(worldPoint);
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetLinearVelocityAtWorldPoint(worldPoint);
}
return AZ::Vector3::CreateZero();
}
AZ::Vector3 RigidBodyComponent::GetCenterOfMassWorld() const
{
return m_rigidBody->GetCenterOfMassWorld();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetCenterOfMassWorld();
}
return AZ::Vector3::CreateZero();
}
AZ::Vector3 RigidBodyComponent::GetCenterOfMassLocal() const
{
return m_rigidBody->GetCenterOfMassLocal();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetCenterOfMassLocal();
}
return AZ::Vector3::CreateZero();
}
AZ::Matrix3x3 RigidBodyComponent::GetInverseInertiaWorld() const
{
return m_rigidBody->GetInverseInertiaWorld();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetInverseInertiaWorld();
}
return AZ::Matrix3x3::CreateZero();
}
AZ::Matrix3x3 RigidBodyComponent::GetInverseInertiaLocal() const
{
return m_rigidBody->GetInverseInertiaLocal();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetInverseInertiaLocal();
}
return AZ::Matrix3x3::CreateZero();
}
float RigidBodyComponent::GetMass() const
{
return m_rigidBody->GetMass();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetMass();
}
return 0.0f;
}
float RigidBodyComponent::GetInverseMass() const
{
return m_rigidBody->GetInverseMass();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetInverseMass();
}
return 0.0f;
}
void RigidBodyComponent::SetMass(float mass)
{
m_rigidBody->SetMass(mass);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetMass(mass);
}
}
void RigidBodyComponent::SetCenterOfMassOffset(const AZ::Vector3& comOffset)
{
m_rigidBody->SetCenterOfMassOffset(comOffset);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetCenterOfMassOffset(comOffset);
}
}
float RigidBodyComponent::GetLinearDamping() const
{
return m_rigidBody->GetLinearDamping();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetLinearDamping();
}
return 0.0f;
}
void RigidBodyComponent::SetLinearDamping(float damping)
{
m_rigidBody->SetLinearDamping(damping);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetLinearDamping(damping);
}
}
float RigidBodyComponent::GetAngularDamping() const
{
return m_rigidBody->GetAngularDamping();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetAngularDamping();
}
return 0.0f;
}
void RigidBodyComponent::SetAngularDamping(float damping)
{
m_rigidBody->SetAngularDamping(damping);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetAngularDamping(damping);
}
}
bool RigidBodyComponent::IsAwake() const
{
return m_rigidBody->IsAwake();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->IsAwake();
}
return false;
}
void RigidBodyComponent::ForceAsleep()
{
m_rigidBody->ForceAsleep();
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->ForceAsleep();
}
}
void RigidBodyComponent::ForceAwake()
{
m_rigidBody->ForceAwake();
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->ForceAwake();
}
}
bool RigidBodyComponent::IsKinematic() const
{
return m_rigidBody->IsKinematic();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->IsKinematic();
}
return false;
}
void RigidBodyComponent::SetKinematic(bool kinematic)
{
m_rigidBody->SetKinematic(kinematic);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetKinematic(kinematic);
}
}
void RigidBodyComponent::SetKinematicTarget(const AZ::Transform& targetPosition)
{
m_isLastMovementFromKinematicSource = true;
m_rigidBody->SetKinematicTarget(targetPosition);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetKinematicTarget(targetPosition);
}
}
bool RigidBodyComponent::IsGravityEnabled() const
{
return m_rigidBody->IsGravityEnabled();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->IsGravityEnabled();
}
return false;
}
void RigidBodyComponent::SetGravityEnabled(bool enabled)
{
m_rigidBody->SetGravityEnabled(enabled);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetGravityEnabled(enabled);
}
}
void RigidBodyComponent::SetSimulationEnabled(bool enabled)
{
m_rigidBody->SetSimulationEnabled(enabled);
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
if (enabled)
{
sceneInterface->EnableSimulationOfBody(m_attachedSceneHandle, m_rigidBodyHandle);
}
else
{
sceneInterface->DisableSimulationOfBody(m_attachedSceneHandle, m_rigidBodyHandle);
}
}
}
float RigidBodyComponent::GetSleepThreshold() const
{
return m_rigidBody->GetSleepThreshold();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetSleepThreshold();
}
return 0.0f;
}
void RigidBodyComponent::SetSleepThreshold(float threshold)
{
m_rigidBody->SetSleepThreshold(threshold);
if (AzPhysics::RigidBody* body = GetRigidBody())
{
body->SetSleepThreshold(threshold);
}
}
AZ::Aabb RigidBodyComponent::GetAabb() const
{
return m_rigidBody->GetAabb();
if (const AzPhysics::RigidBody* body = GetRigidBodyConst())
{
return body->GetAabb();
}
return AZ::Aabb::CreateNull();
}
AzPhysics::RigidBody* RigidBodyComponent::GetRigidBody()
{
return m_rigidBody;
return azdynamic_cast<AzPhysics::RigidBody*>(GetSimulatedBody());
}
AzPhysics::SimulatedBody* RigidBodyComponent::GetSimulatedBody()
{
return m_rigidBody;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle);
}
return nullptr;
}
const AzPhysics::RigidBody* RigidBodyComponent::GetRigidBodyConst() const
{
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return azdynamic_cast<AzPhysics::RigidBody*>(
sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle));
}
return nullptr;
}
AzPhysics::SimulatedBodyHandle RigidBodyComponent::GetSimulatedBodyHandle() const
@@ -536,9 +686,9 @@ namespace PhysX
AzPhysics::SceneQueryHit RigidBodyComponent::RayCast(const AzPhysics::RayCastRequest& request)
{
if (m_rigidBody)
if (AzPhysics::RigidBody* body = GetRigidBody())
{
return m_rigidBody->RayCast(request);
return body->RayCast(request);
}
return AzPhysics::SceneQueryHit();
}
Gems/PhysX/Code/Source/RigidBodyComponent.h
+2 -1
View File
@@ -153,11 +153,12 @@ namespace PhysX
void InitPhysicsTickHandler();
void PostPhysicsTick(float fixedDeltaTime);
const AzPhysics::RigidBody* GetRigidBodyConst() const;
std::unique_ptr<TransformForwardTimeInterpolator> m_interpolator;
AzPhysics::RigidBodyConfiguration m_configuration;
AzPhysics::SimulatedBodyHandle m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
AzPhysics::RigidBody* m_rigidBody = nullptr;
AzPhysics::SceneHandle m_attachedSceneHandle = AzPhysics::InvalidSceneHandle;
AZ::Vector3 m_initialScale = AZ::Vector3::CreateOne();
Gems/PhysX/Code/Source/Scene/PhysXScene.cpp
+17 -1
View File
@@ -189,6 +189,22 @@ namespace PhysX
return newBody;
}
AzPhysics::SimulatedBody* CreateRigidBody(const AzPhysics::RigidBodyConfiguration* configuration, AZ::Crc32& crc)
{
RigidBody* newBody = aznew RigidBody(*configuration);
if (!AZStd::holds_alternative<AZStd::monostate>(configuration->m_colliderAndShapeData))
{
const bool shapeAdded = AddShape(newBody, configuration->m_colliderAndShapeData);
AZ_Warning("PhysXScene", shapeAdded, "No Collider or Shape information found when creating Rigid body [%s]", configuration->m_debugName.c_str());
}
const AzPhysics::MassComputeFlags& flags = configuration->GetMassComputeFlags();
newBody->UpdateMassProperties(flags, &configuration->m_centerOfMassOffset,
&configuration->m_inertiaTensor, &configuration->m_mass);
crc = AZ::Crc32(newBody, sizeof(*newBody));
return newBody;
}
AzPhysics::SimulatedBody* CreateCharacterBody(PhysXScene* scene,
const Physics::CharacterConfiguration* characterConfig)
{
@@ -617,7 +633,7 @@ namespace PhysX
AZ::Crc32 newBodyCrc;
if (azrtti_istypeof<AzPhysics::RigidBodyConfiguration>(simulatedBodyConfig))
{
newBody = Internal::CreateSimulatedBody<RigidBody, AzPhysics::RigidBodyConfiguration>(
newBody = Internal::CreateRigidBody(
azdynamic_cast<const AzPhysics::RigidBodyConfiguration*>(simulatedBodyConfig), newBodyCrc);
}
else if (azrtti_istypeof<AzPhysics::StaticRigidBodyConfiguration>(simulatedBodyConfig))
Gems/PhysX/Code/Source/StaticRigidBodyComponent.cpp
+33 -9
View File
@@ -100,7 +100,6 @@ namespace PhysX
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
m_staticRigidBodyHandle = sceneInterface->AddSimulatedBody(m_attachedSceneHandle, &configuration);
m_staticRigidBody = azdynamic_cast<PhysX::StaticRigidBody*>(sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_staticRigidBodyHandle));
}
}
@@ -119,16 +118,18 @@ namespace PhysX
{
sceneInterface->RemoveSimulatedBody(m_attachedSceneHandle, m_staticRigidBodyHandle);
m_staticRigidBodyHandle = AzPhysics::InvalidSceneHandle;
m_staticRigidBody = nullptr;
}
AzPhysics::SimulatedBodyComponentRequestsBus::Handler::BusDisconnect();
AZ::TransformNotificationBus::Handler::BusDisconnect();
}
void StaticRigidBodyComponent::OnTransformChanged(const AZ::Transform& /*local*/, const AZ::Transform& world)
void StaticRigidBodyComponent::OnTransformChanged([[maybe_unused]] const AZ::Transform& local, const AZ::Transform& world)
{
m_staticRigidBody->SetTransform(world);
if (AzPhysics::SimulatedBody* body = GetSimulatedBody())
{
body->SetTransform(world);
}
}
void StaticRigidBodyComponent::EnablePhysics()
@@ -153,12 +154,31 @@ namespace PhysX
bool StaticRigidBodyComponent::IsPhysicsEnabled() const
{
return m_staticRigidBody != nullptr && m_staticRigidBody->m_simulating;
if (m_staticRigidBodyHandle != AzPhysics::InvalidSimulatedBodyHandle)
{
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get();
sceneInterface != nullptr &&
sceneInterface->IsEnabled(m_attachedSceneHandle))//check if the scene is enabled
{
if (AzPhysics::SimulatedBody* body = sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_staticRigidBodyHandle))
{
return body->m_simulating;
}
}
}
return false;
}
AZ::Aabb StaticRigidBodyComponent::GetAabb() const
{
return m_staticRigidBody->GetAabb();
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
if (AzPhysics::SimulatedBody* body = sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_staticRigidBodyHandle))
{
return body->GetAabb();
}
}
return AZ::Aabb::CreateNull();
}
AzPhysics::SimulatedBodyHandle StaticRigidBodyComponent::GetSimulatedBodyHandle() const
@@ -168,14 +188,18 @@ namespace PhysX
AzPhysics::SimulatedBody* StaticRigidBodyComponent::GetSimulatedBody()
{
return m_staticRigidBody;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
return sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_staticRigidBodyHandle);
}
return nullptr;
}
AzPhysics::SceneQueryHit StaticRigidBodyComponent::RayCast(const AzPhysics::RayCastRequest& request)
{
if (m_staticRigidBody)
if (auto* body = azdynamic_cast<PhysX::StaticRigidBody*>(GetSimulatedBody()))
{
return m_staticRigidBody->RayCast(request);
return body->RayCast(request);
}
return AzPhysics::SceneQueryHit();
}
Gems/PhysX/Code/Source/StaticRigidBodyComponent.h
-1
View File
@@ -65,7 +65,6 @@ namespace PhysX
void OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world) override;
AzPhysics::SimulatedBodyHandle m_staticRigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle;
PhysX::StaticRigidBody* m_staticRigidBody = nullptr;
AzPhysics::SceneHandle m_attachedSceneHandle = AzPhysics::InvalidSceneHandle;
};
} // namespace PhysX
Gems/PhysX/Code/Source/System/PhysXSystem.cpp
+3
View File
@@ -140,6 +140,9 @@ namespace PhysX
}
};
AZ_Warning("PhysXSystem", deltaTime <= m_systemConfig.m_maxTimestep,
"Frame delta time of [%.6f seconds] exceeds Physics max frame timestep, physics timestep will be clamped to [%.6f seconds].",
deltaTime, m_systemConfig.m_maxTimestep);
deltaTime = AZ::GetClamp(deltaTime, 0.0f, m_systemConfig.m_maxTimestep);
AZ_Assert(m_systemConfig.m_fixedTimestep >= 0.0f, "PhysXSystem - fixed timestep is negitive.");
Gems/PhysX/Code/Tests/PhysXTestCommon.cpp
+12
View File
@@ -415,6 +415,10 @@ namespace PhysX
Physics::SphereShapeConfiguration shapeConfiguration;
shapeConfiguration.m_radius = radius;
AzPhysics::RigidBodyConfiguration rigidBodySettings;
rigidBodySettings.m_computeMass = false;
rigidBodySettings.m_computeInertiaTensor = false;
rigidBodySettings.m_computeCenterOfMass = false;
rigidBodySettings.m_mass = 1.0f;
rigidBodySettings.m_position = position;
rigidBodySettings.m_linearDamping = 0.0f;
rigidBodySettings.m_colliderAndShapeData = AZStd::make_pair(&colliderConfig, &shapeConfiguration);
@@ -437,6 +441,10 @@ namespace PhysX
Physics::CapsuleShapeConfiguration shapeConfig(height, radius);
rigidBodySettings.m_colliderAndShapeData = AZStd::make_pair(&colliderConfig, &shapeConfig);
rigidBodySettings.m_position = position;
rigidBodySettings.m_computeMass = false;
rigidBodySettings.m_computeInertiaTensor = false;
rigidBodySettings.m_computeCenterOfMass = false;
rigidBodySettings.m_mass = 1.0f;
if (auto* sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get())
{
@@ -455,6 +463,10 @@ namespace PhysX
shapeConfiguration.m_dimensions = dimensions;
AzPhysics::RigidBodyConfiguration rigidBodySettings;
rigidBodySettings.m_computeMass = false;
rigidBodySettings.m_computeInertiaTensor = false;
rigidBodySettings.m_computeCenterOfMass = false;
rigidBodySettings.m_mass = 1.0f;
rigidBodySettings.m_position = position;
rigidBodySettings.m_linearDamping = 0.0f;
rigidBodySettings.m_colliderAndShapeData = AZStd::make_pair(&colliderConfig, &shapeConfiguration);