Removed physics material combination mode. Added rough and absorbent parameter to material. Fixed 'change' signal connection

modules/bullet/bullet_physics_server.cpp

@@ -647,20 +647,6 @@ float BulletPhysicsServer::body_get_param(RID p_body, BodyParameter p_param) con
 	return body->get_param(p_param);
 }
 
-void BulletPhysicsServer::body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
-	ERR_FAIL_COND(!body);
-
-	body->set_combine_mode(p_param, p_mode);
-}
-
-PhysicsServer::CombineMode BulletPhysicsServer::body_get_combine_mode(RID p_body, BodyParameter p_param) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
-	ERR_FAIL_COND_V(!body, COMBINE_MODE_INHERIT);
-
-	return body->get_combine_mode(p_param);
-}
-
 void BulletPhysicsServer::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
 	RigidBodyBullet *body = rigid_body_owner.get(p_body);
 	ERR_FAIL_COND(!body);

modules/bullet/bullet_physics_server.h

@@ -213,9 +213,6 @@ public:
 	virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value);
 	virtual float body_get_param(RID p_body, BodyParameter p_param) const;
 
-	virtual void body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode);
-	virtual CombineMode body_get_combine_mode(RID p_body, BodyParameter p_param) const;
-
 	virtual void body_set_kinematic_safe_margin(RID p_body, real_t p_margin);
 	virtual real_t body_get_kinematic_safe_margin(RID p_body) const;
 

modules/bullet/rigid_body_bullet.cpp

@@ -257,8 +257,6 @@ RigidBodyBullet::RigidBodyBullet() :
 		angularDamp(0),
 		can_sleep(true),
 		omit_forces_integration(false),
-		restitution_combine_mode(PhysicsServer::COMBINE_MODE_INHERIT),
-		friction_combine_mode(PhysicsServer::COMBINE_MODE_INHERIT),
 		force_integration_callback(NULL),
 		isTransformChanged(false),
 		previousActiveState(true),
@@ -752,22 +750,6 @@ Vector3 RigidBodyBullet::get_angular_velocity() const {
 	return gVec;
 }
 
-void RigidBodyBullet::set_combine_mode(const PhysicsServer::BodyParameter p_param, const PhysicsServer::CombineMode p_mode) {
-	if (p_param == PhysicsServer::BODY_PARAM_BOUNCE) {
-		restitution_combine_mode = p_mode;
-	} else {
-		friction_combine_mode = p_mode;
-	}
-}
-
-PhysicsServer::CombineMode RigidBodyBullet::get_combine_mode(PhysicsServer::BodyParameter p_param) const {
-	if (p_param == PhysicsServer::BODY_PARAM_BOUNCE) {
-		return restitution_combine_mode;
-	} else {
-		return friction_combine_mode;
-	}
-}
-
 void RigidBodyBullet::set_transform__bullet(const btTransform &p_global_transform) {
 	if (mode == PhysicsServer::BODY_MODE_KINEMATIC) {
 		// The kinematic use MotionState class

modules/bullet/rigid_body_bullet.h

@@ -200,9 +200,6 @@ private:
 	bool can_sleep;
 	bool omit_forces_integration;
 
-	PhysicsServer::CombineMode restitution_combine_mode;
-	PhysicsServer::CombineMode friction_combine_mode;
-
 	Vector<CollisionData> collisions;
 	// these parameters are used to avoid vector resize
 	int maxCollisionsDetection;
@@ -298,12 +295,6 @@ public:
 	void set_angular_velocity(const Vector3 &p_velocity);
 	Vector3 get_angular_velocity() const;
 
-	void set_combine_mode(const PhysicsServer::BodyParameter p_param, const PhysicsServer::CombineMode p_mode);
-	PhysicsServer::CombineMode get_combine_mode(PhysicsServer::BodyParameter p_param) const;
-
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_restitution_combine_mode() const { return restitution_combine_mode; }
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_friction_combine_mode() const { return friction_combine_mode; }
-
 	virtual void set_transform__bullet(const btTransform &p_global_transform);
 	virtual const btTransform &get_transform__bullet() const;
 

modules/bullet/space_bullet.cpp

@@ -550,42 +550,12 @@ BulletPhysicsDirectSpaceState *SpaceBullet::get_direct_state() {
 
 btScalar calculateGodotCombinedRestitution(const btCollisionObject *body0, const btCollisionObject *body1) {
 
-	const PhysicsServer::CombineMode cm = static_cast<RigidBodyBullet *>(body0->getUserPointer())->get_restitution_combine_mode();
-
-	switch (cm) {
-		case PhysicsServer::COMBINE_MODE_INHERIT:
-			if (static_cast<RigidBodyBullet *>(body1->getUserPointer())->get_restitution_combine_mode() != PhysicsServer::COMBINE_MODE_INHERIT)
-				return calculateGodotCombinedRestitution(body1, body0);
-			// else use MAX [This is used when the two bodies doesn't use physical material]
-		case PhysicsServer::COMBINE_MODE_MAX:
-			return MAX(body0->getRestitution(), body1->getRestitution());
-		case PhysicsServer::COMBINE_MODE_MIN:
-			return MIN(body0->getRestitution(), body1->getRestitution());
-		case PhysicsServer::COMBINE_MODE_MULTIPLY:
-			return body0->getRestitution() * body1->getRestitution();
-		default: // Is always PhysicsServer::COMBINE_MODE_AVERAGE:
-			return (body0->getRestitution() + body1->getRestitution()) / 2;
-	}
+	return CLAMP(body0->getRestitution() + body1->getRestitution(), 0, 1);
 }
 
 btScalar calculateGodotCombinedFriction(const btCollisionObject *body0, const btCollisionObject *body1) {
 
-	const PhysicsServer::CombineMode cm = static_cast<RigidBodyBullet *>(body0->getUserPointer())->get_friction_combine_mode();
-
-	switch (cm) {
-		case PhysicsServer::COMBINE_MODE_INHERIT:
-			if (static_cast<RigidBodyBullet *>(body1->getUserPointer())->get_friction_combine_mode() != PhysicsServer::COMBINE_MODE_INHERIT)
-				return calculateGodotCombinedFriction(body1, body0);
-			// else use MULTIPLY [This is used when the two bodies doesn't use physical material]
-		case PhysicsServer::COMBINE_MODE_MULTIPLY:
-			return body0->getFriction() * body1->getFriction();
-		case PhysicsServer::COMBINE_MODE_MAX:
-			return MAX(body0->getFriction(), body1->getFriction());
-		case PhysicsServer::COMBINE_MODE_MIN:
-			return MIN(body0->getFriction(), body1->getFriction());
-		default: // Is always PhysicsServer::COMBINE_MODE_AVERAGE:
-			return (body0->getFriction() * body1->getFriction()) / 2;
-	}
+	return ABS(MIN(body0->getFriction(), body1->getFriction()));
 }
 
 void SpaceBullet::create_empty_world(bool p_create_soft_world) {

scene/2d/physics_body_2d.cpp

@@ -197,9 +197,9 @@ void StaticBody2D::set_friction(real_t p_friction) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_friction(p_friction);
-	_reload_physics_characteristics();
 }
 
 real_t StaticBody2D::get_friction() const {
@@ -223,9 +223,9 @@ void StaticBody2D::set_bounce(real_t p_bounce) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_bounce(p_bounce);
-	_reload_physics_characteristics();
 }
 
 real_t StaticBody2D::get_bounce() const {
@@ -243,7 +243,8 @@ real_t StaticBody2D::get_bounce() const {
 
 void StaticBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
 	if (physics_material_override.is_valid()) {
-		physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
+		if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))
+			physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
 	}
 
 	physics_material_override = p_physics_material_override;
@@ -295,13 +296,9 @@ void StaticBody2D::_reload_physics_characteristics() {
 	if (physics_material_override.is_null()) {
 		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, 0);
 		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1);
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, Physics2DServer::COMBINE_MODE_INHERIT);
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, Physics2DServer::COMBINE_MODE_INHERIT);
 	} else {
-		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce());
-		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->get_friction());
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, (Physics2DServer::CombineMode)physics_material_override->get_bounce_combine_mode());
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, (Physics2DServer::CombineMode)physics_material_override->get_friction_combine_mode());
+		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
 	}
 }
 
@@ -620,9 +617,9 @@ void RigidBody2D::set_friction(real_t p_friction) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_friction(p_friction);
-	_reload_physics_characteristics();
 }
 real_t RigidBody2D::get_friction() const {
 
@@ -645,9 +642,9 @@ void RigidBody2D::set_bounce(real_t p_bounce) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_bounce(p_bounce);
-	_reload_physics_characteristics();
 }
 real_t RigidBody2D::get_bounce() const {
 
@@ -664,7 +661,8 @@ real_t RigidBody2D::get_bounce() const {
 
 void RigidBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
 	if (physics_material_override.is_valid()) {
-		physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
+		if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))
+			physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
 	}
 
 	physics_material_override = p_physics_material_override;
@@ -1087,13 +1085,9 @@ void RigidBody2D::_reload_physics_characteristics() {
 	if (physics_material_override.is_null()) {
 		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, 0);
 		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1);
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, Physics2DServer::COMBINE_MODE_INHERIT);
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, Physics2DServer::COMBINE_MODE_INHERIT);
 	} else {
-		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce());
-		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->get_friction());
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, (Physics2DServer::CombineMode)physics_material_override->get_bounce_combine_mode());
-		Physics2DServer::get_singleton()->body_set_combine_mode(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, (Physics2DServer::CombineMode)physics_material_override->get_friction_combine_mode());
+		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
 	}
 }
 

scene/3d/physics_body.cpp

@@ -189,9 +189,10 @@ void StaticBody::set_friction(real_t p_friction) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
+
 	physics_material_override->set_friction(p_friction);
-	_reload_physics_characteristics();
 }
 
 real_t StaticBody::get_friction() const {
@@ -215,9 +216,9 @@ void StaticBody::set_bounce(real_t p_bounce) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_bounce(p_bounce);
-	_reload_physics_characteristics();
 }
 
 real_t StaticBody::get_bounce() const {
@@ -235,7 +236,8 @@ real_t StaticBody::get_bounce() const {
 
 void StaticBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
 	if (physics_material_override.is_valid()) {
-		physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
+		if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))
+			physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
 	}
 
 	physics_material_override = p_physics_material_override;
@@ -309,13 +311,9 @@ void StaticBody::_reload_physics_characteristics() {
 	if (physics_material_override.is_null()) {
 		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, 0);
 		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1);
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, PhysicsServer::COMBINE_MODE_INHERIT);
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, PhysicsServer::COMBINE_MODE_INHERIT);
 	} else {
-		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce());
-		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction());
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce_combine_mode());
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction_combine_mode());
+		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
 	}
 }
 
@@ -622,9 +620,9 @@ void RigidBody::set_friction(real_t p_friction) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_friction(p_friction);
-	_reload_physics_characteristics();
 }
 real_t RigidBody::get_friction() const {
 
@@ -644,9 +642,9 @@ void RigidBody::set_bounce(real_t p_bounce) {
 
 	if (physics_material_override.is_null()) {
 		physics_material_override.instance();
+		set_physics_material_override(physics_material_override);
 	}
 	physics_material_override->set_bounce(p_bounce);
-	_reload_physics_characteristics();
 }
 real_t RigidBody::get_bounce() const {
 	ERR_EXPLAIN("The method get_bounce has been deprecated and will be removed in the future, use physical material")
@@ -661,7 +659,8 @@ real_t RigidBody::get_bounce() const {
 
 void RigidBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
 	if (physics_material_override.is_valid()) {
-		physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
+		if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics"))
+			physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, this, "_reload_physics_characteristics");
 	}
 
 	physics_material_override = p_physics_material_override;
@@ -1040,13 +1039,9 @@ void RigidBody::_reload_physics_characteristics() {
 	if (physics_material_override.is_null()) {
 		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, 0);
 		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1);
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, PhysicsServer::COMBINE_MODE_INHERIT);
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, PhysicsServer::COMBINE_MODE_INHERIT);
 	} else {
-		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce());
-		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction());
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->get_bounce_combine_mode());
-		PhysicsServer::get_singleton()->body_set_combine_mode(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction_combine_mode());
+		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_BOUNCE, physics_material_override->computed_bounce());
+		PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_friction());
 	}
 }
 

scene/resources/physics_material.cpp

@@ -29,66 +29,48 @@
 /*************************************************************************/
 #include "physics_material.h"
 
-bool PhysicsMaterial::_set(const StringName &p_name, const Variant &p_value) {
-	if (p_name == "bounce") {
-		set_bounce(p_value);
-	} else if (p_name == "bounce_combine_mode") {
-		set_bounce_combine_mode(static_cast<PhysicsServer::CombineMode>(int(p_value)));
-	} else if (p_name == "friction") {
-		set_friction(p_value);
-	} else if (p_name == "friction_combine_mode") {
-		set_friction_combine_mode(static_cast<PhysicsServer::CombineMode>(int(p_value)));
-	} else {
-		return false;
-	}
+void PhysicsMaterial::_bind_methods() {
 
-	emit_changed();
-	return true;
-}
+	ClassDB::bind_method(D_METHOD("set_friction", "friction"), &PhysicsMaterial::set_friction);
+	ClassDB::bind_method(D_METHOD("get_friction"), &PhysicsMaterial::get_friction);
 
-bool PhysicsMaterial::_get(const StringName &p_name, Variant &r_ret) const {
-	if (p_name == "bounce") {
-		r_ret = bounce;
-	} else if (p_name == "bounce_combine_mode") {
-		r_ret = int(bounce_combine_mode);
-	} else if (p_name == "friction") {
-		r_ret = friction;
-	} else if (p_name == "friction_combine_mode") {
-		r_ret = int(friction_combine_mode);
-	} else {
-		return false;
-	}
+	ClassDB::bind_method(D_METHOD("set_rough", "rough"), &PhysicsMaterial::set_rough);
+	ClassDB::bind_method(D_METHOD("is_rough"), &PhysicsMaterial::is_rough);
 
-	return true;
-}
+	ClassDB::bind_method(D_METHOD("set_bounce", "bounce"), &PhysicsMaterial::set_bounce);
+	ClassDB::bind_method(D_METHOD("get_bounce"), &PhysicsMaterial::get_bounce);
 
-void PhysicsMaterial::_get_property_list(List<PropertyInfo> *p_list) const {
-	p_list->push_back(PropertyInfo(Variant::REAL, "bounce"));
-	p_list->push_back(PropertyInfo(Variant::INT, "bounce_combine_mode", PROPERTY_HINT_ENUM, "Max,Min,Multiply,Average"));
-	p_list->push_back(PropertyInfo(Variant::REAL, "friction"));
-	p_list->push_back(PropertyInfo(Variant::INT, "friction_combine_mode", PROPERTY_HINT_ENUM, "Max,Min,Multiply,Average"));
-}
+	ClassDB::bind_method(D_METHOD("set_absorbent", "absorbent"), &PhysicsMaterial::set_absorbent);
+	ClassDB::bind_method(D_METHOD("is_absorbent"), &PhysicsMaterial::is_absorbent);
 
-void PhysicsMaterial::_bind_methods() {}
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "friction"), "set_friction", "get_friction");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "rough"), "set_rough", "is_rough");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "bounce"), "set_bounce", "get_bounce");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "absorbent"), "set_absorbent", "is_absorbent");
+}
 
-void PhysicsMaterial::set_bounce(real_t p_val) {
-	bounce = p_val;
+void PhysicsMaterial::set_friction(real_t p_val) {
+	friction = p_val;
+	emit_changed();
 }
 
-void PhysicsMaterial::set_bounce_combine_mode(PhysicsServer::CombineMode p_val) {
-	bounce_combine_mode = p_val;
+void PhysicsMaterial::set_rough(bool p_val) {
+	rough = p_val;
+	emit_changed();
 }
 
-void PhysicsMaterial::set_friction(real_t p_val) {
-	friction = p_val;
+void PhysicsMaterial::set_bounce(real_t p_val) {
+	bounce = p_val;
+	emit_changed();
 }
 
-void PhysicsMaterial::set_friction_combine_mode(PhysicsServer::CombineMode p_val) {
-	friction_combine_mode = p_val;
+void PhysicsMaterial::set_absorbent(bool p_val) {
+	absorbent = p_val;
+	emit_changed();
 }
 
 PhysicsMaterial::PhysicsMaterial() :
+		friction(1),
+		rough(false),
 		bounce(0),
-		bounce_combine_mode(PhysicsServer::COMBINE_MODE_MAX),
-		friction(0),
-		friction_combine_mode(PhysicsServer::COMBINE_MODE_MULTIPLY) {}
+		absorbent(false) {}

scene/resources/physics_material.h

@@ -39,30 +39,34 @@ class PhysicsMaterial : public Resource {
 	OBJ_SAVE_TYPE(PhysicsMaterial);
 	RES_BASE_EXTENSION("PhyMat");
 
-	real_t bounce;
-	PhysicsServer::CombineMode bounce_combine_mode;
 	real_t friction;
-	PhysicsServer::CombineMode friction_combine_mode;
+	bool rough;
+	real_t bounce;
+	bool absorbent;
 
 protected:
-	bool _set(const StringName &p_name, const Variant &p_value);
-	bool _get(const StringName &p_name, Variant &r_ret) const;
-	void _get_property_list(List<PropertyInfo> *p_list) const;
-
 	static void _bind_methods();
 
 public:
+	void set_friction(real_t p_val);
+	_FORCE_INLINE_ real_t get_friction() const { return friction; }
+
+	void set_rough(bool p_val);
+	_FORCE_INLINE_ bool is_rough() const { return rough; }
+
+	_FORCE_INLINE_ real_t computed_friction() const {
+		return rough ? -friction : friction;
+	}
+
 	void set_bounce(real_t p_val);
 	_FORCE_INLINE_ real_t get_bounce() const { return bounce; }
 
-	void set_bounce_combine_mode(PhysicsServer::CombineMode p_val);
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_bounce_combine_mode() const { return bounce_combine_mode; }
-
-	void set_friction(real_t p_val);
-	_FORCE_INLINE_ real_t get_friction() const { return friction; }
+	void set_absorbent(bool p_val);
+	_FORCE_INLINE_ bool is_absorbent() const { return absorbent; }
 
-	void set_friction_combine_mode(PhysicsServer::CombineMode p_val);
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_friction_combine_mode() const { return friction_combine_mode; }
+	_FORCE_INLINE_ real_t computed_bounce() const {
+		return absorbent ? -bounce : bounce;
+	}
 
 	PhysicsMaterial();
 };

servers/physics/body_pair_sw.cpp

@@ -212,41 +212,11 @@ bool BodyPairSW::_test_ccd(real_t p_step, BodySW *p_A, int p_shape_A, const Tran
 }
 
 real_t combine_bounce(BodySW *A, BodySW *B) {
-	const PhysicsServer::CombineMode cm = A->get_bounce_combine_mode();
-
-	switch (cm) {
-		case PhysicsServer::COMBINE_MODE_INHERIT:
-			if (B->get_bounce_combine_mode() != PhysicsServer::COMBINE_MODE_INHERIT)
-				return combine_bounce(B, A);
-			// else use MAX [This is used when the two bodies doesn't use physical material]
-		case PhysicsServer::COMBINE_MODE_MAX:
-			return MAX(A->get_bounce(), B->get_bounce());
-		case PhysicsServer::COMBINE_MODE_MIN:
-			return MIN(A->get_bounce(), B->get_bounce());
-		case PhysicsServer::COMBINE_MODE_MULTIPLY:
-			return A->get_bounce() * B->get_bounce();
-		default: // Is always PhysicsServer::COMBINE_MODE_AVERAGE:
-			return (A->get_bounce() + B->get_bounce()) / 2;
-	}
+	return CLAMP(A->get_bounce() + B->get_bounce(), 0, 1);
 }
 
 real_t combine_friction(BodySW *A, BodySW *B) {
-	const PhysicsServer::CombineMode cm = A->get_friction_combine_mode();
-
-	switch (cm) {
-		case PhysicsServer::COMBINE_MODE_INHERIT:
-			if (B->get_friction_combine_mode() != PhysicsServer::COMBINE_MODE_INHERIT)
-				return combine_friction(B, A);
-			// else use Multiply [This is used when the two bodies doesn't use physical material]
-		case PhysicsServer::COMBINE_MODE_MULTIPLY:
-			return A->get_friction() * B->get_friction();
-		case PhysicsServer::COMBINE_MODE_MAX:
-			return MAX(A->get_friction(), B->get_friction());
-		case PhysicsServer::COMBINE_MODE_MIN:
-			return MIN(A->get_friction(), B->get_friction());
-		default: // Is always PhysicsServer::COMBINE_MODE_AVERAGE:
-			return (A->get_friction() + B->get_friction()) / 2;
-	}
+	return ABS(MIN(A->get_friction(), B->get_friction()));
 }
 
 bool BodyPairSW::setup(real_t p_step) {

servers/physics/body_sw.cpp

@@ -423,22 +423,6 @@ void BodySW::_compute_area_gravity_and_dampenings(const AreaSW *p_area) {
 	area_angular_damp += p_area->get_angular_damp();
 }
 
-void BodySW::set_combine_mode(PhysicsServer::BodyParameter p_param, PhysicsServer::CombineMode p_mode) {
-	if (p_param == PhysicsServer::BODY_PARAM_BOUNCE) {
-		bounce_combine_mode = p_mode;
-	} else {
-		friction_combine_mode = p_mode;
-	}
-}
-
-PhysicsServer::CombineMode BodySW::get_combine_mode(PhysicsServer::BodyParameter p_param) const {
-	if (p_param == PhysicsServer::BODY_PARAM_BOUNCE) {
-		return bounce_combine_mode;
-	} else {
-		return friction_combine_mode;
-	}
-}
-
 void BodySW::set_axis_lock(PhysicsServer::BodyAxis p_axis, bool lock) {
 	if (lock) {
 		locked_axis |= p_axis;

servers/physics/body_sw.h

@@ -49,8 +49,6 @@ class BodySW : public CollisionObjectSW {
 	real_t mass;
 	real_t bounce;
 	real_t friction;
-	PhysicsServer::CombineMode bounce_combine_mode;
-	PhysicsServer::CombineMode friction_combine_mode;
 
 	real_t linear_damp;
 	real_t angular_damp;
@@ -300,12 +298,6 @@ public:
 	_FORCE_INLINE_ Vector3 get_gravity() const { return gravity; }
 	_FORCE_INLINE_ real_t get_bounce() const { return bounce; }
 
-	void set_combine_mode(PhysicsServer::BodyParameter p_param, PhysicsServer::CombineMode p_mode);
-	PhysicsServer::CombineMode get_combine_mode(PhysicsServer::BodyParameter p_param) const;
-
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_bounce_combine_mode() const { return bounce_combine_mode; }
-	_FORCE_INLINE_ PhysicsServer::CombineMode get_friction_combine_mode() const { return friction_combine_mode; }
-
 	void set_axis_lock(PhysicsServer::BodyAxis p_axis, bool lock);
 	bool is_axis_locked(PhysicsServer::BodyAxis p_axis) const;
 

servers/physics/physics_server_sw.cpp

@@ -701,20 +701,6 @@ real_t PhysicsServerSW::body_get_param(RID p_body, BodyParameter p_param) const
 	return body->get_param(p_param);
 };
 
-void PhysicsServerSW::body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode) {
-	BodySW *body = body_owner.get(p_body);
-	ERR_FAIL_COND(!body);
-
-	body->set_combine_mode(p_param, p_mode);
-}
-
-PhysicsServer::CombineMode PhysicsServerSW::body_get_combine_mode(RID p_body, BodyParameter p_param) const {
-	BodySW *body = body_owner.get(p_body);
-	ERR_FAIL_COND_V(!body, COMBINE_MODE_INHERIT);
-
-	return body->get_combine_mode(p_param);
-}
-
 void PhysicsServerSW::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
 	BodySW *body = body_owner.get(p_body);
 	ERR_FAIL_COND(!body);

servers/physics/physics_server_sw.h

@@ -188,10 +188,6 @@ public:
 	virtual void body_set_param(RID p_body, BodyParameter p_param, real_t p_value);
 	virtual real_t body_get_param(RID p_body, BodyParameter p_param) const;
 
-	/// p_param accept only Bounce and Friction
-	virtual void body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode);
-	virtual CombineMode body_get_combine_mode(RID p_body, BodyParameter p_param) const;
-
 	virtual void body_set_kinematic_safe_margin(RID p_body, real_t p_margin);
 	virtual real_t body_get_kinematic_safe_margin(RID p_body) const;
 

servers/physics_2d/body_2d_sw.cpp

@@ -405,22 +405,6 @@ void Body2DSW::_compute_area_gravity_and_dampenings(const Area2DSW *p_area) {
 	area_angular_damp += p_area->get_angular_damp();
 }
 
-void Body2DSW::set_combine_mode(Physics2DServer::BodyParameter p_param, Physics2DServer::CombineMode p_mode) {
-	if (p_param == Physics2DServer::BODY_PARAM_BOUNCE) {
-		bounce_combine_mode = p_mode;
-	} else {
-		friction_combine_mode = p_mode;
-	}
-}
-
-Physics2DServer::CombineMode Body2DSW::get_combine_mode(Physics2DServer::BodyParameter p_param) const {
-	if (p_param == Physics2DServer::BODY_PARAM_BOUNCE) {
-		return bounce_combine_mode;
-	} else {
-		return friction_combine_mode;
-	}
-}
-
 void Body2DSW::integrate_forces(real_t p_step) {
 
 	if (mode == Physics2DServer::BODY_MODE_STATIC)

servers/physics_2d/body_2d_sw.h

@@ -54,8 +54,6 @@ class Body2DSW : public CollisionObject2DSW {
 	real_t mass;
 	real_t bounce;
 	real_t friction;
-	Physics2DServer::CombineMode bounce_combine_mode;
-	Physics2DServer::CombineMode friction_combine_mode;
 
 	real_t _inv_mass;
 	real_t _inv_inertia;
@@ -258,12 +256,6 @@ public:
 	_FORCE_INLINE_ real_t get_linear_damp() const { return linear_damp; }
 	_FORCE_INLINE_ real_t get_angular_damp() const { return angular_damp; }
 
-	void set_combine_mode(Physics2DServer::BodyParameter p_param, Physics2DServer::CombineMode p_mode);
-	Physics2DServer::CombineMode get_combine_mode(Physics2DServer::BodyParameter p_param) const;
-
-	_FORCE_INLINE_ Physics2DServer::CombineMode get_bounce_combine_mode() const { return bounce_combine_mode; }
-	_FORCE_INLINE_ Physics2DServer::CombineMode get_friction_combine_mode() const { return friction_combine_mode; }
-
 	void integrate_forces(real_t p_step);
 	void integrate_velocities(real_t p_step);
 

servers/physics_2d/body_pair_2d_sw.cpp

@@ -220,41 +220,11 @@ bool BodyPair2DSW::_test_ccd(real_t p_step, Body2DSW *p_A, int p_shape_A, const
 }
 
 real_t combine_bounce(Body2DSW *A, Body2DSW *B) {
-	const Physics2DServer::CombineMode cm = A->get_bounce_combine_mode();
-
-	switch (cm) {
-		case Physics2DServer::COMBINE_MODE_INHERIT:
-			if (B->get_bounce_combine_mode() != Physics2DServer::COMBINE_MODE_INHERIT)
-				return combine_bounce(B, A);
-			// else use MAX [This is used when the two bodies doesn't use physical material]
-		case Physics2DServer::COMBINE_MODE_MAX:
-			return MAX(A->get_bounce(), B->get_bounce());
-		case Physics2DServer::COMBINE_MODE_MIN:
-			return MIN(A->get_bounce(), B->get_bounce());
-		case Physics2DServer::COMBINE_MODE_MULTIPLY:
-			return A->get_bounce() * B->get_bounce();
-		default: // Is always Physics2DServer::COMBINE_MODE_AVERAGE:
-			return (A->get_bounce() + B->get_bounce()) / 2;
-	}
+	return CLAMP(A->get_bounce() + B->get_bounce(), 0, 1);
 }
 
 real_t combine_friction(Body2DSW *A, Body2DSW *B) {
-	const Physics2DServer::CombineMode cm = A->get_friction_combine_mode();
-
-	switch (cm) {
-		case Physics2DServer::COMBINE_MODE_INHERIT:
-			if (B->get_friction_combine_mode() != Physics2DServer::COMBINE_MODE_INHERIT)
-				return combine_friction(B, A);
-			// else use Multiply [This is used when the two bodies doesn't use physical material]
-		case Physics2DServer::COMBINE_MODE_MULTIPLY:
-			return A->get_friction() * B->get_friction();
-		case Physics2DServer::COMBINE_MODE_MAX:
-			return MAX(A->get_friction(), B->get_friction());
-		case Physics2DServer::COMBINE_MODE_MIN:
-			return MIN(A->get_friction(), B->get_friction());
-		default: // Is always Physics2DServer::COMBINE_MODE_AVERAGE:
-			return (A->get_friction() + B->get_friction()) / 2;
-	}
+	return ABS(MIN(A->get_friction(), B->get_friction()));
 }
 
 bool BodyPair2DSW::setup(real_t p_step) {

servers/physics_2d/physics_2d_server_sw.cpp

@@ -789,22 +789,6 @@ real_t Physics2DServerSW::body_get_param(RID p_body, BodyParameter p_param) cons
 	return body->get_param(p_param);
 };
 
-void Physics2DServerSW::body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode) {
-
-	Body2DSW *body = body_owner.get(p_body);
-	ERR_FAIL_COND(!body);
-
-	body->set_combine_mode(p_param, p_mode);
-}
-
-Physics2DServer::CombineMode Physics2DServerSW::body_get_combine_mode(RID p_body, BodyParameter p_param) const {
-
-	Body2DSW *body = body_owner.get(p_body);
-	ERR_FAIL_COND_V(!body, COMBINE_MODE_INHERIT);
-
-	return body->get_combine_mode(p_param);
-}
-
 void Physics2DServerSW::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
 
 	Body2DSW *body = body_owner.get(p_body);

servers/physics_2d/physics_2d_server_sw.h

@@ -200,10 +200,6 @@ public:
 	virtual void body_set_param(RID p_body, BodyParameter p_param, real_t p_value);
 	virtual real_t body_get_param(RID p_body, BodyParameter p_param) const;
 
-	/// p_param accept only Bounce and Friction
-	virtual void body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode);
-	virtual CombineMode body_get_combine_mode(RID p_body, BodyParameter p_param) const;
-
 	virtual void body_set_state(RID p_body, BodyState p_state, const Variant &p_variant);
 	virtual Variant body_get_state(RID p_body, BodyState p_state) const;
 

servers/physics_2d/physics_2d_server_wrap_mt.h

@@ -211,9 +211,6 @@ public:
 	FUNC3(body_set_param, RID, BodyParameter, real_t);
 	FUNC2RC(real_t, body_get_param, RID, BodyParameter);
 
-	FUNC3(body_set_combine_mode, RID, BodyParameter, CombineMode);
-	FUNC2RC(CombineMode, body_get_combine_mode, RID, BodyParameter);
-
 	FUNC3(body_set_state, RID, BodyState, const Variant &);
 	FUNC2RC(Variant, body_get_state, RID, BodyState);
 

servers/physics_2d_server.h

@@ -416,19 +416,6 @@ public:
 	virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value) = 0;
 	virtual float body_get_param(RID p_body, BodyParameter p_param) const = 0;
 
-	enum CombineMode {
-		COMBINE_MODE_MAX,
-		COMBINE_MODE_MIN,
-		COMBINE_MODE_MULTIPLY,
-		COMBINE_MODE_AVERAGE,
-
-		COMBINE_MODE_INHERIT /// Inherit from other body or use COMBINE_MODE_MAX (Restitution) COMBINE_MODE_MULTIPLY (Friction)
-	};
-
-	/// p_param accept only Bounce and Friction
-	virtual void body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode) = 0;
-	virtual CombineMode body_get_combine_mode(RID p_body, BodyParameter p_param) const = 0;
-
 	//state
 	enum BodyState {
 		BODY_STATE_TRANSFORM,

servers/physics_server.h

@@ -399,19 +399,6 @@ public:
 	virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value) = 0;
 	virtual float body_get_param(RID p_body, BodyParameter p_param) const = 0;
 
-	enum CombineMode {
-		COMBINE_MODE_MAX,
-		COMBINE_MODE_MIN,
-		COMBINE_MODE_MULTIPLY,
-		COMBINE_MODE_AVERAGE,
-
-		COMBINE_MODE_INHERIT /// Inherit from other body or use COMBINE_MODE_MAX (Restitution) COMBINE_MODE_MULTIPLY (Friction)
-	};
-
-	/// p_param accept only Bounce and Friction
-	virtual void body_set_combine_mode(RID p_body, BodyParameter p_param, CombineMode p_mode) = 0;
-	virtual CombineMode body_get_combine_mode(RID p_body, BodyParameter p_param) const = 0;
-
 	virtual void body_set_kinematic_safe_margin(RID p_body, real_t p_margin) = 0;
 	virtual real_t body_get_kinematic_safe_margin(RID p_body) const = 0;