From fb06fa2c8b9d248285b975038626c69215392224 Mon Sep 17 00:00:00 2001 From: Wojtek Figat Date: Mon, 27 Feb 2023 23:01:10 +0100 Subject: [PATCH] Add optional build without PhysX --- .../Engine/Physics/Actors/WheeledVehicle.cpp | 3 + .../Physics/PhysX/PhysicsBackendPhysX.cpp | 5 + Source/Engine/Physics/Physics.Build.cs | 14 +- Source/Engine/Physics/PhysicsBackendEmpty.cpp | 855 ++++++++++++++++++ Source/Engine/Terrain/Terrain.Build.cs | 1 - 5 files changed, 876 insertions(+), 2 deletions(-) create mode 100644 Source/Engine/Physics/PhysicsBackendEmpty.cpp diff --git a/Source/Engine/Physics/Actors/WheeledVehicle.cpp b/Source/Engine/Physics/Actors/WheeledVehicle.cpp index cc28ef756..bcf94ee05 100644 --- a/Source/Engine/Physics/Actors/WheeledVehicle.cpp +++ b/Source/Engine/Physics/Actors/WheeledVehicle.cpp @@ -10,6 +10,9 @@ #include "Engine/Level/Scene/SceneRendering.h" #include "Engine/Debug/DebugDraw.h" #endif +#if !WITH_VEHICLE +#include "Engine/Core/Log.h" +#endif WheeledVehicle::WheeledVehicle(const SpawnParams& params) : RigidBody(params) diff --git a/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp b/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp index 097ca4853..3863d2c13 100644 --- a/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp +++ b/Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp @@ -2120,6 +2120,11 @@ void PhysicsBackend::GetJointForce(void* joint, Vector3& linear, Vector3& angula linear = P2C(linearPhysX); angular = P2C(angularPhysX); } + else + { + linear = Vector3::Zero; + angular = Vector3::Zero; + } } void* PhysicsBackend::CreateFixedJoint(const PhysicsJointDesc& desc) diff --git a/Source/Engine/Physics/Physics.Build.cs b/Source/Engine/Physics/Physics.Build.cs index 55a972dde..d31e0d271 100644 --- a/Source/Engine/Physics/Physics.Build.cs +++ b/Source/Engine/Physics/Physics.Build.cs @@ -14,6 +14,11 @@ public class Physics : EngineModule /// public static bool WithCooking = true; + /// + /// Enables using PhysX library. Can be overriden by SetupPhysicsBackend. + /// + public static bool WithPhysX = true; + /// /// Physics system extension event to override for custom physics backend plugin. /// @@ -34,6 +39,13 @@ public class Physics : EngineModule private static void SetupPhysicsBackendPhysX(Physics physics, BuildOptions options) { - options.PrivateDependencies.Add("PhysX"); + if (WithPhysX) + { + options.PrivateDependencies.Add("PhysX"); + } + else + { + options.PrivateDefinitions.Add("COMPILE_WITH_EMPTY_PHYSICS"); + } } } diff --git a/Source/Engine/Physics/PhysicsBackendEmpty.cpp b/Source/Engine/Physics/PhysicsBackendEmpty.cpp new file mode 100644 index 000000000..49861f0df --- /dev/null +++ b/Source/Engine/Physics/PhysicsBackendEmpty.cpp @@ -0,0 +1,855 @@ +// Copyright (c) 2012-2023 Wojciech Figat. All rights reserved. + +#if COMPILE_WITH_EMPTY_PHYSICS + +#include "Engine/Core/Log.h" +#include "Engine/Physics/CollisionData.h" +#include "Engine/Physics/PhysicalMaterial.h" +#include "Engine/Physics/PhysicsScene.h" +#include "Engine/Physics/CollisionCooking.h" +#include "Engine/Physics/Actors/IPhysicsActor.h" +#include "Engine/Physics/Joints/Limits.h" +#include "Engine/Physics/Joints/DistanceJoint.h" +#include "Engine/Physics/Joints/HingeJoint.h" +#include "Engine/Physics/Joints/SliderJoint.h" +#include "Engine/Physics/Joints/SphericalJoint.h" +#include "Engine/Physics/Joints/D6Joint.h" +#include "Engine/Physics/Colliders/Collider.h" + +#define DUMY_HANDLE ((void*)1) + +void* PhysicalMaterial::GetPhysicsMaterial() +{ + return DUMY_HANDLE; +} + +void PhysicalMaterial::UpdatePhysicsMaterial() +{ +} + +#if COMPILE_WITH_PHYSICS_COOKING + +bool CollisionCooking::CookConvexMesh(CookingInput& input, BytesContainer& output) +{ + LOG(Error, "No physics."); + return true; +} + +bool CollisionCooking::CookTriangleMesh(CookingInput& input, BytesContainer& output) +{ + LOG(Error, "No physics."); + return true; +} + +bool CollisionCooking::CookHeightField(int32 cols, int32 rows, const PhysicsBackend::HeightFieldSample* data, WriteStream& stream) +{ + LOG(Error, "No physics."); + return true; +} + +#endif + +bool PhysicsBackend::Init() +{ + LOG(Info, "No physics."); + return false; +} + +void PhysicsBackend::Shutdown() +{ +} + +void PhysicsBackend::ApplySettings(const PhysicsSettings& settings) +{ +} + +void* PhysicsBackend::CreateScene(const PhysicsSettings& settings) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::DestroyScene(void* scene) +{ +} + +void PhysicsBackend::StartSimulateScene(void* scene, float dt) +{ +} + +void PhysicsBackend::EndSimulateScene(void* scene) +{ +} + +Vector3 PhysicsBackend::GetSceneGravity(void* scene) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetSceneGravity(void* scene, const Vector3& value) +{ +} + +bool PhysicsBackend::GetSceneEnableCCD(void* scene) +{ + return false; +} + +void PhysicsBackend::SetSceneEnableCCD(void* scene, bool value) +{ +} + +float PhysicsBackend::GetSceneBounceThresholdVelocity(void* scene) +{ + return 0.0f; +} + +void PhysicsBackend::SetSceneBounceThresholdVelocity(void* scene, float value) +{ +} + +void PhysicsBackend::SetSceneOrigin(void* scene, const Vector3& oldOrigin, const Vector3& newOrigin) +{ +} + +void PhysicsBackend::AddSceneActor(void* scene, void* actor) +{ +} + +void PhysicsBackend::RemoveSceneActor(void* scene, void* actor) +{ +} + +void PhysicsBackend::AddSceneActorAction(void* scene, void* actor, ActionType action) +{ +} + +bool PhysicsBackend::RayCast(void* scene, const Vector3& origin, const Vector3& direction, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::RayCast(void* scene, const Vector3& origin, const Vector3& direction, RayCastHit& hitInfo, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::RayCastAll(void* scene, const Vector3& origin, const Vector3& direction, Array& results, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::BoxCast(void* scene, const Vector3& center, const Vector3& halfExtents, const Vector3& direction, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::BoxCast(void* scene, const Vector3& center, const Vector3& halfExtents, const Vector3& direction, RayCastHit& hitInfo, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::BoxCastAll(void* scene, const Vector3& center, const Vector3& halfExtents, const Vector3& direction, Array& results, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::SphereCast(void* scene, const Vector3& center, const float radius, const Vector3& direction, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::SphereCast(void* scene, const Vector3& center, const float radius, const Vector3& direction, RayCastHit& hitInfo, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::SphereCastAll(void* scene, const Vector3& center, const float radius, const Vector3& direction, Array& results, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CapsuleCast(void* scene, const Vector3& center, const float radius, const float height, const Vector3& direction, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CapsuleCast(void* scene, const Vector3& center, const float radius, const float height, const Vector3& direction, RayCastHit& hitInfo, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CapsuleCastAll(void* scene, const Vector3& center, const float radius, const float height, const Vector3& direction, Array& results, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::ConvexCast(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, const Vector3& direction, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::ConvexCast(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, const Vector3& direction, RayCastHit& hitInfo, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::ConvexCastAll(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, const Vector3& direction, Array& results, const Quaternion& rotation, const float maxDistance, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CheckBox(void* scene, const Vector3& center, const Vector3& halfExtents, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CheckSphere(void* scene, const Vector3& center, const float radius, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CheckCapsule(void* scene, const Vector3& center, const float radius, const float height, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::CheckConvex(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapBox(void* scene, const Vector3& center, const Vector3& halfExtents, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapSphere(void* scene, const Vector3& center, const float radius, Array& results, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapCapsule(void* scene, const Vector3& center, const float radius, const float height, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapConvex(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapBox(void* scene, const Vector3& center, const Vector3& halfExtents, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapSphere(void* scene, const Vector3& center, const float radius, Array& results, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapCapsule(void* scene, const Vector3& center, const float radius, const float height, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +bool PhysicsBackend::OverlapConvex(void* scene, const Vector3& center, const CollisionData* convexMesh, const Vector3& scale, Array& results, const Quaternion& rotation, uint32 layerMask, bool hitTriggers) +{ + return false; +} + +PhysicsBackend::ActorFlags PhysicsBackend::GetActorFlags(void* actor) +{ + return ActorFlags::None; +} + +void PhysicsBackend::SetActorFlags(void* actor, ActorFlags value) +{ +} + +void PhysicsBackend::GetActorBounds(void* actor, BoundingBox& bounds) +{ + bounds = BoundingBox::Empty; +} + +int32 PhysicsBackend::GetRigidActorShapesCount(void* actor) +{ + return 0; +} + +void* PhysicsBackend::CreateRigidDynamicActor(IPhysicsActor* actor, const Vector3& position, const Quaternion& orientation, void* scene) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateRigidStaticActor(IPhysicsActor* actor, const Vector3& position, const Quaternion& orientation, void* scene) +{ + return DUMY_HANDLE; +} + +PhysicsBackend::RigidDynamicFlags PhysicsBackend::GetRigidDynamicActorFlags(void* actor) +{ + return RigidDynamicFlags::None; +} + +void PhysicsBackend::SetRigidDynamicActorFlags(void* actor, RigidDynamicFlags value) +{ +} + +void PhysicsBackend::GetRigidActorPose(void* actor, Vector3& position, Quaternion& orientation) +{ + position = Vector3::Zero; + orientation = Quaternion::Identity; +} + +void PhysicsBackend::SetRigidActorPose(void* actor, const Vector3& position, const Quaternion& orientation, bool kinematic, bool wakeUp) +{ +} + +void PhysicsBackend::SetRigidDynamicActorLinearDamping(void* actor, float value) +{ +} + +void PhysicsBackend::SetRigidDynamicActorAngularDamping(void* actor, float value) +{ +} + +void PhysicsBackend::SetRigidDynamicActorMaxAngularVelocity(void* actor, float value) +{ +} + +void PhysicsBackend::SetRigidDynamicActorConstraints(void* actor, RigidbodyConstraints value) +{ +} + +Vector3 PhysicsBackend::GetRigidDynamicActorLinearVelocity(void* actor) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetRigidDynamicActorLinearVelocity(void* actor, const Vector3& value, bool wakeUp) +{ +} + +Vector3 PhysicsBackend::GetRigidDynamicActorAngularVelocity(void* actor) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetRigidDynamicActorAngularVelocity(void* actor, const Vector3& value, bool wakeUp) +{ +} + +Vector3 PhysicsBackend::GetRigidDynamicActorCenterOfMass(void* actor) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetRigidDynamicActorCenterOfMassOffset(void* actor, const Float3& value) +{ +} + +bool PhysicsBackend::GetRigidDynamicActorIsSleeping(void* actor) +{ + return false; +} + +void PhysicsBackend::RigidDynamicActorSleep(void* actor) +{ +} + +void PhysicsBackend::RigidDynamicActorWakeUp(void* actor) +{ +} + +float PhysicsBackend::GetRigidDynamicActorSleepThreshold(void* actor) +{ + return 0.0f; +} + +void PhysicsBackend::SetRigidDynamicActorSleepThreshold(void* actor, float value) +{ +} + +float PhysicsBackend::GetRigidDynamicActorMaxDepenetrationVelocity(void* actor) +{ + return 0.0f; +} + +void PhysicsBackend::SetRigidDynamicActorMaxDepenetrationVelocity(void* actor, float value) +{ +} + +void PhysicsBackend::SetRigidDynamicActorSolverIterationCounts(void* actor, int32 minPositionIters, int32 minVelocityIters) +{ +} + +void PhysicsBackend::UpdateRigidDynamicActorMass(void* actor, float& mass, float massScale, bool autoCalculate) +{ +} + +void PhysicsBackend::AddRigidDynamicActorForce(void* actor, const Vector3& force, ForceMode mode) +{ +} + +void PhysicsBackend::AddRigidDynamicActorForceAtPosition(void* actor, const Vector3& force, const Vector3& position, ForceMode mode) +{ +} + +void PhysicsBackend::AddRigidDynamicActorTorque(void* actor, const Vector3& torque, ForceMode mode) +{ +} + +void* PhysicsBackend::CreateShape(PhysicsColliderActor* collider, const CollisionShape& geometry, JsonAsset* material, bool enabled, bool trigger) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::SetShapeState(void* shape, bool enabled, bool trigger) +{ +} + +void PhysicsBackend::SetShapeFilterMask(void* shape, uint32 mask0, uint32 mask1) +{ +} + +void* PhysicsBackend::GetShapeActor(void* shape) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::GetShapePose(void* shape, Vector3& position, Quaternion& orientation) +{ +} + +CollisionShape::Types PhysicsBackend::GetShapeType(void* shape) +{ + return CollisionShape::Types::Box; +} + +void PhysicsBackend::GetShapeLocalPose(void* shape, Vector3& position, Quaternion& orientation) +{ +} + +void PhysicsBackend::SetShapeLocalPose(void* shape, const Vector3& position, const Quaternion& orientation) +{ +} + +void PhysicsBackend::SetShapeContactOffset(void* shape, float value) +{ +} + +void PhysicsBackend::SetShapeMaterial(void* shape, JsonAsset* material) +{ +} + +void PhysicsBackend::SetShapeGeometry(void* shape, const CollisionShape& geometry) +{ +} + +void PhysicsBackend::AttachShape(void* shape, void* actor) +{ +} + +void PhysicsBackend::DetachShape(void* shape, void* actor) +{ +} + +bool PhysicsBackend::ComputeShapesPenetration(void* shapeA, void* shapeB, const Vector3& positionA, const Quaternion& orientationA, const Vector3& positionB, const Quaternion& orientationB, Vector3& direction, float& distance) +{ + direction = Vector3::Forward; + return false; +} + +float PhysicsBackend::ComputeShapeSqrDistanceToPoint(void* shape, const Vector3& position, const Quaternion& orientation, const Vector3& point, Vector3* closestPoint) +{ + return 0.0f; +} + +bool PhysicsBackend::RayCastShape(void* shape, const Vector3& position, const Quaternion& orientation, const Vector3& origin, const Vector3& direction, float& resultHitDistance, float maxDistance) +{ + return false; +} + +bool PhysicsBackend::RayCastShape(void* shape, const Vector3& position, const Quaternion& orientation, const Vector3& origin, const Vector3& direction, RayCastHit& hitInfo, float maxDistance) +{ + return false; +} + +void PhysicsBackend::SetJointFlags(void* joint, JointFlags value) +{ +} + +void PhysicsBackend::SetJointActors(void* joint, void* actors0, void* actor1) +{ +} + +void PhysicsBackend::SetJointActorPose(void* joint, const Vector3& position, const Quaternion& orientation, uint8 index) +{ +} + +void PhysicsBackend::SetJointBreakForce(void* joint, float force, float torque) +{ +} + +void PhysicsBackend::GetJointForce(void* joint, Vector3& linear, Vector3& angular) +{ + linear = Vector3::Zero; + angular = Vector3::Zero; +} + +void* PhysicsBackend::CreateFixedJoint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateDistanceJoint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateHingeJoint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateSliderJoint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateSphericalJoint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateD6Joint(const PhysicsJointDesc& desc) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::SetDistanceJointFlags(void* joint, DistanceJointFlag flags) +{ +} + +void PhysicsBackend::SetDistanceJointMinDistance(void* joint, float value) +{ +} + +void PhysicsBackend::SetDistanceJointMaxDistance(void* joint, float value) +{ +} + +void PhysicsBackend::SetDistanceJointTolerance(void* joint, float value) +{ +} + +void PhysicsBackend::SetDistanceJointSpring(void* joint, const SpringParameters& value) +{ +} + +float PhysicsBackend::GetDistanceJointDistance(void* joint) +{ + return 0.0f; +} + +void PhysicsBackend::SetHingeJointFlags(void* joint, HingeJointFlag value, bool driveFreeSpin) +{ +} + +void PhysicsBackend::SetHingeJointLimit(void* joint, const LimitAngularRange& value) +{ +} + +void PhysicsBackend::SetHingeJointDrive(void* joint, const HingeJointDrive& value) +{ +} + +float PhysicsBackend::GetHingeJointAngle(void* joint) +{ + return 0.0f; +} + +float PhysicsBackend::GetHingeJointVelocity(void* joint) +{ + return 0.0f; +} + +void PhysicsBackend::SetSliderJointFlags(void* joint, SliderJointFlag value) +{ +} + +void PhysicsBackend::SetSliderJointLimit(void* joint, const LimitLinearRange& value) +{ +} + +float PhysicsBackend::GetSliderJointPosition(void* joint) +{ + return 0.0f; +} + +float PhysicsBackend::GetSliderJointVelocity(void* joint) +{ + return 0.0f; +} + +void PhysicsBackend::SetSphericalJointFlags(void* joint, SphericalJointFlag value) +{ +} + +void PhysicsBackend::SetSphericalJointLimit(void* joint, const LimitConeRange& value) +{ +} + +void PhysicsBackend::SetD6JointMotion(void* joint, D6JointAxis axis, D6JointMotion value) +{ +} + +void PhysicsBackend::SetD6JointDrive(void* joint, const D6JointDriveType index, const D6JointDrive& value) +{ +} + +void PhysicsBackend::SetD6JointLimitLinear(void* joint, const LimitLinear& value) +{ +} + +void PhysicsBackend::SetD6JointLimitTwist(void* joint, const LimitAngularRange& value) +{ +} + +void PhysicsBackend::SetD6JointLimitSwing(void* joint, const LimitConeRange& value) +{ +} + +Vector3 PhysicsBackend::GetD6JointDrivePosition(void* joint) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetD6JointDrivePosition(void* joint, const Vector3& value) +{ +} + +Quaternion PhysicsBackend::GetD6JointDriveRotation(void* joint) +{ + return Quaternion::Identity; +} + +void PhysicsBackend::SetD6JointDriveRotation(void* joint, const Quaternion& value) +{ +} + +void PhysicsBackend::GetD6JointDriveVelocity(void* joint, Vector3& linear, Vector3& angular) +{ + linear = Vector3::Zero; + angular = Vector3::Zero; +} + +void PhysicsBackend::SetD6JointDriveVelocity(void* joint, const Vector3& linear, const Vector3& angular) +{ +} + +float PhysicsBackend::GetD6JointTwist(void* joint) +{ + return 0.0f; +} + +float PhysicsBackend::GetD6JointSwingY(void* joint) +{ + return 0.0f; +} + +float PhysicsBackend::GetD6JointSwingZ(void* joint) +{ + return 0.0f; +} + +void* PhysicsBackend::CreateController(void* scene, IPhysicsActor* actor, PhysicsColliderActor* collider, float contactOffset, const Vector3& position, float slopeLimit, int32 nonWalkableMode, JsonAsset* material, float radius, float height, float stepOffset, void*& shape) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::GetControllerRigidDynamicActor(void* controller) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::SetControllerSize(void* controller, float radius, float height) +{ +} + +void PhysicsBackend::SetControllerSlopeLimit(void* controller, float value) +{ +} + +void PhysicsBackend::SetControllerNonWalkableMode(void* controller, int32 value) +{ +} + +void PhysicsBackend::SetControllerStepOffset(void* controller, float value) +{ +} + +Vector3 PhysicsBackend::GetControllerUpDirection(void* controller) +{ + return Vector3::Up; +} + +void PhysicsBackend::SetControllerUpDirection(void* controller, const Vector3& value) +{ +} + +Vector3 PhysicsBackend::GetControllerPosition(void* controller) +{ + return Vector3::Zero; +} + +void PhysicsBackend::SetControllerPosition(void* controller, const Vector3& value) +{ +} + +int32 PhysicsBackend::MoveController(void* controller, void* shape, const Vector3& displacement, float minMoveDistance, float deltaTime) +{ + return 0; +} + +#if WITH_VEHICLE + +void* PhysicsBackend::CreateVehicle(WheeledVehicle* actor) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::DestroyVehicle(void* vehicle, int32 driveType) +{ +} + +void PhysicsBackend::SetVehicleGearbox(void* vehicle, const void* value) +{ +} + +int32 PhysicsBackend::GetVehicleTargetGear(void* vehicle) +{ + return 0; +} + +void PhysicsBackend::SetVehicleTargetGear(void* vehicle, int32 value) +{ +} + +int32 PhysicsBackend::GetVehicleCurrentGear(void* vehicle) +{ + return 0; +} + +void PhysicsBackend::SetVehicleCurrentGear(void* vehicle, int32 value) +{ +} + +float PhysicsBackend::GetVehicleForwardSpeed(void* vehicle) +{ + return 0.0f; +} + +float PhysicsBackend::GetVehicleSidewaysSpeed(void* vehicle) +{ + return 0.0f; +} + +float PhysicsBackend::GetVehicleEngineRotationSpeed(void* vehicle) +{ + return 0.0f; +} + +void PhysicsBackend::AddVehicle(void* scene, WheeledVehicle* actor) +{ +} + +void PhysicsBackend::RemoveVehicle(void* scene, WheeledVehicle* actor) +{ +} + +#endif + +void* PhysicsBackend::CreateConvexMesh(byte* data, int32 dataSize, BoundingBox& localBounds) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateTriangleMesh(byte* data, int32 dataSize, BoundingBox& localBounds) +{ + return DUMY_HANDLE; +} + +void* PhysicsBackend::CreateHeightField(byte* data, int32 dataSize) +{ + return DUMY_HANDLE; +} + +void PhysicsBackend::GetConvexMeshTriangles(void* contextMesh, Array& vertexBuffer, Array& indexBuffer) +{ +} + +void PhysicsBackend::GetTriangleMeshTriangles(void* triangleMesh, Array& vertexBuffer, Array& indexBuffer) +{ +} + +const uint32* PhysicsBackend::GetTriangleMeshRemap(void* triangleMesh, uint32& count) +{ + count = 0; + return nullptr; +} + +void PhysicsBackend::GetHeightFieldSize(void* heightField, int32& rows, int32& columns) +{ + rows = 0; + columns = 0; +} + +float PhysicsBackend::GetHeightFieldHeight(void* heightField, float x, float z) +{ + return 0.0f; +} + +bool PhysicsBackend::ModifyHeightField(void* heightField, int32 startCol, int32 startRow, int32 cols, int32 rows, const HeightFieldSample* data) +{ + return true; +} + +void PhysicsBackend::FlushRequests() +{ +} + +void PhysicsBackend::FlushRequests(void* scene) +{ +} + +void PhysicsBackend::DestroyActor(void* actor) +{ +} + +void PhysicsBackend::DestroyShape(void* shape) +{ +} + +void PhysicsBackend::DestroyJoint(void* joint) +{ +} + +void PhysicsBackend::DestroyController(void* controller) +{ +} + +void PhysicsBackend::DestroyObject(void* object) +{ +} + +void PhysicsBackend::RemoveCollider(PhysicsColliderActor* collider) +{ +} + +void PhysicsBackend::RemoveJoint(Joint* joint) +{ +} + +#endif diff --git a/Source/Engine/Terrain/Terrain.Build.cs b/Source/Engine/Terrain/Terrain.Build.cs index 16cf6d2ab..1cc36a237 100644 --- a/Source/Engine/Terrain/Terrain.Build.cs +++ b/Source/Engine/Terrain/Terrain.Build.cs @@ -14,7 +14,6 @@ public class Terrain : EngineModule base.Setup(options); options.PrivateDependencies.Add("Physics"); - options.PrivateDependencies.Add("PhysX"); if (options.Target.IsEditor) {