Merge pull request #12756 from Stratos695/master

Allowing double-axis lock in RigidBody & KinematicBody (Fixes #12500)

2 files changed, 106 insertions, 27 deletions

diff --git a/scene/3d/physics_body.cpp b/scene/3d/physics_body.cpp
index f2f00bb617..8c9f59e267 100644
--- a/scene/3d/physics_body.cpp
+++ b/scene/3d/physics_body.cpp
@@ -734,15 +734,31 @@ bool RigidBody::is_contact_monitor_enabled() const {
 	return contact_monitor != NULL;
 }
 
-void RigidBody::set_axis_lock(AxisLock p_lock) {
+void RigidBody::set_axis_lock_x(bool p_lock) {
+	RigidBody::locked_axis[0] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 0, locked_axis[0]);
+}
+
+void RigidBody::set_axis_lock_y(bool p_lock) {
+	RigidBody::locked_axis[1] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 1, locked_axis[1]);
+}
+
+void RigidBody::set_axis_lock_z(bool p_lock) {
+	RigidBody::locked_axis[2] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 2, locked_axis[2]);
+}
 
-	axis_lock = p_lock;
-	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), PhysicsServer::BodyAxisLock(axis_lock));
+bool RigidBody::get_axis_lock_x() const {
+	return RigidBody::locked_axis[0];
 }
 
-RigidBody::AxisLock RigidBody::get_axis_lock() const {
+bool RigidBody::get_axis_lock_y() const {
+	return RigidBody::locked_axis[1];
+}
 
-	return axis_lock;
+bool RigidBody::get_axis_lock_z() const {
+	return RigidBody::locked_axis[2];
 }
 
 Array RigidBody::get_colliding_bodies() const {
@@ -837,8 +853,12 @@ void RigidBody::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_body_enter_tree"), &RigidBody::_body_enter_tree);
 	ClassDB::bind_method(D_METHOD("_body_exit_tree"), &RigidBody::_body_exit_tree);
 
-	ClassDB::bind_method(D_METHOD("set_axis_lock", "axis_lock"), &RigidBody::set_axis_lock);
-	ClassDB::bind_method(D_METHOD("get_axis_lock"), &RigidBody::get_axis_lock);
+	ClassDB::bind_method(D_METHOD("set_axis_lock_x", "axis_lock_x"), &RigidBody::set_axis_lock_x);
+	ClassDB::bind_method(D_METHOD("set_axis_lock_y", "axis_lock_y"), &RigidBody::set_axis_lock_y);
+	ClassDB::bind_method(D_METHOD("set_axis_lock_z", "axis_lock_z"), &RigidBody::set_axis_lock_z);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_x"), &RigidBody::get_axis_lock_x);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_y"), &RigidBody::get_axis_lock_y);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_z"), &RigidBody::get_axis_lock_z);
 
 	ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidBody::get_colliding_bodies);
 
@@ -856,7 +876,10 @@ void RigidBody::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "contact_monitor"), "set_contact_monitor", "is_contact_monitor_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sleeping"), "set_sleeping", "is_sleeping");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "can_sleep"), "set_can_sleep", "is_able_to_sleep");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "axis_lock", PROPERTY_HINT_ENUM, "Disabled,Lock X,Lock Y,Lock Z"), "set_axis_lock", "get_axis_lock");
+	ADD_GROUP("Axis Lock", "axis_lock_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_x"), "set_axis_lock_x", "get_axis_lock_x");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_y"), "set_axis_lock_y", "get_axis_lock_y");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_z"), "set_axis_lock_z", "get_axis_lock_z");
 	ADD_GROUP("Linear", "linear_");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "linear_velocity"), "set_linear_velocity", "get_linear_velocity");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "linear_damp", PROPERTY_HINT_RANGE, "-1,128,0.01"), "set_linear_damp", "get_linear_damp");
@@ -874,11 +897,6 @@ void RigidBody::_bind_methods() {
 	BIND_ENUM_CONSTANT(MODE_STATIC);
 	BIND_ENUM_CONSTANT(MODE_CHARACTER);
 	BIND_ENUM_CONSTANT(MODE_KINEMATIC);
-
-	BIND_ENUM_CONSTANT(AXIS_LOCK_DISABLED);
-	BIND_ENUM_CONSTANT(AXIS_LOCK_X);
-	BIND_ENUM_CONSTANT(AXIS_LOCK_Y);
-	BIND_ENUM_CONSTANT(AXIS_LOCK_Z);
 }
 
 RigidBody::RigidBody() :
@@ -904,8 +922,6 @@ RigidBody::RigidBody() :
 	contact_monitor = NULL;
 	can_sleep = true;
 
-	axis_lock = AXIS_LOCK_DISABLED;
-
 	PhysicsServer::get_singleton()->body_set_force_integration_callback(get_rid(), this, "_direct_state_changed");
 }
 
@@ -952,6 +968,12 @@ bool KinematicBody::move_and_collide(const Vector3 &p_motion, Collision &r_colli
 		r_collision.local_shape = result.collision_local_shape;
 	}
 
+	for (int i = 0; i < 3; i++) {
+		if (locked_axis[i]) {
+			result.motion[i] = 0;
+		}
+	}
+
 	gt.origin += result.motion;
 	set_global_transform(gt);
 
@@ -960,9 +982,16 @@ bool KinematicBody::move_and_collide(const Vector3 &p_motion, Collision &r_colli
 
 Vector3 KinematicBody::move_and_slide(const Vector3 &p_linear_velocity, const Vector3 &p_floor_direction, float p_slope_stop_min_velocity, int p_max_slides, float p_floor_max_angle) {
 
-	Vector3 motion = (floor_velocity + p_linear_velocity) * get_physics_process_delta_time();
 	Vector3 lv = p_linear_velocity;
 
+	for (int i = 0; i < 3; i++) {
+		if (locked_axis[i]) {
+			lv[i] = 0;
+		}
+	}
+
+	Vector3 motion = (floor_velocity + lv) * get_physics_process_delta_time();
+
 	on_floor = false;
 	on_ceiling = false;
 	on_wall = false;
@@ -1008,6 +1037,12 @@ Vector3 KinematicBody::move_and_slide(const Vector3 &p_linear_velocity, const Ve
 			motion = motion.slide(n);
 			lv = lv.slide(n);
 
+			for (int i = 0; i < 3; i++) {
+				if (locked_axis[i]) {
+					lv[i] = 0;
+				}
+			}
+
 			colliders.push_back(collision);
 
 		} else {
@@ -1047,6 +1082,33 @@ bool KinematicBody::test_move(const Transform &p_from, const Vector3 &p_motion)
 	return PhysicsServer::get_singleton()->body_test_motion(get_rid(), p_from, p_motion);
 }
 
+void KinematicBody::set_axis_lock_x(bool p_lock) {
+	KinematicBody::locked_axis[0] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 0, locked_axis[0]);
+}
+
+void KinematicBody::set_axis_lock_y(bool p_lock) {
+	KinematicBody::locked_axis[1] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 1, locked_axis[1]);
+}
+
+void KinematicBody::set_axis_lock_z(bool p_lock) {
+	KinematicBody::locked_axis[2] = p_lock;
+	PhysicsServer::get_singleton()->body_set_axis_lock(get_rid(), 2, locked_axis[2]);
+}
+
+bool KinematicBody::get_axis_lock_x() const {
+	return KinematicBody::locked_axis[0];
+}
+
+bool KinematicBody::get_axis_lock_y() const {
+	return KinematicBody::locked_axis[1];
+}
+
+bool KinematicBody::get_axis_lock_z() const {
+	return KinematicBody::locked_axis[2];
+}
+
 void KinematicBody::set_safe_margin(float p_margin) {
 
 	margin = p_margin;
@@ -1095,12 +1157,24 @@ void KinematicBody::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_on_wall"), &KinematicBody::is_on_wall);
 	ClassDB::bind_method(D_METHOD("get_floor_velocity"), &KinematicBody::get_floor_velocity);
 
+	ClassDB::bind_method(D_METHOD("set_axis_lock_x", "axis_lock_x"), &KinematicBody::set_axis_lock_x);
+	ClassDB::bind_method(D_METHOD("set_axis_lock_y", "axis_lock_y"), &KinematicBody::set_axis_lock_y);
+	ClassDB::bind_method(D_METHOD("set_axis_lock_z", "axis_lock_z"), &KinematicBody::set_axis_lock_z);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_x"), &KinematicBody::get_axis_lock_x);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_y"), &KinematicBody::get_axis_lock_y);
+	ClassDB::bind_method(D_METHOD("get_axis_lock_z"), &KinematicBody::get_axis_lock_z);
+
 	ClassDB::bind_method(D_METHOD("set_safe_margin", "pixels"), &KinematicBody::set_safe_margin);
 	ClassDB::bind_method(D_METHOD("get_safe_margin"), &KinematicBody::get_safe_margin);
 
 	ClassDB::bind_method(D_METHOD("get_slide_count"), &KinematicBody::get_slide_count);
 	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &KinematicBody::_get_slide_collision);
 
+	ADD_GROUP("Axis Lock", "axis_lock_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_x"), "set_axis_lock_x", "get_axis_lock_x");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_y"), "set_axis_lock_y", "get_axis_lock_y");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "axis_lock_z"), "set_axis_lock_z", "get_axis_lock_z");
+
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin");
 }
 
diff --git a/scene/3d/physics_body.h b/scene/3d/physics_body.h
index f88b3860dc..57b120ef63 100644
--- a/scene/3d/physics_body.h
+++ b/scene/3d/physics_body.h
@@ -114,13 +114,6 @@ public:
 		MODE_KINEMATIC,
 	};
 
-	enum AxisLock {
-		AXIS_LOCK_DISABLED,
-		AXIS_LOCK_X,
-		AXIS_LOCK_Y,
-		AXIS_LOCK_Z,
-	};
-
 private:
 	bool can_sleep;
 	PhysicsDirectBodyState *state;
@@ -139,7 +132,7 @@ private:
 	bool sleeping;
 	bool ccd;
 
-	AxisLock axis_lock;
+	bool locked_axis[3] = { false, false, false };
 
 	int max_contacts_reported;
 
@@ -245,8 +238,12 @@ public:
 	void set_use_continuous_collision_detection(bool p_enable);
 	bool is_using_continuous_collision_detection() const;
 
-	void set_axis_lock(AxisLock p_lock);
-	AxisLock get_axis_lock() const;
+	void set_axis_lock_x(bool p_lock);
+	void set_axis_lock_y(bool p_lock);
+	void set_axis_lock_z(bool p_lock);
+	bool get_axis_lock_x() const;
+	bool get_axis_lock_y() const;
+	bool get_axis_lock_z() const;
 
 	Array get_colliding_bodies() const;
 
@@ -259,7 +256,6 @@ public:
 };
 
 VARIANT_ENUM_CAST(RigidBody::Mode);
-VARIANT_ENUM_CAST(RigidBody::AxisLock);
 
 class KinematicCollision;
 
@@ -281,6 +277,8 @@ public:
 	};
 
 private:
+	bool locked_axis[3] = { false, false, false };
+
 	float margin;
 
 	Vector3 floor_velocity;
@@ -303,6 +301,13 @@ public:
 	bool move_and_collide(const Vector3 &p_motion, Collision &r_collision);
 	bool test_move(const Transform &p_from, const Vector3 &p_motion);
 
+	void set_axis_lock_x(bool p_lock);
+	void set_axis_lock_y(bool p_lock);
+	void set_axis_lock_z(bool p_lock);
+	bool get_axis_lock_x() const;
+	bool get_axis_lock_y() const;
+	bool get_axis_lock_z() const;
+
 	void set_safe_margin(float p_margin);
 	float get_safe_margin() const;