diff --git a/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.cpp b/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.cpp index 80434e5dee..0d5d5ca841 100644 --- a/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.cpp +++ b/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.cpp @@ -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(context)) { serializeContext->Class() - ->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) diff --git a/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.h b/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.h index 5c43118f3d..ecf7e023c5 100644 --- a/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.h +++ b/Code/Framework/AzFramework/AzFramework/Physics/Configuration/RigidBodyConfiguration.h @@ -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. diff --git a/Code/Framework/AzFramework/AzFramework/Physics/SimulatedBodies/RigidBody.h b/Code/Framework/AzFramework/AzFramework/Physics/SimulatedBodies/RigidBody.h index 5b18887d43..0f43aaaf4a 100644 --- a/Code/Framework/AzFramework/AzFramework/Physics/SimulatedBodies/RigidBody.h +++ b/Code/Framework/AzFramework/AzFramework/Physics/SimulatedBodies/RigidBody.h @@ -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; diff --git a/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp b/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp index d276486548..87865d0e08 100644 --- a/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp +++ b/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp @@ -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; diff --git a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h index a1e57a6917..1ae87e2282 100644 --- a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h +++ b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h @@ -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 {}; } diff --git a/Gems/PhysX/Code/Source/EditorRigidBodyComponent.cpp b/Gems/PhysX/Code/Source/EditorRigidBodyComponent.cpp index b6517b0499..f97e7c6cbd 100644 --- a/Gems/PhysX/Code/Source/EditorRigidBodyComponent.cpp +++ b/Gems/PhysX/Code/Source/EditorRigidBodyComponent.cpp @@ -282,9 +282,8 @@ namespace PhysX if (auto* sceneInterface = AZ::Interface::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::Get()) { - m_rigidBodyHandle = sceneInterface->AddSimulatedBody(m_editorSceneHandle, &configuration); - m_editorBody = azdynamic_cast(sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_rigidBodyHandle)); + m_editorRigidBodyHandle = sceneInterface->AddSimulatedBody(m_editorSceneHandle, &configuration); + if (auto* body = azdynamic_cast( + 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::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::Get()) { - m_editorBody->SetSimulationEnabled(true); + sceneInterface->EnableSimulationOfBody(m_editorSceneHandle, m_editorRigidBodyHandle); } } void EditorRigidBodyComponent::DisablePhysics() { - m_editorBody->SetSimulationEnabled(false); + if (auto* sceneInterface = AZ::Interface::Get()) + { + sceneInterface->DisableSimulationOfBody(m_editorSceneHandle, m_editorRigidBodyHandle); + } } bool EditorRigidBodyComponent::IsPhysicsEnabled() const { - return m_editorBody && m_editorBody->m_simulating; + if (auto* sceneInterface = AZ::Interface::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::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::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::Get()) + { + return azdynamic_cast( + sceneInterface->GetSimulatedBodyFromHandle(m_editorSceneHandle, m_editorRigidBodyHandle)); + } + return nullptr; } void EditorRigidBodyComponent::SetShouldBeRecreated() diff --git a/Gems/PhysX/Code/Source/EditorRigidBodyComponent.h b/Gems/PhysX/Code/Source/EditorRigidBodyComponent.h index b2b199e6be..72d34bb0d0 100644 --- a/Gems/PhysX/Code/Source/EditorRigidBodyComponent.h +++ b/Gems/PhysX/Code/Source/EditorRigidBodyComponent.h @@ -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; diff --git a/Gems/PhysX/Code/Source/RigidBody.cpp b/Gems/PhysX/Code/Source/RigidBody.cpp index 6d1ece6a82..7fda0a1912 100644 --- a/Gems/PhysX/Code/Source/RigidBody.cpp +++ b/Gems/PhysX/Code/Source/RigidBody.cpp @@ -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()) : diff --git a/Gems/PhysX/Code/Source/RigidBody.h b/Gems/PhysX/Code/Source/RigidBody.h index c9f171b261..07df60d649 100644 --- a/Gems/PhysX/Code/Source/RigidBody.h +++ b/Gems/PhysX/Code/Source/RigidBody.h @@ -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; diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp index cf2e306cc7..58b0749d0f 100644 --- a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp +++ b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp @@ -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::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::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(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::Get()) + auto* sceneInterface = AZ::Interface::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::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::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(GetSimulatedBody()); } AzPhysics::SimulatedBody* RigidBodyComponent::GetSimulatedBody() { - return m_rigidBody; + if (auto* sceneInterface = AZ::Interface::Get()) + { + return sceneInterface->GetSimulatedBodyFromHandle(m_attachedSceneHandle, m_rigidBodyHandle); + } + return nullptr; + } + + const AzPhysics::RigidBody* RigidBodyComponent::GetRigidBodyConst() const + { + if (auto* sceneInterface = AZ::Interface::Get()) + { + return azdynamic_cast( + 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(); } diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.h b/Gems/PhysX/Code/Source/RigidBodyComponent.h index 12c4d3f5ff..7b2a34cf37 100644 --- a/Gems/PhysX/Code/Source/RigidBodyComponent.h +++ b/Gems/PhysX/Code/Source/RigidBodyComponent.h @@ -153,11 +153,12 @@ namespace PhysX void InitPhysicsTickHandler(); void PostPhysicsTick(float fixedDeltaTime); + const AzPhysics::RigidBody* GetRigidBodyConst() const; + std::unique_ptr 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(); diff --git a/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp b/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp index 03bbac9fd4..96e2d8a9bb 100644 --- a/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp +++ b/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp @@ -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(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(simulatedBodyConfig)) { - newBody = Internal::CreateSimulatedBody( + newBody = Internal::CreateRigidBody( azdynamic_cast(simulatedBodyConfig), newBodyCrc); } else if (azrtti_istypeof(simulatedBodyConfig)) diff --git a/Gems/PhysX/Code/Source/StaticRigidBodyComponent.cpp b/Gems/PhysX/Code/Source/StaticRigidBodyComponent.cpp index 79e5ea8204..881fb29750 100644 --- a/Gems/PhysX/Code/Source/StaticRigidBodyComponent.cpp +++ b/Gems/PhysX/Code/Source/StaticRigidBodyComponent.cpp @@ -100,7 +100,6 @@ namespace PhysX if (auto* sceneInterface = AZ::Interface::Get()) { m_staticRigidBodyHandle = sceneInterface->AddSimulatedBody(m_attachedSceneHandle, &configuration); - m_staticRigidBody = azdynamic_cast(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::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::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::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(GetSimulatedBody())) { - return m_staticRigidBody->RayCast(request); + return body->RayCast(request); } return AzPhysics::SceneQueryHit(); } diff --git a/Gems/PhysX/Code/Source/StaticRigidBodyComponent.h b/Gems/PhysX/Code/Source/StaticRigidBodyComponent.h index 660521ab7a..0f5bf1a4b2 100644 --- a/Gems/PhysX/Code/Source/StaticRigidBodyComponent.h +++ b/Gems/PhysX/Code/Source/StaticRigidBodyComponent.h @@ -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 diff --git a/Gems/PhysX/Code/Source/System/PhysXSystem.cpp b/Gems/PhysX/Code/Source/System/PhysXSystem.cpp index 1d925570c5..1622d04aae 100644 --- a/Gems/PhysX/Code/Source/System/PhysXSystem.cpp +++ b/Gems/PhysX/Code/Source/System/PhysXSystem.cpp @@ -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."); diff --git a/Gems/PhysX/Code/Tests/PhysXTestCommon.cpp b/Gems/PhysX/Code/Tests/PhysXTestCommon.cpp index 2404a60e0d..93ad7704c9 100644 --- a/Gems/PhysX/Code/Tests/PhysXTestCommon.cpp +++ b/Gems/PhysX/Code/Tests/PhysXTestCommon.cpp @@ -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::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);