游戏引擎和物理引擎区别_unity确定性物理引擎

2021SC@SDUSC

        前八次文章我们分析了flax Engine 游戏引擎中物理引擎的Actors（角色）包下的相关的源码的分析，从本次开始我们将针对flax Engine 游戏引擎中的物理引擎中的Joints（关节）这个包进行，源码的分析。在分析之前我们先要了解一下Joints（关节）这个包主要的功能是什么，了解这个以后可以对我们分析源码起到不小的帮助。

        在查阅相关资料后我们可以发现：Joints （关节）主要是针对两个物体间进行连接的物理量。

简而言之就是用来连接物体的关节。

在flax Engine 游戏引擎中定了5种不同的joints（关节）。

（1）Hinge Joint 铰链关节

        其作用是将两个刚体束缚在一起，在两者之间产生铰链效果

（2）Fixed Joint 固定关节

        固定关节组件用于约束一个游戏对象对另一个游戏对象的运动。
        固定关节适用于以下的情形：当希望将对象较容易与另—个对象分开时，或者连接两个没有父子关系的对象使其一起运动，使用固定关节的对象自身需要有—个刚体组件。

（3）Spring Joint 弹簧关节

        弹簧关节组件可将两个刚体连接在—起，使其像连接着弹簧那样运动。

  (4) Distance Joint 固定距离关节

        两个刚体之间固定距离。

   （5）D6 Joint :不知道具体用途在网上也找不到相关内容，在之后查看源码后，进行相关内容的解释。

本次分析就flaxengine 游戏引擎的物理系统的大致框架来进行分析。下次我将深入源代码进行物理引擎的分析。

在接下来的几次种，我将针对不同的Joints（关节）进行源码的分析。

一：HingeJoint（铰链关节）：

本次我们将针对flax Engine 游戏引擎物理引擎中的HingeJoint（铰链关节）进行源码的分析。

（1）HingeJoint.h 文件

按照管理我们首先分析HingeJoint.h文件。

API_ENUM(Attributes="Flags") enum class HingeJointFlag { /// <summary> /// The none. /// </summary> None = 0, /// <summary> /// The joint limit is enabled. /// </summary> Limit = 0x1, /// <summary> /// The joint drive is enabled. /// </summary> Drive = 0x2, }; 

首先是头文件的枚举类型的类：定义了limit：关节限制和drive：关节驱动

DECLARE_SCRIPTING_TYPE_MINIMAL(HingeJointDrive); /// <summary> /// Target velocity of the joint. /// </summary> API_FIELD(Attributes="Limit(0)") float Velocity = 0.0f; /// <summary> /// Maximum torque the drive is allowed to apply. /// </summary> API_FIELD(Attributes="Limit(0)") float ForceLimit = MAX_float; /// <summary> /// Scales the velocity of the first body, and its response to drive torque is scaled down. /// </summary> API_FIELD(Attributes="Limit(0)") float GearRatio = 1.0f; /// <summary> /// If the joint is moving faster than the drive's target speed, the drive will try to break. /// If you don't want the breaking to happen set this to true. /// </summary> API_FIELD() bool FreeSpin = false;

其次是铰链关节的构造函数：

定义了：

1：关节的目标速度

2：驱动器允许施加的最大扭矩

3：缩放第一个实体的速度，并缩小其对驱动扭矩的响应

4：如果关节的移动速度超过驱动器的目标速度，驱动器将尝试断开。如果你不想破坏发生，将其设置为真

public: /// <summary> /// Compares two objects. /// </summary> /// <param name="other">The other.</param> /// <returns>True if both objects are equal.</returns> bool operator==(const HingeJointDrive& other) const { return Velocity == other.Velocity && ForceLimit == other.ForceLimit && GearRatio == other.GearRatio && FreeSpin && other.FreeSpin; } };

public：比较两个对象。如果两个对象相等，则为True

DECLARE_SCENE_OBJECT(HingeJoint); private: HingeJointFlag _flags; LimitAngularRange _limit; HingeJointDrive _drive; public:

从其两个附着的实体（例如门铰链）移除除单个旋转自由度以外的所有旋转自由度的物理关节。

 API_PROPERTY(Attributes="EditorOrder(100), DefaultValue(HingeJointFlag.Limit | HingeJointFlag.Drive)") FORCE_INLINE HingeJointFlag GetFlags() const { return _flags; } 

获取关节模式标志。控制联合行为。

 API_PROPERTY() void SetFlags(const HingeJointFlag value);

设置关节模式标志。控制联合行为

 API_PROPERTY(Attributes="EditorOrder(110), EditorDisplay(\"Joint\")") FORCE_INLINE LimitAngularRange GetLimit() const { return _limit; }

确定关节的限制。“限制”将运动约束到指定的角度范围。必须在关节上启用限制标志才能识别该标记。

 API_PROPERTY() void SetDrive(const HingeJointDrive& value); public: /// <summary> /// Gets the current angle of the joint (in radians, in the range (-Pi, Pi]). /// </summary> API_PROPERTY() float GetCurrentAngle() const; /// <summary> /// Gets the current velocity of the joint. /// </summary> API_PROPERTY() float GetCurrentVelocity() const; public: // [Joint] void Serialize(SerializeStream& stream, const void* otherObj) override; void Deserialize(DeserializeStream& stream, ISerializeModifier* modifier) override; protected: // [Joint] PxJoint* CreateJoint(JointData& data) override; };

1：确定关节的驱动特性。它会将关节的角速度推向特定值。必须启用关节上的驱动标志，才能激活驱动。

2：获取关节的当前角度（以弧度为单位，范围为（-Pi，Pi]）。

3：获取关节的当前速度

（2）：HingeJoint.c 文件

HingeJoint::HingeJoint(const SpawnParams& params) : Joint(params) , _flags(HingeJointFlag::Limit | HingeJointFlag::Drive) { _limit.Lower = -90.0f; _limit.Upper = 90.0f; }

铰链的构造函数：设置limit 和 joint

void HingeJoint::SetFlags(const HingeJointFlag value) { if (_flags == value) return; _flags = value; if (_joint) { auto joint = static_cast<PxRevoluteJoint*>(_joint); joint->setRevoluteJointFlag(PxRevoluteJointFlag::eLIMIT_ENABLED, (_flags & HingeJointFlag::Limit) != 0); joint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_ENABLED, (_flags & HingeJointFlag::Drive) != 0); } }

设置Flags：

如果flags等于value 则返回，如果不是则将value赋值给flags。初始化joint。

void HingeJoint::SetLimit(const LimitAngularRange& value) { if (_limit == value) return; _limit = value; if (_joint) { auto joint = static_cast<PxRevoluteJoint*>(_joint); PxJointAngularLimitPair limit(value.Lower * DegreesToRadians, value.Upper * DegreesToRadians, value.ContactDist); limit.stiffness = value.Spring.Stiffness; limit.damping = value.Spring.Damping; limit.restitution = value.Restitution; joint->setLimit(limit); } }

设置Limit：

如果limit等于value 则返回，如果不是则将value赋值给limit。初始化joint。

void HingeJoint::SetDrive(const HingeJointDrive& value) { if (_drive == value) return; _drive = value; if (_joint) { auto joint = static_cast<PxRevoluteJoint*>(_joint); joint->setDriveVelocity(Math::Max(value.Velocity, 0.0f)); joint->setDriveForceLimit(Math::Max(value.ForceLimit, 0.0f)); joint->setDriveGearRatio(Math::Max(value.GearRatio, 0.0f)); joint->setRevoluteJointFlag(PxRevoluteJointFlag::eDRIVE_FREESPIN, value.FreeSpin); } }

设置Drive：

如果drive等于value 则返回，如果不是则将value赋值给drive。初始化joint。

void HingeJoint::Serialize(SerializeStream& stream, const void* otherObj) { // Base Joint::Serialize(stream, otherObj); SERIALIZE_GET_OTHER_OBJ(HingeJoint); SERIALIZE_MEMBER(Flags, _flags); SERIALIZE_MEMBER(ContactDist, _limit.ContactDist); SERIALIZE_MEMBER(Restitution, _limit.Restitution); SERIALIZE_MEMBER(Stiffness, _limit.Spring.Stiffness); SERIALIZE_MEMBER(Damping, _limit.Spring.Damping); SERIALIZE_MEMBER(LowerLimit, _limit.Lower); SERIALIZE_MEMBER(UpperLimit, _limit.Upper); SERIALIZE_MEMBER(Velocity, _drive.Velocity); SERIALIZE_MEMBER(ForceLimit, _drive.ForceLimit); SERIALIZE_MEMBER(GearRatio, _drive.GearRatio); SERIALIZE_MEMBER(FreeSpin, _drive.FreeSpin); }