1179 lines
33 KiB
C++
1179 lines
33 KiB
C++
// Copyright (c) 2018-2019 Kiwano - Nomango
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
// of this software and associated documentation files (the "Software"), to deal
|
||
// in the Software without restriction, including without limitation the rights
|
||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
// copies of the Software, and to permit persons to whom the Software is
|
||
// furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in
|
||
// all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
// THE SOFTWARE.
|
||
|
||
#pragma once
|
||
#include <kiwano-physics/Body.h>
|
||
#include <kiwano-physics/helper.h>
|
||
|
||
namespace kiwano
|
||
{
|
||
namespace physics
|
||
{
|
||
KGE_DECLARE_SMART_PTR(Joint);
|
||
KGE_DECLARE_SMART_PTR(DistanceJoint);
|
||
KGE_DECLARE_SMART_PTR(FrictionJoint);
|
||
KGE_DECLARE_SMART_PTR(GearJoint);
|
||
KGE_DECLARE_SMART_PTR(MotorJoint);
|
||
KGE_DECLARE_SMART_PTR(MouseJoint);
|
||
KGE_DECLARE_SMART_PTR(PrismaticJoint);
|
||
KGE_DECLARE_SMART_PTR(PulleyJoint);
|
||
KGE_DECLARE_SMART_PTR(RevoluteJoint);
|
||
KGE_DECLARE_SMART_PTR(RopeJoint);
|
||
KGE_DECLARE_SMART_PTR(WeldJoint);
|
||
KGE_DECLARE_SMART_PTR(WheelJoint);
|
||
|
||
/**
|
||
* \addtogroup Physics
|
||
* @{
|
||
*/
|
||
|
||
/// \~chinese
|
||
/// @brief 关节
|
||
class KGE_API Joint : public virtual ObjectBase
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 关节类型
|
||
enum class Type
|
||
{
|
||
Unknown = 0, ///< 未知
|
||
Revolute, ///< 旋转关节
|
||
Prismatic, ///< 平移关节
|
||
Distance, ///< 固定距离关节
|
||
Pulley, ///< 滑轮关节
|
||
Mouse, ///< 鼠标关节
|
||
Gear, ///< 齿轮关节
|
||
Wheel, ///< 轮关节
|
||
Weld, ///< 焊接关节
|
||
Friction, ///< 摩擦关节
|
||
Rope, ///< 绳关节
|
||
Motor ///< 马达关节
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 关节基础参数
|
||
struct ParamBase
|
||
{
|
||
Body* body_a; ///< 关节连接的物体A
|
||
Body* body_b; ///< 关节连接的物体B
|
||
|
||
ParamBase(Body* body_a, Body* body_b)
|
||
: body_a(body_a)
|
||
, body_b(body_b)
|
||
{
|
||
}
|
||
|
||
ParamBase(BodyPtr body_a, BodyPtr body_b)
|
||
: body_a(body_a.get())
|
||
, body_b(body_b.get())
|
||
{
|
||
}
|
||
};
|
||
|
||
Joint();
|
||
|
||
virtual ~Joint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, b2JointDef* joint_def);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节连接的物体A
|
||
BodyPtr GetBodyA() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节连接的物体B
|
||
BodyPtr GetBodyB() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物理世界
|
||
World* GetWorld() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 销毁关节
|
||
void Destroy();
|
||
|
||
b2Joint* GetB2Joint() const;
|
||
void SetB2Joint(b2Joint* joint);
|
||
|
||
private:
|
||
b2Joint* joint_;
|
||
World* world_;
|
||
Type type_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 固定距离关节
|
||
class KGE_API DistanceJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 固定距离关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor_a; ///< 关节在物体A上的连接点
|
||
Point anchor_b; ///< 关节在物体B上的连接点
|
||
float frequency_hz; ///< 响应速度，数值越高关节响应的速度越快，看上去越坚固
|
||
float damping_ratio; ///< 阻尼率，值越大关节运动阻尼越大
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor_a, Point const& anchor_b, float frequency_hz = 0.f,
|
||
float damping_ratio = 0.f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor_a(anchor_a)
|
||
, anchor_b(anchor_b)
|
||
, frequency_hz(frequency_hz)
|
||
, damping_ratio(damping_ratio)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor_a, Point const& anchor_b, float frequency_hz = 0.f,
|
||
float damping_ratio = 0.f)
|
||
: Param(body_a.get(), body_b.get(), anchor_a, anchor_b, frequency_hz, damping_ratio)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建固定距离关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static DistanceJointPtr Create(World* world, Param const& param);
|
||
|
||
DistanceJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置关节长度
|
||
void SetLength(float length);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节长度
|
||
float GetLength() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置弹簧响应速度 [赫兹]
|
||
void SetFrequency(float hz);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取弹簧响应速度 [赫兹]
|
||
float GetFrequency() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置阻尼率
|
||
void SetDampingRatio(float ratio);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取阻尼率
|
||
float GetDampingRatio() const;
|
||
|
||
private:
|
||
b2DistanceJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 摩擦关节
|
||
class KGE_API FrictionJoint : public Joint
|
||
{
|
||
public:
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor; ///< 摩擦作用点
|
||
float max_force; ///< 最大摩擦力
|
||
float max_torque; ///< 最大扭力
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor, float max_force = 0.f, float max_torque = 0.f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor(anchor)
|
||
, max_force(max_force)
|
||
, max_torque(max_torque)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor, float max_force = 0.f, float max_torque = 0.f)
|
||
: Param(body_a.get(), body_b.get(), anchor, max_force, max_torque)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建摩擦关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static FrictionJointPtr Create(World* world, Param const& param);
|
||
|
||
FrictionJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大摩擦力
|
||
void SetMaxForce(float force);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大摩擦力
|
||
float GetMaxForce() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大转矩
|
||
void SetMaxTorque(float torque);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大转矩
|
||
float GetMaxTorque() const;
|
||
|
||
private:
|
||
b2FrictionJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 齿轮关节
|
||
class KGE_API GearJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 齿轮关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Joint* joint_a; ///< 关节A（旋转关节/平移关节）
|
||
Joint* joint_b; ///< 关节B（旋转关节/平移关节）
|
||
float ratio; ///< 齿轮传动比
|
||
|
||
Param(Joint* joint_a, Joint* joint_b, float ratio = 1.f)
|
||
: ParamBase(nullptr, nullptr)
|
||
, joint_a(joint_a)
|
||
, joint_b(joint_b)
|
||
, ratio(ratio)
|
||
{
|
||
}
|
||
|
||
Param(JointPtr joint_a, JointPtr joint_b, float ratio = 1.f)
|
||
: Param(joint_a.get(), joint_b.get(), ratio)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建齿轮关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static GearJointPtr Create(World* world, Param const& param);
|
||
|
||
GearJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设定齿轮传动比
|
||
void SetRatio(float ratio);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取齿轮传动比
|
||
float GetRatio() const;
|
||
|
||
private:
|
||
b2GearJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 马达关节
|
||
class KGE_API MotorJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 马达关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
float max_force; ///< 最大摩擦力
|
||
float max_torque; ///< 最大转矩
|
||
float correction_factor; ///< 位置矫正因子（范围 0-1）
|
||
|
||
Param(Body* body_a, Body* body_b, float max_force = 1.f, float max_torque = 100.f,
|
||
float correction_factor = 0.3f)
|
||
: ParamBase(body_a, body_b)
|
||
, max_force(max_force)
|
||
, max_torque(max_torque)
|
||
, correction_factor(correction_factor)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, float max_force = 0.f, float max_torque = 0.f,
|
||
float correction_factor = 0.3f)
|
||
: Param(body_a.get(), body_b.get(), max_force, max_torque, correction_factor)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建马达关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static MotorJointPtr Create(World* world, Param const& param);
|
||
|
||
MotorJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大摩擦力
|
||
void SetMaxForce(float force);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大摩擦力
|
||
float GetMaxForce() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大转矩
|
||
void SetMaxTorque(float torque);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大转矩
|
||
float GetMaxTorque() const;
|
||
|
||
private:
|
||
b2MotorJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 平移关节
|
||
class KGE_API PrismaticJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 平移关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor; ///< 关节位置
|
||
Vec2 axis; ///< 物体A滑动的方向
|
||
bool enable_limit; ///< 是否启用限制
|
||
float lower_translation; ///< 移动的最小限制，与方向同向为正，反向为负，启用限制后才有效果
|
||
float upper_translation; ///< 移动的最大限制，与方向同向为正，反向为负，启用限制后才有效果
|
||
bool enable_motor; ///< 是否启用马达
|
||
float max_motor_force; ///< 最大马达力 [N]
|
||
float motor_speed; ///< 马达转速 [degree/s]
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor, Vec2 const& axis, bool enable_limit = false,
|
||
float lower_translation = 0.0f, float upper_translation = 0.0f, bool enable_motor = false,
|
||
float max_motor_force = 0.0f, float motor_speed = 0.0f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor(anchor)
|
||
, axis(axis)
|
||
, enable_limit(enable_limit)
|
||
, lower_translation(lower_translation)
|
||
, upper_translation(upper_translation)
|
||
, enable_motor(enable_motor)
|
||
, max_motor_force(max_motor_force)
|
||
, motor_speed(motor_speed)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor, Vec2 const& axis, bool enable_limit = false,
|
||
float lower_translation = 0.0f, float upper_translation = 0.0f, bool enable_motor = false,
|
||
float max_motor_force = 0.0f, float motor_speed = 0.0f)
|
||
: Param(body_a.get(), body_b.get(), anchor, axis, enable_limit, lower_translation, upper_translation,
|
||
enable_motor, max_motor_force, motor_speed)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建平移关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static PrismaticJointPtr Create(World* world, Param const& param);
|
||
|
||
PrismaticJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取参考角
|
||
float GetReferenceAngle() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节转换
|
||
float GetJointTranslation() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节速度
|
||
float GetJointSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 是否启用关节限制
|
||
bool IsLimitEnabled() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置是否启用关节限制
|
||
void EnableLimit(bool flag);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取平移最小限制
|
||
float GetLowerLimit() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取平移最大限制
|
||
float GetUpperLimit() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置关节限制
|
||
void SetLimits(float lower, float upper);
|
||
|
||
/// \~chinese
|
||
/// @brief 是否启用马达
|
||
bool IsMotorEnabled() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置是否启用马达
|
||
void EnableMotor(bool flag);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置马达转速 [degree/s]
|
||
void SetMotorSpeed(float speed);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取马达转速 [degree/s]
|
||
float GetMotorSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大马达力 [N]
|
||
void SetMaxMotorForce(float force);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大马达力 [N]
|
||
float GetMaxMotorForce() const;
|
||
|
||
private:
|
||
b2PrismaticJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 滑轮关节
|
||
class KGE_API PulleyJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 滑轮关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor_a; ///< 关节在物体A上的作用点
|
||
Point anchor_b; ///< 关节在物体B上的作用点
|
||
Point ground_anchor_a; ///< 物体A对应的滑轮的位置
|
||
Point ground_anchor_b; ///< 物体B对应的滑轮的位置
|
||
float ratio; ///< 滑轮比，关节传动时，滑轮上升和下降的两头的位移比例
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor_a, Point const& anchor_b, Point const& ground_anchor_a,
|
||
Point const& ground_anchor_b, float ratio = 1.0f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor_a(anchor_a)
|
||
, anchor_b(anchor_b)
|
||
, ground_anchor_a(ground_anchor_a)
|
||
, ground_anchor_b(ground_anchor_b)
|
||
, ratio(ratio)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor_a, Point const& anchor_b,
|
||
Point const& ground_anchor_a, Point const& ground_anchor_b, float ratio = 1.0f)
|
||
: Param(body_a.get(), body_b.get(), anchor_a, anchor_b, ground_anchor_a, ground_anchor_b, ratio)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建滑轮关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static PulleyJointPtr Create(World* world, Param const& param);
|
||
|
||
PulleyJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 物体A对应的滑轮的位置
|
||
Point GetGroundAnchorA() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 物体B对应的滑轮的位置
|
||
Point GetGroundAnchorB() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取滑轮传动比
|
||
float GetRatio() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物体A与滑轮的距离
|
||
float GetLengthA() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物体B与滑轮的距离
|
||
float GetLengthB() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物体A与滑轮的当前距离
|
||
float GetCurrentLengthA() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物体B与滑轮的当前距离
|
||
float GetCurrentLengthB() const;
|
||
|
||
private:
|
||
b2PulleyJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 旋转关节
|
||
class KGE_API RevoluteJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 旋转关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor; ///< 关节位置
|
||
bool enable_limit; ///< 是否启用限制
|
||
float lower_angle; ///< 移动的最小限制，与方向同向为正，反向为负，启用限制后才有效果
|
||
float upper_angle; ///< 移动的最大限制，与方向同向为正，反向为负，启用限制后才有效果
|
||
bool enable_motor; ///< 是否启用马达
|
||
float max_motor_torque; ///< 最大马达力 [N]
|
||
float motor_speed; ///< 马达转速 [degree/s]
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor, bool enable_limit = false, float lower_angle = 0.0f,
|
||
float upper_angle = 0.0f, bool enable_motor = false, float max_motor_torque = 0.0f,
|
||
float motor_speed = 0.0f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor(anchor)
|
||
, enable_limit(enable_limit)
|
||
, lower_angle(lower_angle)
|
||
, upper_angle(upper_angle)
|
||
, enable_motor(enable_motor)
|
||
, max_motor_torque(max_motor_torque)
|
||
, motor_speed(motor_speed)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor, bool enable_limit = false, float lower_angle = 0.0f,
|
||
float upper_angle = 0.0f, bool enable_motor = false, float max_motor_torque = 0.0f,
|
||
float motor_speed = 0.0f)
|
||
: Param(body_a.get(), body_b.get(), anchor, enable_limit, lower_angle, upper_angle, enable_motor,
|
||
max_motor_torque, motor_speed)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建旋转关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static RevoluteJointPtr Create(World* world, Param const& param);
|
||
|
||
RevoluteJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取参考角
|
||
float GetReferenceAngle() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节角度
|
||
float GetJointAngle() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节速度
|
||
float GetJointSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 是否启用关节限制
|
||
bool IsLimitEnabled() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置是否启用关节限制
|
||
void EnableLimit(bool flag);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取平移最小限制
|
||
float GetLowerLimit() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取平移最大限制
|
||
float GetUpperLimit() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置关节限制
|
||
void SetLimits(float lower, float upper);
|
||
|
||
/// \~chinese
|
||
/// @brief 是否启用马达
|
||
bool IsMotorEnabled() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置是否启用马达
|
||
void EnableMotor(bool flag);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置马达转速 [degree/s]
|
||
void SetMotorSpeed(float speed);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取马达转速 [degree/s]
|
||
float GetMotorSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大马达转矩 [N/m]
|
||
void SetMaxMotorTorque(float torque);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大马达转矩 [N/m]
|
||
float GetMaxMotorTorque() const;
|
||
|
||
private:
|
||
b2RevoluteJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 绳关节
|
||
class KGE_API RopeJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 绳关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point local_anchor_a; ///< 关节在物体A上的连接点
|
||
Point local_anchor_b; ///< 关节在物体B上的连接点
|
||
float max_length; ///< 绳索最大长度
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& local_anchor_a, Point const& local_anchor_b,
|
||
float max_length = 0.f)
|
||
: ParamBase(body_a, body_b)
|
||
, local_anchor_a(local_anchor_a)
|
||
, local_anchor_b(local_anchor_b)
|
||
, max_length(max_length)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& local_anchor_a, Point const& local_anchor_b,
|
||
float max_length = 0.f)
|
||
: Param(body_a.get(), body_b.get(), local_anchor_a, local_anchor_b, max_length)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建绳关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static RopeJointPtr Create(World* world, Param const& param);
|
||
|
||
RopeJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置关节最大长度
|
||
void SetMaxLength(float length);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节最大长度
|
||
float GetMaxLength() const;
|
||
|
||
private:
|
||
b2RopeJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 焊接关节
|
||
class KGE_API WeldJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 焊接关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor; ///< 焊接位置
|
||
float frequency_hz; ///< 响应速度，数值越高关节响应的速度越快，看上去越坚固
|
||
float damping_ratio; ///< 阻尼率，值越大关节运动阻尼越大
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor, float frequency_hz = 0.f, float damping_ratio = 0.f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor(anchor)
|
||
, frequency_hz(frequency_hz)
|
||
, damping_ratio(damping_ratio)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor, float frequency_hz = 0.f, float damping_ratio = 0.f)
|
||
: Param(body_a.get(), body_b.get(), anchor, frequency_hz, damping_ratio)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建焊接关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static WeldJointPtr Create(World* world, Param const& param);
|
||
|
||
WeldJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取物体B相对于物体A的角度
|
||
float GetReferenceAngle() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置弹簧响应速度 [赫兹]
|
||
void SetFrequency(float hz);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取弹簧响应速度 [赫兹]
|
||
float GetFrequency() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置阻尼率
|
||
void SetDampingRatio(float ratio);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取阻尼率
|
||
float GetDampingRatio() const;
|
||
|
||
private:
|
||
b2WeldJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 轮关节
|
||
class KGE_API WheelJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 轮关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point anchor; ///< 轮关节位置
|
||
Vec2 axis; ///< 物体A滑动方向
|
||
bool enable_motor; ///< 是否启用马达
|
||
float max_motor_torque; ///< 最大马达力 [N]
|
||
float motor_speed; ///< 马达转速 [degree/s]
|
||
float frequency_hz; ///< 响应速度，数值越高关节响应的速度越快，看上去越坚固
|
||
float damping_ratio; ///< 弹簧阻尼率，值越大关节运动阻尼越大
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& anchor, Vec2 const& axis, float frequency_hz = 2.0f,
|
||
float damping_ratio = 0.7f, bool enable_motor = false, float max_motor_torque = 0.0f,
|
||
float motor_speed = 0.0f)
|
||
: ParamBase(body_a, body_b)
|
||
, anchor(anchor)
|
||
, axis(axis)
|
||
, enable_motor(enable_motor)
|
||
, max_motor_torque(max_motor_torque)
|
||
, motor_speed(motor_speed)
|
||
, frequency_hz(frequency_hz)
|
||
, damping_ratio(damping_ratio)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& anchor, Vec2 const& axis, float frequency_hz = 2.0f,
|
||
float damping_ratio = 0.7f, bool enable_motor = false, float max_motor_torque = 0.0f,
|
||
float motor_speed = 0.0f)
|
||
: Param(body_a.get(), body_b.get(), anchor, axis, frequency_hz, damping_ratio, enable_motor,
|
||
max_motor_torque, motor_speed)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建轮关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static WheelJointPtr Create(World* world, Param const& param);
|
||
|
||
WheelJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节当前的平移距离
|
||
float GetJointTranslation() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节当前的线性速度
|
||
float GetJointLinearSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节当前的角度
|
||
float GetJointAngle() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 获取关节当前的旋转速度
|
||
float GetJointAngularSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 是否启用马达
|
||
bool IsMotorEnabled() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置是否启用马达
|
||
void EnableMotor(bool flag);
|
||
|
||
/// \~chinese
|
||
/// @brief 设置马达转速 [degree/s]
|
||
void SetMotorSpeed(float speed);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取马达转速 [degree/s]
|
||
float GetMotorSpeed() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置最大马达转矩 [N/m]
|
||
void SetMaxMotorTorque(float torque);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大马达转矩 [N/m]
|
||
float GetMaxMotorTorque() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置弹簧响应速度
|
||
void SetSpringFrequencyHz(float hz);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取弹簧响应速度
|
||
float GetSpringFrequencyHz() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置弹簧阻尼率
|
||
void SetSpringDampingRatio(float ratio);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取弹簧阻尼率
|
||
float GetSpringDampingRatio() const;
|
||
|
||
private:
|
||
b2WheelJoint* raw_joint_;
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 鼠标关节
|
||
/// @details 用于使身体的某个点追踪世界上的指定点，例如让物体追踪鼠标位置
|
||
class KGE_API MouseJoint : public Joint
|
||
{
|
||
public:
|
||
/// \~chinese
|
||
/// @brief 鼠标关节参数
|
||
struct Param : public Joint::ParamBase
|
||
{
|
||
Point target; ///< 关节作用目标位置
|
||
float max_force; ///< 作用在物体A上的最大力
|
||
float frequency_hz; ///< 响应速度，数值越高关节响应的速度越快，看上去越坚固
|
||
float damping_ratio; ///< 阻尼率，值越大关节运动阻尼越大
|
||
|
||
Param(Body* body_a, Body* body_b, Point const& target, float max_force, float frequency_hz = 5.0f,
|
||
float damping_ratio = 0.7f)
|
||
: ParamBase(body_a, body_b)
|
||
, target(target)
|
||
, max_force(max_force)
|
||
, frequency_hz(frequency_hz)
|
||
, damping_ratio(damping_ratio)
|
||
{
|
||
}
|
||
|
||
Param(BodyPtr body_a, BodyPtr body_b, Point const& target, float max_force, float frequency_hz = 5.0f,
|
||
float damping_ratio = 0.7f)
|
||
: Param(body_a.get(), body_b.get(), target, max_force, frequency_hz, damping_ratio)
|
||
{
|
||
}
|
||
};
|
||
|
||
/// \~chinese
|
||
/// @brief 创建鼠标关节
|
||
/// @param world 物理世界
|
||
/// @param param 关节参数
|
||
static MouseJointPtr Create(World* world, Param const& param);
|
||
|
||
MouseJoint();
|
||
|
||
/// \~chinese
|
||
/// @brief 初始化关节
|
||
bool InitJoint(World* world, Param const& param);
|
||
|
||
/// \~chinese
|
||
/// @brief 设定最大摩擦力 [N]
|
||
void SetMaxForce(float force);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取最大摩擦力 [N]
|
||
float GetMaxForce() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置响应速度 [hz]
|
||
void SetFrequency(float hz);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取响应速度 [hz]
|
||
float GetFrequency() const;
|
||
|
||
/// \~chinese
|
||
/// @brief 设置阻尼率
|
||
void SetDampingRatio(float ratio);
|
||
|
||
/// \~chinese
|
||
/// @brief 获取阻尼率
|
||
float GetDampingRatio() const;
|
||
|
||
private:
|
||
b2MouseJoint* raw_joint_;
|
||
};
|
||
|
||
/** @} */
|
||
|
||
inline b2Joint* Joint::GetB2Joint() const
|
||
{
|
||
return joint_;
|
||
}
|
||
inline World* Joint::GetWorld() const
|
||
{
|
||
return world_;
|
||
}
|
||
|
||
inline void DistanceJoint::SetFrequency(float hz)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetFrequency(hz);
|
||
}
|
||
inline float DistanceJoint::GetFrequency() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetFrequency();
|
||
}
|
||
inline void DistanceJoint::SetDampingRatio(float ratio)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetDampingRatio(ratio);
|
||
}
|
||
inline float DistanceJoint::GetDampingRatio() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetDampingRatio();
|
||
}
|
||
|
||
inline float PrismaticJoint::GetReferenceAngle() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetReferenceAngle());
|
||
}
|
||
inline bool PrismaticJoint::IsLimitEnabled() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->IsLimitEnabled();
|
||
}
|
||
inline void PrismaticJoint::EnableLimit(bool flag)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->EnableLimit(flag);
|
||
}
|
||
inline bool PrismaticJoint::IsMotorEnabled() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->IsMotorEnabled();
|
||
}
|
||
inline void PrismaticJoint::EnableMotor(bool flag)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->EnableMotor(flag);
|
||
}
|
||
inline void PrismaticJoint::SetMotorSpeed(float speed)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
|
||
}
|
||
inline float PrismaticJoint::GetMotorSpeed() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetMotorSpeed());
|
||
}
|
||
inline void PrismaticJoint::SetMaxMotorForce(float force)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetMaxMotorForce(force);
|
||
}
|
||
inline float PrismaticJoint::GetMaxMotorForce() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetMaxMotorForce();
|
||
}
|
||
|
||
inline float RevoluteJoint::GetReferenceAngle() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetReferenceAngle());
|
||
}
|
||
inline bool RevoluteJoint::IsLimitEnabled() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->IsLimitEnabled();
|
||
}
|
||
inline void RevoluteJoint::EnableLimit(bool flag)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->EnableLimit(flag);
|
||
}
|
||
inline bool RevoluteJoint::IsMotorEnabled() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->IsMotorEnabled();
|
||
}
|
||
inline void RevoluteJoint::EnableMotor(bool flag)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->EnableMotor(flag);
|
||
}
|
||
inline void RevoluteJoint::SetMotorSpeed(float speed)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
|
||
}
|
||
inline float RevoluteJoint::GetMotorSpeed() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetMotorSpeed());
|
||
}
|
||
|
||
inline float WeldJoint::GetReferenceAngle() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetReferenceAngle());
|
||
}
|
||
inline void WeldJoint::SetFrequency(float hz)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetFrequency(hz);
|
||
}
|
||
inline float WeldJoint::GetFrequency() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetFrequency();
|
||
}
|
||
inline void WeldJoint::SetDampingRatio(float ratio)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetDampingRatio(ratio);
|
||
}
|
||
inline float WeldJoint::GetDampingRatio() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetDampingRatio();
|
||
}
|
||
|
||
inline float WheelJoint::GetJointAngle() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetJointAngle());
|
||
}
|
||
inline float WheelJoint::GetJointAngularSpeed() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetJointAngularSpeed());
|
||
}
|
||
inline bool WheelJoint::IsMotorEnabled() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->IsMotorEnabled();
|
||
}
|
||
inline void WheelJoint::EnableMotor(bool flag)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->EnableMotor(flag);
|
||
}
|
||
inline void WheelJoint::SetMotorSpeed(float speed)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetMotorSpeed(math::Degree2Radian(speed));
|
||
}
|
||
inline float WheelJoint::GetMotorSpeed() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return math::Radian2Degree(raw_joint_->GetMotorSpeed());
|
||
}
|
||
inline void WheelJoint::SetSpringFrequencyHz(float hz)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetSpringFrequencyHz(hz);
|
||
}
|
||
inline float WheelJoint::GetSpringFrequencyHz() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetSpringFrequencyHz();
|
||
}
|
||
inline void WheelJoint::SetSpringDampingRatio(float ratio)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetSpringDampingRatio(ratio);
|
||
}
|
||
inline float WheelJoint::GetSpringDampingRatio() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetSpringDampingRatio();
|
||
}
|
||
|
||
inline void MouseJoint::SetFrequency(float hz)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetFrequency(hz);
|
||
}
|
||
inline float MouseJoint::GetFrequency() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetFrequency();
|
||
}
|
||
inline void MouseJoint::SetDampingRatio(float ratio)
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
raw_joint_->SetDampingRatio(ratio);
|
||
}
|
||
inline float MouseJoint::GetDampingRatio() const
|
||
{
|
||
KGE_ASSERT(raw_joint_);
|
||
return raw_joint_->GetDampingRatio();
|
||
}
|
||
} // namespace physics
|
||
} // namespace kiwano
|