Use real_t in physics nodes
This commit is contained in:
Aaron Franke
parent
46de553473
commit
9199a681de
|
|
@ -165,7 +165,7 @@ bool CollisionObject2D::is_shape_owner_one_way_collision_enabled(uint32_t p_owne
|
|||
return shapes[p_owner].one_way_collision;
|
||||
}
|
||||
|
||||
void CollisionObject2D::shape_owner_set_one_way_collision_margin(uint32_t p_owner, float p_margin) {
|
||||
void CollisionObject2D::shape_owner_set_one_way_collision_margin(uint32_t p_owner, real_t p_margin) {
|
||||
if (area) {
|
||||
return; //not for areas
|
||||
}
|
||||
|
|
@ -179,7 +179,7 @@ void CollisionObject2D::shape_owner_set_one_way_collision_margin(uint32_t p_owne
|
|||
}
|
||||
}
|
||||
|
||||
float CollisionObject2D::get_shape_owner_one_way_collision_margin(uint32_t p_owner) const {
|
||||
real_t CollisionObject2D::get_shape_owner_one_way_collision_margin(uint32_t p_owner) const {
|
||||
ERR_FAIL_COND_V(!shapes.has(p_owner), 0);
|
||||
|
||||
return shapes[p_owner].one_way_collision_margin;
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ class CollisionObject2D : public Node2D {
|
|||
Vector<Shape> shapes;
|
||||
bool disabled;
|
||||
bool one_way_collision;
|
||||
float one_way_collision_margin;
|
||||
real_t one_way_collision_margin;
|
||||
|
||||
ShapeData() {
|
||||
disabled = false;
|
||||
|
|
@ -97,8 +97,8 @@ public:
|
|||
void shape_owner_set_one_way_collision(uint32_t p_owner, bool p_enable);
|
||||
bool is_shape_owner_one_way_collision_enabled(uint32_t p_owner) const;
|
||||
|
||||
void shape_owner_set_one_way_collision_margin(uint32_t p_owner, float p_margin);
|
||||
float get_shape_owner_one_way_collision_margin(uint32_t p_owner) const;
|
||||
void shape_owner_set_one_way_collision_margin(uint32_t p_owner, real_t p_margin);
|
||||
real_t get_shape_owner_one_way_collision_margin(uint32_t p_owner) const;
|
||||
|
||||
void shape_owner_add_shape(uint32_t p_owner, const Ref<Shape2D> &p_shape);
|
||||
int shape_owner_get_shape_count(uint32_t p_owner) const;
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ void CollisionPolygon2D::_notification(int p_what) {
|
|||
Vector2 line_to(0, 20);
|
||||
draw_line(Vector2(), line_to, dcol, 3);
|
||||
Vector<Vector2> pts;
|
||||
float tsize = 8;
|
||||
real_t tsize = 8;
|
||||
pts.push_back(line_to + (Vector2(0, tsize)));
|
||||
pts.push_back(line_to + (Vector2(Math_SQRT12 * tsize, 0)));
|
||||
pts.push_back(line_to + (Vector2(-Math_SQRT12 * tsize, 0)));
|
||||
|
|
@ -275,14 +275,14 @@ bool CollisionPolygon2D::is_one_way_collision_enabled() const {
|
|||
return one_way_collision;
|
||||
}
|
||||
|
||||
void CollisionPolygon2D::set_one_way_collision_margin(float p_margin) {
|
||||
void CollisionPolygon2D::set_one_way_collision_margin(real_t p_margin) {
|
||||
one_way_collision_margin = p_margin;
|
||||
if (parent) {
|
||||
parent->shape_owner_set_one_way_collision_margin(owner_id, one_way_collision_margin);
|
||||
}
|
||||
}
|
||||
|
||||
float CollisionPolygon2D::get_one_way_collision_margin() const {
|
||||
real_t CollisionPolygon2D::get_one_way_collision_margin() const {
|
||||
return one_way_collision_margin;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ protected:
|
|||
CollisionObject2D *parent;
|
||||
bool disabled;
|
||||
bool one_way_collision;
|
||||
float one_way_collision_margin;
|
||||
real_t one_way_collision_margin;
|
||||
|
||||
Vector<Vector<Vector2>> _decompose_in_convex();
|
||||
|
||||
|
|
@ -86,8 +86,8 @@ public:
|
|||
void set_one_way_collision(bool p_enable);
|
||||
bool is_one_way_collision_enabled() const;
|
||||
|
||||
void set_one_way_collision_margin(float p_margin);
|
||||
float get_one_way_collision_margin() const;
|
||||
void set_one_way_collision_margin(real_t p_margin);
|
||||
real_t get_one_way_collision_margin() const;
|
||||
|
||||
CollisionPolygon2D();
|
||||
};
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ void CollisionShape2D::_notification(int p_what) {
|
|||
Vector2 line_to(0, 20);
|
||||
draw_line(Vector2(), line_to, draw_col, 2);
|
||||
Vector<Vector2> pts;
|
||||
float tsize = 8;
|
||||
real_t tsize = 8;
|
||||
pts.push_back(line_to + (Vector2(0, tsize)));
|
||||
pts.push_back(line_to + (Vector2(Math_SQRT12 * tsize, 0)));
|
||||
pts.push_back(line_to + (Vector2(-Math_SQRT12 * tsize, 0)));
|
||||
|
|
@ -215,14 +215,14 @@ bool CollisionShape2D::is_one_way_collision_enabled() const {
|
|||
return one_way_collision;
|
||||
}
|
||||
|
||||
void CollisionShape2D::set_one_way_collision_margin(float p_margin) {
|
||||
void CollisionShape2D::set_one_way_collision_margin(real_t p_margin) {
|
||||
one_way_collision_margin = p_margin;
|
||||
if (parent) {
|
||||
parent->shape_owner_set_one_way_collision_margin(owner_id, one_way_collision_margin);
|
||||
}
|
||||
}
|
||||
|
||||
float CollisionShape2D::get_one_way_collision_margin() const {
|
||||
real_t CollisionShape2D::get_one_way_collision_margin() const {
|
||||
return one_way_collision_margin;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ class CollisionShape2D : public Node2D {
|
|||
void _shape_changed();
|
||||
bool disabled;
|
||||
bool one_way_collision;
|
||||
float one_way_collision_margin;
|
||||
real_t one_way_collision_margin;
|
||||
|
||||
void _update_in_shape_owner(bool p_xform_only = false);
|
||||
|
||||
|
|
@ -69,8 +69,8 @@ public:
|
|||
void set_one_way_collision(bool p_enable);
|
||||
bool is_one_way_collision_enabled() const;
|
||||
|
||||
void set_one_way_collision_margin(float p_margin);
|
||||
float get_one_way_collision_margin() const;
|
||||
void set_one_way_collision_margin(real_t p_margin);
|
||||
real_t get_one_way_collision_margin() const;
|
||||
|
||||
virtual String get_configuration_warning() const override;
|
||||
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ struct _RigidBody2DInOut {
|
|||
int local_shape;
|
||||
};
|
||||
|
||||
bool RigidBody2D::_test_motion(const Vector2 &p_motion, bool p_infinite_inertia, float p_margin, const Ref<PhysicsTestMotionResult2D> &p_result) {
|
||||
bool RigidBody2D::_test_motion(const Vector2 &p_motion, bool p_infinite_inertia, real_t p_margin, const Ref<PhysicsTestMotionResult2D> &p_result) {
|
||||
PhysicsServer2D::MotionResult *r = nullptr;
|
||||
if (p_result.is_valid()) {
|
||||
r = p_result->get_result_ptr();
|
||||
|
|
@ -611,7 +611,7 @@ void RigidBody2D::apply_impulse(const Vector2 &p_impulse, const Vector2 &p_posit
|
|||
PhysicsServer2D::get_singleton()->body_apply_impulse(get_rid(), p_impulse, p_position);
|
||||
}
|
||||
|
||||
void RigidBody2D::apply_torque_impulse(float p_torque) {
|
||||
void RigidBody2D::apply_torque_impulse(real_t p_torque) {
|
||||
PhysicsServer2D::get_singleton()->body_apply_torque_impulse(get_rid(), p_torque);
|
||||
}
|
||||
|
||||
|
|
@ -623,11 +623,11 @@ Vector2 RigidBody2D::get_applied_force() const {
|
|||
return PhysicsServer2D::get_singleton()->body_get_applied_force(get_rid());
|
||||
};
|
||||
|
||||
void RigidBody2D::set_applied_torque(const float p_torque) {
|
||||
void RigidBody2D::set_applied_torque(const real_t p_torque) {
|
||||
PhysicsServer2D::get_singleton()->body_set_applied_torque(get_rid(), p_torque);
|
||||
};
|
||||
|
||||
float RigidBody2D::get_applied_torque() const {
|
||||
real_t RigidBody2D::get_applied_torque() const {
|
||||
return PhysicsServer2D::get_singleton()->body_get_applied_torque(get_rid());
|
||||
};
|
||||
|
||||
|
|
@ -639,7 +639,7 @@ void RigidBody2D::add_force(const Vector2 &p_force, const Vector2 &p_position) {
|
|||
PhysicsServer2D::get_singleton()->body_add_force(get_rid(), p_force, p_position);
|
||||
}
|
||||
|
||||
void RigidBody2D::add_torque(const float p_torque) {
|
||||
void RigidBody2D::add_torque(const real_t p_torque) {
|
||||
PhysicsServer2D::get_singleton()->body_add_torque(get_rid(), p_torque);
|
||||
}
|
||||
|
||||
|
|
@ -906,7 +906,7 @@ bool KinematicBody2D::separate_raycast_shapes(bool p_infinite_inertia, Collision
|
|||
Vector2 recover;
|
||||
int hits = PhysicsServer2D::get_singleton()->body_test_ray_separation(get_rid(), gt, p_infinite_inertia, recover, sep_res, 8, margin);
|
||||
int deepest = -1;
|
||||
float deepest_depth;
|
||||
real_t deepest_depth;
|
||||
for (int i = 0; i < hits; i++) {
|
||||
if (deepest == -1 || sep_res[i].collision_depth > deepest_depth) {
|
||||
deepest = i;
|
||||
|
|
@ -966,7 +966,7 @@ bool KinematicBody2D::move_and_collide(const Vector2 &p_motion, bool p_infinite_
|
|||
//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
|
||||
#define FLOOR_ANGLE_THRESHOLD 0.01
|
||||
|
||||
Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_up_direction, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_up_direction, bool p_stop_on_slope, int p_max_slides, real_t p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector2 body_velocity = p_linear_velocity;
|
||||
Vector2 body_velocity_normal = body_velocity.normalized();
|
||||
Vector2 up_direction = p_up_direction.normalized();
|
||||
|
|
@ -1057,7 +1057,7 @@ Vector2 KinematicBody2D::move_and_slide(const Vector2 &p_linear_velocity, const
|
|||
return body_velocity;
|
||||
}
|
||||
|
||||
Vector2 KinematicBody2D::move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_up_direction, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector2 KinematicBody2D::move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_up_direction, bool p_stop_on_slope, int p_max_slides, real_t p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector2 up_direction = p_up_direction.normalized();
|
||||
bool was_on_floor = on_floor;
|
||||
|
||||
|
|
@ -1123,11 +1123,11 @@ bool KinematicBody2D::test_move(const Transform2D &p_from, const Vector2 &p_moti
|
|||
return PhysicsServer2D::get_singleton()->body_test_motion(get_rid(), p_from, p_motion, p_infinite_inertia, margin);
|
||||
}
|
||||
|
||||
void KinematicBody2D::set_safe_margin(float p_margin) {
|
||||
void KinematicBody2D::set_safe_margin(real_t p_margin) {
|
||||
margin = p_margin;
|
||||
}
|
||||
|
||||
float KinematicBody2D::get_safe_margin() const {
|
||||
real_t KinematicBody2D::get_safe_margin() const {
|
||||
return margin;
|
||||
}
|
||||
|
||||
|
|
@ -1219,8 +1219,8 @@ void KinematicBody2D::_notification(int p_what) {
|
|||
|
||||
void KinematicBody2D::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("move_and_collide", "rel_vec", "infinite_inertia", "exclude_raycast_shapes", "test_only"), &KinematicBody2D::_move, DEFVAL(true), DEFVAL(true), DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody2D::move_and_slide_with_snap, DEFVAL(Vector2(0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody2D::move_and_slide, DEFVAL(Vector2(0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((real_t)45.0)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody2D::move_and_slide_with_snap, DEFVAL(Vector2(0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((real_t)45.0)), DEFVAL(true));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("test_move", "from", "rel_vec", "infinite_inertia"), &KinematicBody2D::test_move, DEFVAL(true));
|
||||
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ private:
|
|||
void _body_inout(int p_status, ObjectID p_instance, int p_body_shape, int p_local_shape);
|
||||
void _direct_state_changed(Object *p_state);
|
||||
|
||||
bool _test_motion(const Vector2 &p_motion, bool p_infinite_inertia = true, float p_margin = 0.08, const Ref<PhysicsTestMotionResult2D> &p_result = Ref<PhysicsTestMotionResult2D>());
|
||||
bool _test_motion(const Vector2 &p_motion, bool p_infinite_inertia = true, real_t p_margin = 0.08, const Ref<PhysicsTestMotionResult2D> &p_result = Ref<PhysicsTestMotionResult2D>());
|
||||
|
||||
protected:
|
||||
void _notification(int p_what);
|
||||
|
|
@ -232,17 +232,17 @@ public:
|
|||
|
||||
void apply_central_impulse(const Vector2 &p_impulse);
|
||||
void apply_impulse(const Vector2 &p_impulse, const Vector2 &p_position = Vector2());
|
||||
void apply_torque_impulse(float p_torque);
|
||||
void apply_torque_impulse(real_t p_torque);
|
||||
|
||||
void set_applied_force(const Vector2 &p_force);
|
||||
Vector2 get_applied_force() const;
|
||||
|
||||
void set_applied_torque(const float p_torque);
|
||||
float get_applied_torque() const;
|
||||
void set_applied_torque(const real_t p_torque);
|
||||
real_t get_applied_torque() const;
|
||||
|
||||
void add_central_force(const Vector2 &p_force);
|
||||
void add_force(const Vector2 &p_force, const Vector2 &p_position = Vector2());
|
||||
void add_torque(float p_torque);
|
||||
void add_torque(real_t p_torque);
|
||||
|
||||
TypedArray<Node2D> get_colliding_bodies() const; //function for script
|
||||
|
||||
|
|
@ -276,7 +276,7 @@ public:
|
|||
};
|
||||
|
||||
private:
|
||||
float margin;
|
||||
real_t margin;
|
||||
|
||||
Vector2 floor_normal;
|
||||
Vector2 floor_velocity;
|
||||
|
|
@ -309,11 +309,11 @@ public:
|
|||
|
||||
bool separate_raycast_shapes(bool p_infinite_inertia, Collision &r_collision);
|
||||
|
||||
void set_safe_margin(float p_margin);
|
||||
float get_safe_margin() const;
|
||||
void set_safe_margin(real_t p_margin);
|
||||
real_t get_safe_margin() const;
|
||||
|
||||
Vector2 move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_up_direction = Vector2(0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45), bool p_infinite_inertia = true);
|
||||
Vector2 move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_up_direction = Vector2(0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45), bool p_infinite_inertia = true);
|
||||
Vector2 move_and_slide(const Vector2 &p_linear_velocity, const Vector2 &p_up_direction = Vector2(0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, real_t p_floor_max_angle = Math::deg2rad((real_t)45.0), bool p_infinite_inertia = true);
|
||||
Vector2 move_and_slide_with_snap(const Vector2 &p_linear_velocity, const Vector2 &p_snap, const Vector2 &p_up_direction = Vector2(0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, real_t p_floor_max_angle = Math::deg2rad((real_t)45.0), bool p_infinite_inertia = true);
|
||||
bool is_on_floor() const;
|
||||
bool is_on_wall() const;
|
||||
bool is_on_ceiling() const;
|
||||
|
|
|
|||
|
|
@ -132,13 +132,13 @@ AABB CollisionPolygon3D::get_item_rect() const {
|
|||
return aabb;
|
||||
}
|
||||
|
||||
void CollisionPolygon3D::set_depth(float p_depth) {
|
||||
void CollisionPolygon3D::set_depth(real_t p_depth) {
|
||||
depth = p_depth;
|
||||
_build_polygon();
|
||||
update_gizmo();
|
||||
}
|
||||
|
||||
float CollisionPolygon3D::get_depth() const {
|
||||
real_t CollisionPolygon3D::get_depth() const {
|
||||
return depth;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ class CollisionPolygon3D : public Node3D {
|
|||
GDCLASS(CollisionPolygon3D, Node3D);
|
||||
|
||||
protected:
|
||||
float depth;
|
||||
real_t depth;
|
||||
AABB aabb;
|
||||
Vector<Point2> polygon;
|
||||
|
||||
|
|
@ -59,8 +59,8 @@ protected:
|
|||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_depth(float p_depth);
|
||||
float get_depth() const;
|
||||
void set_depth(real_t p_depth);
|
||||
real_t get_depth() const;
|
||||
|
||||
void set_polygon(const Vector<Point2> &p_polygon);
|
||||
Vector<Point2> get_polygon() const;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ Vector3 PhysicsBody3D::get_angular_velocity() const {
|
|||
return Vector3();
|
||||
}
|
||||
|
||||
float PhysicsBody3D::get_inverse_mass() const {
|
||||
real_t PhysicsBody3D::get_inverse_mass() const {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -924,7 +924,7 @@ bool KinematicBody3D::move_and_collide(const Vector3 &p_motion, bool p_infinite_
|
|||
//so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
|
||||
#define FLOOR_ANGLE_THRESHOLD 0.01
|
||||
|
||||
Vector3 KinematicBody3D::move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_up_direction, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector3 KinematicBody3D::move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_up_direction, bool p_stop_on_slope, int p_max_slides, real_t p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector3 body_velocity = p_linear_velocity;
|
||||
Vector3 body_velocity_normal = body_velocity.normalized();
|
||||
Vector3 up_direction = p_up_direction.normalized();
|
||||
|
|
@ -1018,7 +1018,7 @@ Vector3 KinematicBody3D::move_and_slide(const Vector3 &p_linear_velocity, const
|
|||
return body_velocity;
|
||||
}
|
||||
|
||||
Vector3 KinematicBody3D::move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_up_direction, bool p_stop_on_slope, int p_max_slides, float p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector3 KinematicBody3D::move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_up_direction, bool p_stop_on_slope, int p_max_slides, real_t p_floor_max_angle, bool p_infinite_inertia) {
|
||||
Vector3 up_direction = p_up_direction.normalized();
|
||||
bool was_on_floor = on_floor;
|
||||
|
||||
|
|
@ -1090,7 +1090,7 @@ bool KinematicBody3D::separate_raycast_shapes(bool p_infinite_inertia, Collision
|
|||
Vector3 recover;
|
||||
int hits = PhysicsServer3D::get_singleton()->body_test_ray_separation(get_rid(), gt, p_infinite_inertia, recover, sep_res, 8, margin);
|
||||
int deepest = -1;
|
||||
float deepest_depth;
|
||||
real_t deepest_depth;
|
||||
for (int i = 0; i < hits; i++) {
|
||||
if (deepest == -1 || sep_res[i].collision_depth > deepest_depth) {
|
||||
deepest = i;
|
||||
|
|
@ -1131,12 +1131,12 @@ bool KinematicBody3D::get_axis_lock(PhysicsServer3D::BodyAxis p_axis) const {
|
|||
return PhysicsServer3D::get_singleton()->body_is_axis_locked(get_rid(), p_axis);
|
||||
}
|
||||
|
||||
void KinematicBody3D::set_safe_margin(float p_margin) {
|
||||
void KinematicBody3D::set_safe_margin(real_t p_margin) {
|
||||
margin = p_margin;
|
||||
PhysicsServer3D::get_singleton()->body_set_kinematic_safe_margin(get_rid(), margin);
|
||||
}
|
||||
|
||||
float KinematicBody3D::get_safe_margin() const {
|
||||
real_t KinematicBody3D::get_safe_margin() const {
|
||||
return margin;
|
||||
}
|
||||
|
||||
|
|
@ -1180,8 +1180,8 @@ void KinematicBody3D::_bind_methods() {
|
|||
ClassDB::bind_method(D_METHOD("_direct_state_changed"), &KinematicBody3D::_direct_state_changed);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("move_and_collide", "rel_vec", "infinite_inertia", "exclude_raycast_shapes", "test_only"), &KinematicBody3D::_move, DEFVAL(true), DEFVAL(true), DEFVAL(false));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody3D::move_and_slide, DEFVAL(Vector3(0, 0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody3D::move_and_slide_with_snap, DEFVAL(Vector3(0, 0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((float)45)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide", "linear_velocity", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody3D::move_and_slide, DEFVAL(Vector3(0, 0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((real_t)45.0)), DEFVAL(true));
|
||||
ClassDB::bind_method(D_METHOD("move_and_slide_with_snap", "linear_velocity", "snap", "up_direction", "stop_on_slope", "max_slides", "floor_max_angle", "infinite_inertia"), &KinematicBody3D::move_and_slide_with_snap, DEFVAL(Vector3(0, 0, 0)), DEFVAL(false), DEFVAL(4), DEFVAL(Math::deg2rad((real_t)45.0)), DEFVAL(true));
|
||||
|
||||
ClassDB::bind_method(D_METHOD("test_move", "from", "rel_vec", "infinite_inertia"), &KinematicBody3D::test_move, DEFVAL(true));
|
||||
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ protected:
|
|||
public:
|
||||
virtual Vector3 get_linear_velocity() const;
|
||||
virtual Vector3 get_angular_velocity() const;
|
||||
virtual float get_inverse_mass() const;
|
||||
virtual real_t get_inverse_mass() const;
|
||||
|
||||
void set_collision_layer(uint32_t p_layer);
|
||||
uint32_t get_collision_layer() const;
|
||||
|
|
@ -183,7 +183,7 @@ public:
|
|||
void set_mass(real_t p_mass);
|
||||
real_t get_mass() const;
|
||||
|
||||
virtual float get_inverse_mass() const override { return 1.0 / mass; }
|
||||
virtual real_t get_inverse_mass() const override { return 1.0 / mass; }
|
||||
|
||||
void set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override);
|
||||
Ref<PhysicsMaterial> get_physics_material_override() const;
|
||||
|
|
@ -274,7 +274,7 @@ private:
|
|||
|
||||
uint16_t locked_axis;
|
||||
|
||||
float margin;
|
||||
real_t margin;
|
||||
|
||||
Vector3 floor_normal;
|
||||
Vector3 floor_velocity;
|
||||
|
|
@ -309,11 +309,11 @@ public:
|
|||
void set_axis_lock(PhysicsServer3D::BodyAxis p_axis, bool p_lock);
|
||||
bool get_axis_lock(PhysicsServer3D::BodyAxis p_axis) const;
|
||||
|
||||
void set_safe_margin(float p_margin);
|
||||
float get_safe_margin() const;
|
||||
void set_safe_margin(real_t p_margin);
|
||||
real_t get_safe_margin() const;
|
||||
|
||||
Vector3 move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_up_direction = Vector3(0, 0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45), bool p_infinite_inertia = true);
|
||||
Vector3 move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_up_direction = Vector3(0, 0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, float p_floor_max_angle = Math::deg2rad((float)45), bool p_infinite_inertia = true);
|
||||
Vector3 move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_up_direction = Vector3(0, 0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, real_t p_floor_max_angle = Math::deg2rad((real_t)45.0), bool p_infinite_inertia = true);
|
||||
Vector3 move_and_slide_with_snap(const Vector3 &p_linear_velocity, const Vector3 &p_snap, const Vector3 &p_up_direction = Vector3(0, 0, 0), bool p_stop_on_slope = false, int p_max_slides = 4, real_t p_floor_max_angle = Math::deg2rad((real_t)45.0), bool p_infinite_inertia = true);
|
||||
bool is_on_floor() const;
|
||||
bool is_on_wall() const;
|
||||
bool is_on_ceiling() const;
|
||||
|
|
|
|||
|
|
@ -265,7 +265,7 @@ void PinJoint3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(PARAM_IMPULSE_CLAMP);
|
||||
}
|
||||
|
||||
void PinJoint3D::set_param(Param p_param, float p_value) {
|
||||
void PinJoint3D::set_param(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, 3);
|
||||
params[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -273,7 +273,7 @@ void PinJoint3D::set_param(Param p_param, float p_value) {
|
|||
}
|
||||
}
|
||||
|
||||
float PinJoint3D::get_param(Param p_param) const {
|
||||
real_t PinJoint3D::get_param(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, 3, 0);
|
||||
return params[p_param];
|
||||
}
|
||||
|
|
@ -306,19 +306,19 @@ PinJoint3D::PinJoint3D() {
|
|||
|
||||
///////////////////////////////////
|
||||
|
||||
void HingeJoint3D::_set_upper_limit(float p_limit) {
|
||||
void HingeJoint3D::_set_upper_limit(real_t p_limit) {
|
||||
set_param(PARAM_LIMIT_UPPER, Math::deg2rad(p_limit));
|
||||
}
|
||||
|
||||
float HingeJoint3D::_get_upper_limit() const {
|
||||
real_t HingeJoint3D::_get_upper_limit() const {
|
||||
return Math::rad2deg(get_param(PARAM_LIMIT_UPPER));
|
||||
}
|
||||
|
||||
void HingeJoint3D::_set_lower_limit(float p_limit) {
|
||||
void HingeJoint3D::_set_lower_limit(real_t p_limit) {
|
||||
set_param(PARAM_LIMIT_LOWER, Math::deg2rad(p_limit));
|
||||
}
|
||||
|
||||
float HingeJoint3D::_get_lower_limit() const {
|
||||
real_t HingeJoint3D::_get_lower_limit() const {
|
||||
return Math::rad2deg(get_param(PARAM_LIMIT_LOWER));
|
||||
}
|
||||
|
||||
|
|
@ -363,7 +363,7 @@ void HingeJoint3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(FLAG_MAX);
|
||||
}
|
||||
|
||||
void HingeJoint3D::set_param(Param p_param, float p_value) {
|
||||
void HingeJoint3D::set_param(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -373,7 +373,7 @@ void HingeJoint3D::set_param(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float HingeJoint3D::get_param(Param p_param) const {
|
||||
real_t HingeJoint3D::get_param(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params[p_param];
|
||||
}
|
||||
|
|
@ -437,19 +437,19 @@ HingeJoint3D::HingeJoint3D() {
|
|||
|
||||
//////////////////////////////////
|
||||
|
||||
void SliderJoint3D::_set_upper_limit_angular(float p_limit_angular) {
|
||||
void SliderJoint3D::_set_upper_limit_angular(real_t p_limit_angular) {
|
||||
set_param(PARAM_ANGULAR_LIMIT_UPPER, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float SliderJoint3D::_get_upper_limit_angular() const {
|
||||
real_t SliderJoint3D::_get_upper_limit_angular() const {
|
||||
return Math::rad2deg(get_param(PARAM_ANGULAR_LIMIT_UPPER));
|
||||
}
|
||||
|
||||
void SliderJoint3D::_set_lower_limit_angular(float p_limit_angular) {
|
||||
void SliderJoint3D::_set_lower_limit_angular(real_t p_limit_angular) {
|
||||
set_param(PARAM_ANGULAR_LIMIT_LOWER, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float SliderJoint3D::_get_lower_limit_angular() const {
|
||||
real_t SliderJoint3D::_get_lower_limit_angular() const {
|
||||
return Math::rad2deg(get_param(PARAM_ANGULAR_LIMIT_LOWER));
|
||||
}
|
||||
|
||||
|
|
@ -514,7 +514,7 @@ void SliderJoint3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(PARAM_MAX);
|
||||
}
|
||||
|
||||
void SliderJoint3D::set_param(Param p_param, float p_value) {
|
||||
void SliderJoint3D::set_param(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -523,7 +523,7 @@ void SliderJoint3D::set_param(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float SliderJoint3D::get_param(Param p_param) const {
|
||||
real_t SliderJoint3D::get_param(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params[p_param];
|
||||
}
|
||||
|
|
@ -579,19 +579,19 @@ SliderJoint3D::SliderJoint3D() {
|
|||
|
||||
//////////////////////////////////
|
||||
|
||||
void ConeTwistJoint3D::_set_swing_span(float p_limit_angular) {
|
||||
void ConeTwistJoint3D::_set_swing_span(real_t p_limit_angular) {
|
||||
set_param(PARAM_SWING_SPAN, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float ConeTwistJoint3D::_get_swing_span() const {
|
||||
real_t ConeTwistJoint3D::_get_swing_span() const {
|
||||
return Math::rad2deg(get_param(PARAM_SWING_SPAN));
|
||||
}
|
||||
|
||||
void ConeTwistJoint3D::_set_twist_span(float p_limit_angular) {
|
||||
void ConeTwistJoint3D::_set_twist_span(real_t p_limit_angular) {
|
||||
set_param(PARAM_TWIST_SPAN, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float ConeTwistJoint3D::_get_twist_span() const {
|
||||
real_t ConeTwistJoint3D::_get_twist_span() const {
|
||||
return Math::rad2deg(get_param(PARAM_TWIST_SPAN));
|
||||
}
|
||||
|
||||
|
|
@ -620,7 +620,7 @@ void ConeTwistJoint3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(PARAM_MAX);
|
||||
}
|
||||
|
||||
void ConeTwistJoint3D::set_param(Param p_param, float p_value) {
|
||||
void ConeTwistJoint3D::set_param(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -630,7 +630,7 @@ void ConeTwistJoint3D::set_param(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float ConeTwistJoint3D::get_param(Param p_param) const {
|
||||
real_t ConeTwistJoint3D::get_param(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params[p_param];
|
||||
}
|
||||
|
|
@ -671,51 +671,51 @@ ConeTwistJoint3D::ConeTwistJoint3D() {
|
|||
|
||||
/////////////////////////////////////////////////////////////////////
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_x(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_x(real_t p_limit_angular) {
|
||||
set_param_x(PARAM_ANGULAR_UPPER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_hi_limit_x() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_hi_limit_x() const {
|
||||
return Math::rad2deg(get_param_x(PARAM_ANGULAR_UPPER_LIMIT));
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_x(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_x(real_t p_limit_angular) {
|
||||
set_param_x(PARAM_ANGULAR_LOWER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_lo_limit_x() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_lo_limit_x() const {
|
||||
return Math::rad2deg(get_param_x(PARAM_ANGULAR_LOWER_LIMIT));
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_y(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_y(real_t p_limit_angular) {
|
||||
set_param_y(PARAM_ANGULAR_UPPER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_hi_limit_y() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_hi_limit_y() const {
|
||||
return Math::rad2deg(get_param_y(PARAM_ANGULAR_UPPER_LIMIT));
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_y(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_y(real_t p_limit_angular) {
|
||||
set_param_y(PARAM_ANGULAR_LOWER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_lo_limit_y() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_lo_limit_y() const {
|
||||
return Math::rad2deg(get_param_y(PARAM_ANGULAR_LOWER_LIMIT));
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_z(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_hi_limit_z(real_t p_limit_angular) {
|
||||
set_param_z(PARAM_ANGULAR_UPPER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_hi_limit_z() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_hi_limit_z() const {
|
||||
return Math::rad2deg(get_param_z(PARAM_ANGULAR_UPPER_LIMIT));
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_z(float p_limit_angular) {
|
||||
void Generic6DOFJoint3D::_set_angular_lo_limit_z(real_t p_limit_angular) {
|
||||
set_param_z(PARAM_ANGULAR_LOWER_LIMIT, Math::deg2rad(p_limit_angular));
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::_get_angular_lo_limit_z() const {
|
||||
real_t Generic6DOFJoint3D::_get_angular_lo_limit_z() const {
|
||||
return Math::rad2deg(get_param_z(PARAM_ANGULAR_LOWER_LIMIT));
|
||||
}
|
||||
|
||||
|
|
@ -877,7 +877,7 @@ void Generic6DOFJoint3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(FLAG_MAX);
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::set_param_x(Param p_param, float p_value) {
|
||||
void Generic6DOFJoint3D::set_param_x(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params_x[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -887,12 +887,12 @@ void Generic6DOFJoint3D::set_param_x(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::get_param_x(Param p_param) const {
|
||||
real_t Generic6DOFJoint3D::get_param_x(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params_x[p_param];
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::set_param_y(Param p_param, float p_value) {
|
||||
void Generic6DOFJoint3D::set_param_y(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params_y[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -901,12 +901,12 @@ void Generic6DOFJoint3D::set_param_y(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::get_param_y(Param p_param) const {
|
||||
real_t Generic6DOFJoint3D::get_param_y(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params_y[p_param];
|
||||
}
|
||||
|
||||
void Generic6DOFJoint3D::set_param_z(Param p_param, float p_value) {
|
||||
void Generic6DOFJoint3D::set_param_z(Param p_param, real_t p_value) {
|
||||
ERR_FAIL_INDEX(p_param, PARAM_MAX);
|
||||
params_z[p_param] = p_value;
|
||||
if (get_joint().is_valid()) {
|
||||
|
|
@ -915,7 +915,7 @@ void Generic6DOFJoint3D::set_param_z(Param p_param, float p_value) {
|
|||
update_gizmo();
|
||||
}
|
||||
|
||||
float Generic6DOFJoint3D::get_param_z(Param p_param) const {
|
||||
real_t Generic6DOFJoint3D::get_param_z(Param p_param) const {
|
||||
ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);
|
||||
return params_z[p_param];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -91,13 +91,13 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
float params[3];
|
||||
real_t params[3];
|
||||
virtual RID _configure_joint(PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_param(Param p_param, float p_value);
|
||||
float get_param(Param p_param) const;
|
||||
void set_param(Param p_param, real_t p_value);
|
||||
real_t get_param(Param p_param) const;
|
||||
|
||||
PinJoint3D();
|
||||
};
|
||||
|
|
@ -127,20 +127,20 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
float params[PARAM_MAX];
|
||||
real_t params[PARAM_MAX];
|
||||
bool flags[FLAG_MAX];
|
||||
virtual RID _configure_joint(PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
|
||||
static void _bind_methods();
|
||||
|
||||
void _set_upper_limit(float p_limit);
|
||||
float _get_upper_limit() const;
|
||||
void _set_upper_limit(real_t p_limit);
|
||||
real_t _get_upper_limit() const;
|
||||
|
||||
void _set_lower_limit(float p_limit);
|
||||
float _get_lower_limit() const;
|
||||
void _set_lower_limit(real_t p_limit);
|
||||
real_t _get_lower_limit() const;
|
||||
|
||||
public:
|
||||
void set_param(Param p_param, float p_value);
|
||||
float get_param(Param p_param) const;
|
||||
void set_param(Param p_param, real_t p_value);
|
||||
real_t get_param(Param p_param) const;
|
||||
|
||||
void set_flag(Flag p_flag, bool p_value);
|
||||
bool get_flag(Flag p_flag) const;
|
||||
|
|
@ -184,19 +184,19 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
void _set_upper_limit_angular(float p_limit_angular);
|
||||
float _get_upper_limit_angular() const;
|
||||
void _set_upper_limit_angular(real_t p_limit_angular);
|
||||
real_t _get_upper_limit_angular() const;
|
||||
|
||||
void _set_lower_limit_angular(float p_limit_angular);
|
||||
float _get_lower_limit_angular() const;
|
||||
void _set_lower_limit_angular(real_t p_limit_angular);
|
||||
real_t _get_lower_limit_angular() const;
|
||||
|
||||
float params[PARAM_MAX];
|
||||
real_t params[PARAM_MAX];
|
||||
virtual RID _configure_joint(PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_param(Param p_param, float p_value);
|
||||
float get_param(Param p_param) const;
|
||||
void set_param(Param p_param, real_t p_value);
|
||||
real_t get_param(Param p_param) const;
|
||||
|
||||
SliderJoint3D();
|
||||
};
|
||||
|
|
@ -217,19 +217,19 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
void _set_swing_span(float p_limit_angular);
|
||||
float _get_swing_span() const;
|
||||
void _set_swing_span(real_t p_limit_angular);
|
||||
real_t _get_swing_span() const;
|
||||
|
||||
void _set_twist_span(float p_limit_angular);
|
||||
float _get_twist_span() const;
|
||||
void _set_twist_span(real_t p_limit_angular);
|
||||
real_t _get_twist_span() const;
|
||||
|
||||
float params[PARAM_MAX];
|
||||
real_t params[PARAM_MAX];
|
||||
virtual RID _configure_joint(PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_param(Param p_param, float p_value);
|
||||
float get_param(Param p_param) const;
|
||||
void set_param(Param p_param, real_t p_value);
|
||||
real_t get_param(Param p_param) const;
|
||||
|
||||
ConeTwistJoint3D();
|
||||
};
|
||||
|
|
@ -277,43 +277,43 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
void _set_angular_hi_limit_x(float p_limit_angular);
|
||||
float _get_angular_hi_limit_x() const;
|
||||
void _set_angular_hi_limit_x(real_t p_limit_angular);
|
||||
real_t _get_angular_hi_limit_x() const;
|
||||
|
||||
void _set_angular_hi_limit_y(float p_limit_angular);
|
||||
float _get_angular_hi_limit_y() const;
|
||||
void _set_angular_hi_limit_y(real_t p_limit_angular);
|
||||
real_t _get_angular_hi_limit_y() const;
|
||||
|
||||
void _set_angular_hi_limit_z(float p_limit_angular);
|
||||
float _get_angular_hi_limit_z() const;
|
||||
void _set_angular_hi_limit_z(real_t p_limit_angular);
|
||||
real_t _get_angular_hi_limit_z() const;
|
||||
|
||||
void _set_angular_lo_limit_x(float p_limit_angular);
|
||||
float _get_angular_lo_limit_x() const;
|
||||
void _set_angular_lo_limit_x(real_t p_limit_angular);
|
||||
real_t _get_angular_lo_limit_x() const;
|
||||
|
||||
void _set_angular_lo_limit_y(float p_limit_angular);
|
||||
float _get_angular_lo_limit_y() const;
|
||||
void _set_angular_lo_limit_y(real_t p_limit_angular);
|
||||
real_t _get_angular_lo_limit_y() const;
|
||||
|
||||
void _set_angular_lo_limit_z(float p_limit_angular);
|
||||
float _get_angular_lo_limit_z() const;
|
||||
void _set_angular_lo_limit_z(real_t p_limit_angular);
|
||||
real_t _get_angular_lo_limit_z() const;
|
||||
|
||||
float params_x[PARAM_MAX];
|
||||
real_t params_x[PARAM_MAX];
|
||||
bool flags_x[FLAG_MAX];
|
||||
float params_y[PARAM_MAX];
|
||||
real_t params_y[PARAM_MAX];
|
||||
bool flags_y[FLAG_MAX];
|
||||
float params_z[PARAM_MAX];
|
||||
real_t params_z[PARAM_MAX];
|
||||
bool flags_z[FLAG_MAX];
|
||||
|
||||
virtual RID _configure_joint(PhysicsBody3D *body_a, PhysicsBody3D *body_b) override;
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_param_x(Param p_param, float p_value);
|
||||
float get_param_x(Param p_param) const;
|
||||
void set_param_x(Param p_param, real_t p_value);
|
||||
real_t get_param_x(Param p_param) const;
|
||||
|
||||
void set_param_y(Param p_param, float p_value);
|
||||
float get_param_y(Param p_param) const;
|
||||
void set_param_y(Param p_param, real_t p_value);
|
||||
real_t get_param_y(Param p_param) const;
|
||||
|
||||
void set_param_z(Param p_param, float p_value);
|
||||
float get_param_z(Param p_param) const;
|
||||
void set_param_z(Param p_param, real_t p_value);
|
||||
real_t get_param_z(Param p_param) const;
|
||||
|
||||
void set_flag_x(Flag p_flag, bool p_enabled);
|
||||
bool get_flag_x(Flag p_flag) const;
|
||||
|
|
|
|||
|
|
@ -78,11 +78,11 @@ void SpringArm3D::_bind_methods() {
|
|||
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "margin"), "set_margin", "get_margin");
|
||||
}
|
||||
|
||||
float SpringArm3D::get_length() const {
|
||||
real_t SpringArm3D::get_length() const {
|
||||
return spring_length;
|
||||
}
|
||||
|
||||
void SpringArm3D::set_length(float p_length) {
|
||||
void SpringArm3D::set_length(real_t p_length) {
|
||||
if (is_inside_tree() && (Engine::get_singleton()->is_editor_hint() || get_tree()->is_debugging_collisions_hint())) {
|
||||
update_gizmo();
|
||||
}
|
||||
|
|
@ -106,11 +106,11 @@ uint32_t SpringArm3D::get_mask() {
|
|||
return mask;
|
||||
}
|
||||
|
||||
float SpringArm3D::get_margin() {
|
||||
real_t SpringArm3D::get_margin() {
|
||||
return margin;
|
||||
}
|
||||
|
||||
void SpringArm3D::set_margin(float p_margin) {
|
||||
void SpringArm3D::set_margin(real_t p_margin) {
|
||||
margin = p_margin;
|
||||
}
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ void SpringArm3D::clear_excluded_objects() {
|
|||
excluded_objects.clear();
|
||||
}
|
||||
|
||||
float SpringArm3D::get_hit_length() {
|
||||
real_t SpringArm3D::get_hit_length() {
|
||||
return current_spring_length;
|
||||
}
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ void SpringArm3D::process_spring() {
|
|||
PhysicsDirectSpaceState3D::RayResult r;
|
||||
bool intersected = get_world_3d()->get_direct_space_state()->intersect_ray(get_global_transform().origin, get_global_transform().origin + motion, r, excluded_objects, mask);
|
||||
if (intersected) {
|
||||
float dist = get_global_transform().origin.distance_to(r.position);
|
||||
real_t dist = get_global_transform().origin.distance_to(r.position);
|
||||
dist -= margin;
|
||||
motion_delta = dist / (spring_length);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,19 +38,19 @@ class SpringArm3D : public Node3D {
|
|||
|
||||
Ref<Shape3D> shape;
|
||||
Set<RID> excluded_objects;
|
||||
float spring_length = 1;
|
||||
float current_spring_length = 0;
|
||||
real_t spring_length = 1;
|
||||
real_t current_spring_length = 0;
|
||||
bool keep_child_basis = false;
|
||||
uint32_t mask = 1;
|
||||
float margin = 0.01;
|
||||
real_t margin = 0.01;
|
||||
|
||||
protected:
|
||||
void _notification(int p_what);
|
||||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_length(float p_length);
|
||||
float get_length() const;
|
||||
void set_length(real_t p_length);
|
||||
real_t get_length() const;
|
||||
void set_shape(Ref<Shape3D> p_shape);
|
||||
Ref<Shape3D> get_shape() const;
|
||||
void set_mask(uint32_t p_mask);
|
||||
|
|
@ -58,9 +58,9 @@ public:
|
|||
void add_excluded_object(RID p_rid);
|
||||
bool remove_excluded_object(RID p_rid);
|
||||
void clear_excluded_objects();
|
||||
float get_hit_length();
|
||||
void set_margin(float p_margin);
|
||||
float get_margin();
|
||||
real_t get_hit_length();
|
||||
void set_margin(real_t p_margin);
|
||||
real_t get_margin();
|
||||
|
||||
SpringArm3D() {}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,77 +147,77 @@ void VehicleWheel3D::_update(PhysicsDirectBodyState3D *s) {
|
|||
}
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_radius(float p_radius) {
|
||||
void VehicleWheel3D::set_radius(real_t p_radius) {
|
||||
m_wheelRadius = p_radius;
|
||||
update_gizmo();
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_radius() const {
|
||||
real_t VehicleWheel3D::get_radius() const {
|
||||
return m_wheelRadius;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_suspension_rest_length(float p_length) {
|
||||
void VehicleWheel3D::set_suspension_rest_length(real_t p_length) {
|
||||
m_suspensionRestLength = p_length;
|
||||
update_gizmo();
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_suspension_rest_length() const {
|
||||
real_t VehicleWheel3D::get_suspension_rest_length() const {
|
||||
return m_suspensionRestLength;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_suspension_travel(float p_length) {
|
||||
void VehicleWheel3D::set_suspension_travel(real_t p_length) {
|
||||
m_maxSuspensionTravelCm = p_length / 0.01;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_suspension_travel() const {
|
||||
real_t VehicleWheel3D::get_suspension_travel() const {
|
||||
return m_maxSuspensionTravelCm * 0.01;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_suspension_stiffness(float p_value) {
|
||||
void VehicleWheel3D::set_suspension_stiffness(real_t p_value) {
|
||||
m_suspensionStiffness = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_suspension_stiffness() const {
|
||||
real_t VehicleWheel3D::get_suspension_stiffness() const {
|
||||
return m_suspensionStiffness;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_suspension_max_force(float p_value) {
|
||||
void VehicleWheel3D::set_suspension_max_force(real_t p_value) {
|
||||
m_maxSuspensionForce = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_suspension_max_force() const {
|
||||
real_t VehicleWheel3D::get_suspension_max_force() const {
|
||||
return m_maxSuspensionForce;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_damping_compression(float p_value) {
|
||||
void VehicleWheel3D::set_damping_compression(real_t p_value) {
|
||||
m_wheelsDampingCompression = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_damping_compression() const {
|
||||
real_t VehicleWheel3D::get_damping_compression() const {
|
||||
return m_wheelsDampingCompression;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_damping_relaxation(float p_value) {
|
||||
void VehicleWheel3D::set_damping_relaxation(real_t p_value) {
|
||||
m_wheelsDampingRelaxation = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_damping_relaxation() const {
|
||||
real_t VehicleWheel3D::get_damping_relaxation() const {
|
||||
return m_wheelsDampingRelaxation;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_friction_slip(float p_value) {
|
||||
void VehicleWheel3D::set_friction_slip(real_t p_value) {
|
||||
m_frictionSlip = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_friction_slip() const {
|
||||
real_t VehicleWheel3D::get_friction_slip() const {
|
||||
return m_frictionSlip;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_roll_influence(float p_value) {
|
||||
void VehicleWheel3D::set_roll_influence(real_t p_value) {
|
||||
m_rollInfluence = p_value;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_roll_influence() const {
|
||||
real_t VehicleWheel3D::get_roll_influence() const {
|
||||
return m_rollInfluence;
|
||||
}
|
||||
|
||||
|
|
@ -295,27 +295,27 @@ void VehicleWheel3D::_bind_methods() {
|
|||
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping_relaxation"), "set_damping_relaxation", "get_damping_relaxation");
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_engine_force(float p_engine_force) {
|
||||
void VehicleWheel3D::set_engine_force(real_t p_engine_force) {
|
||||
m_engineForce = p_engine_force;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_engine_force() const {
|
||||
real_t VehicleWheel3D::get_engine_force() const {
|
||||
return m_engineForce;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_brake(float p_brake) {
|
||||
void VehicleWheel3D::set_brake(real_t p_brake) {
|
||||
m_brake = p_brake;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_brake() const {
|
||||
real_t VehicleWheel3D::get_brake() const {
|
||||
return m_brake;
|
||||
}
|
||||
|
||||
void VehicleWheel3D::set_steering(float p_steering) {
|
||||
void VehicleWheel3D::set_steering(real_t p_steering) {
|
||||
m_steering = p_steering;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_steering() const {
|
||||
real_t VehicleWheel3D::get_steering() const {
|
||||
return m_steering;
|
||||
}
|
||||
|
||||
|
|
@ -335,11 +335,11 @@ bool VehicleWheel3D::is_used_as_steering() const {
|
|||
return steers;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_skidinfo() const {
|
||||
real_t VehicleWheel3D::get_skidinfo() const {
|
||||
return m_skidInfo;
|
||||
}
|
||||
|
||||
float VehicleWheel3D::get_rpm() const {
|
||||
real_t VehicleWheel3D::get_rpm() const {
|
||||
return m_rpm;
|
||||
}
|
||||
|
||||
|
|
@ -564,7 +564,7 @@ void VehicleBody3D::_resolve_single_bilateral(PhysicsDirectBodyState3D *s, const
|
|||
Vector3 vel = vel1 - vel2;
|
||||
|
||||
Basis b2trans;
|
||||
float b2invmass = 0;
|
||||
real_t b2invmass = 0;
|
||||
Vector3 b2lv;
|
||||
Vector3 b2av;
|
||||
Vector3 b2invinertia; //todo
|
||||
|
|
@ -622,8 +622,8 @@ VehicleBody3D::btVehicleWheelContactPoint::btVehicleWheelContactPoint(PhysicsDir
|
|||
m_frictionPositionWorld(frictionPosWorld),
|
||||
m_frictionDirectionWorld(frictionDirectionWorld),
|
||||
m_maxImpulse(maxImpulse) {
|
||||
float denom0 = 0;
|
||||
float denom1 = 0;
|
||||
real_t denom0 = 0;
|
||||
real_t denom1 = 0;
|
||||
|
||||
{
|
||||
Vector3 r0 = frictionPosWorld - s->get_transform().origin;
|
||||
|
|
@ -831,7 +831,7 @@ void VehicleBody3D::_direct_state_changed(Object *p_state) {
|
|||
|
||||
state = Object::cast_to<PhysicsDirectBodyState3D>(p_state);
|
||||
|
||||
float step = state->get_step();
|
||||
real_t step = state->get_step();
|
||||
|
||||
for (int i = 0; i < wheels.size(); i++) {
|
||||
_update_wheel(i, state);
|
||||
|
|
@ -891,7 +891,7 @@ void VehicleBody3D::_direct_state_changed(Object *p_state) {
|
|||
state = nullptr;
|
||||
}
|
||||
|
||||
void VehicleBody3D::set_engine_force(float p_engine_force) {
|
||||
void VehicleBody3D::set_engine_force(real_t p_engine_force) {
|
||||
engine_force = p_engine_force;
|
||||
for (int i = 0; i < wheels.size(); i++) {
|
||||
VehicleWheel3D &wheelInfo = *wheels[i];
|
||||
|
|
@ -901,11 +901,11 @@ void VehicleBody3D::set_engine_force(float p_engine_force) {
|
|||
}
|
||||
}
|
||||
|
||||
float VehicleBody3D::get_engine_force() const {
|
||||
real_t VehicleBody3D::get_engine_force() const {
|
||||
return engine_force;
|
||||
}
|
||||
|
||||
void VehicleBody3D::set_brake(float p_brake) {
|
||||
void VehicleBody3D::set_brake(real_t p_brake) {
|
||||
brake = p_brake;
|
||||
for (int i = 0; i < wheels.size(); i++) {
|
||||
VehicleWheel3D &wheelInfo = *wheels[i];
|
||||
|
|
@ -913,11 +913,11 @@ void VehicleBody3D::set_brake(float p_brake) {
|
|||
}
|
||||
}
|
||||
|
||||
float VehicleBody3D::get_brake() const {
|
||||
real_t VehicleBody3D::get_brake() const {
|
||||
return brake;
|
||||
}
|
||||
|
||||
void VehicleBody3D::set_steering(float p_steering) {
|
||||
void VehicleBody3D::set_steering(real_t p_steering) {
|
||||
m_steeringValue = p_steering;
|
||||
for (int i = 0; i < wheels.size(); i++) {
|
||||
VehicleWheel3D &wheelInfo = *wheels[i];
|
||||
|
|
@ -927,7 +927,7 @@ void VehicleBody3D::set_steering(float p_steering) {
|
|||
}
|
||||
}
|
||||
|
||||
float VehicleBody3D::get_steering() const {
|
||||
real_t VehicleBody3D::get_steering() const {
|
||||
return m_steeringValue;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -97,29 +97,29 @@ protected:
|
|||
static void _bind_methods();
|
||||
|
||||
public:
|
||||
void set_radius(float p_radius);
|
||||
float get_radius() const;
|
||||
void set_radius(real_t p_radius);
|
||||
real_t get_radius() const;
|
||||
|
||||
void set_suspension_rest_length(float p_length);
|
||||
float get_suspension_rest_length() const;
|
||||
void set_suspension_rest_length(real_t p_length);
|
||||
real_t get_suspension_rest_length() const;
|
||||
|
||||
void set_suspension_travel(float p_length);
|
||||
float get_suspension_travel() const;
|
||||
void set_suspension_travel(real_t p_length);
|
||||
real_t get_suspension_travel() const;
|
||||
|
||||
void set_suspension_stiffness(float p_value);
|
||||
float get_suspension_stiffness() const;
|
||||
void set_suspension_stiffness(real_t p_value);
|
||||
real_t get_suspension_stiffness() const;
|
||||
|
||||
void set_suspension_max_force(float p_value);
|
||||
float get_suspension_max_force() const;
|
||||
void set_suspension_max_force(real_t p_value);
|
||||
real_t get_suspension_max_force() const;
|
||||
|
||||
void set_damping_compression(float p_value);
|
||||
float get_damping_compression() const;
|
||||
void set_damping_compression(real_t p_value);
|
||||
real_t get_damping_compression() const;
|
||||
|
||||
void set_damping_relaxation(float p_value);
|
||||
float get_damping_relaxation() const;
|
||||
void set_damping_relaxation(real_t p_value);
|
||||
real_t get_damping_relaxation() const;
|
||||
|
||||
void set_friction_slip(float p_value);
|
||||
float get_friction_slip() const;
|
||||
void set_friction_slip(real_t p_value);
|
||||
real_t get_friction_slip() const;
|
||||
|
||||
void set_use_as_traction(bool p_enable);
|
||||
bool is_used_as_traction() const;
|
||||
|
|
@ -129,21 +129,21 @@ public:
|
|||
|
||||
bool is_in_contact() const;
|
||||
|
||||
void set_roll_influence(float p_value);
|
||||
float get_roll_influence() const;
|
||||
void set_roll_influence(real_t p_value);
|
||||
real_t get_roll_influence() const;
|
||||
|
||||
float get_skidinfo() const;
|
||||
real_t get_skidinfo() const;
|
||||
|
||||
float get_rpm() const;
|
||||
real_t get_rpm() const;
|
||||
|
||||
void set_engine_force(float p_engine_force);
|
||||
float get_engine_force() const;
|
||||
void set_engine_force(real_t p_engine_force);
|
||||
real_t get_engine_force() const;
|
||||
|
||||
void set_brake(float p_brake);
|
||||
float get_brake() const;
|
||||
void set_brake(real_t p_brake);
|
||||
real_t get_brake() const;
|
||||
|
||||
void set_steering(float p_steering);
|
||||
float get_steering() const;
|
||||
void set_steering(real_t p_steering);
|
||||
real_t get_steering() const;
|
||||
|
||||
String get_configuration_warning() const override;
|
||||
|
||||
|
|
@ -153,8 +153,8 @@ public:
|
|||
class VehicleBody3D : public RigidBody3D {
|
||||
GDCLASS(VehicleBody3D, RigidBody3D);
|
||||
|
||||
float engine_force;
|
||||
float brake;
|
||||
real_t engine_force;
|
||||
real_t brake;
|
||||
|
||||
real_t m_pitchControl;
|
||||
real_t m_steeringValue;
|
||||
|
|
@ -195,14 +195,14 @@ class VehicleBody3D : public RigidBody3D {
|
|||
void _direct_state_changed(Object *p_state) override;
|
||||
|
||||
public:
|
||||
void set_engine_force(float p_engine_force);
|
||||
float get_engine_force() const;
|
||||
void set_engine_force(real_t p_engine_force);
|
||||
real_t get_engine_force() const;
|
||||
|
||||
void set_brake(float p_brake);
|
||||
float get_brake() const;
|
||||
void set_brake(real_t p_brake);
|
||||
real_t get_brake() const;
|
||||
|
||||
void set_steering(float p_steering);
|
||||
float get_steering() const;
|
||||
void set_steering(real_t p_steering);
|
||||
real_t get_steering() const;
|
||||
|
||||
VehicleBody3D();
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in a new issue