godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Andrea Catania 2018-07-23 16:37:07 +02:00
parent 1ad20dc2f1
commit 5e65e28eed
22 changed files with 80 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
modules/bullet/bullet_physics_server.cpp
View File

@ -647,20 +647,6 @@ float BulletPhysicsServer::body_get_param(RID p_body, BodyParameter p_param) con
return body->get_param(p_param); 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) { void BulletPhysicsServer::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
RigidBodyBullet *body = rigid_body_owner.get(p_body); RigidBodyBullet *body = rigid_body_owner.get(p_body);
ERR_FAIL_COND(!body); ERR_FAIL_COND(!body);

3
modules/bullet/bullet_physics_server.h
View File

@ -213,9 +213,6 @@ public:
virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value); 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 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 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; virtual real_t body_get_kinematic_safe_margin(RID p_body) const;

18
modules/bullet/rigid_body_bullet.cpp
View File

@ -257,8 +257,6 @@ RigidBodyBullet::RigidBodyBullet() :
angularDamp(0), angularDamp(0),
can_sleep(true), can_sleep(true),
omit_forces_integration(false), omit_forces_integration(false),
restitution_combine_mode(PhysicsServer::COMBINE_MODE_INHERIT),
friction_combine_mode(PhysicsServer::COMBINE_MODE_INHERIT),
force_integration_callback(NULL), force_integration_callback(NULL),
isTransformChanged(false), isTransformChanged(false),
previousActiveState(true), previousActiveState(true),
@ -752,22 +750,6 @@ Vector3 RigidBodyBullet::get_angular_velocity() const {
return gVec; 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) { void RigidBodyBullet::set_transform__bullet(const btTransform &p_global_transform) {
if (mode == PhysicsServer::BODY_MODE_KINEMATIC) { if (mode == PhysicsServer::BODY_MODE_KINEMATIC) {
// The kinematic use MotionState class // The kinematic use MotionState class

9
modules/bullet/rigid_body_bullet.h
View File

@ -200,9 +200,6 @@ private:
bool can_sleep; bool can_sleep;
bool omit_forces_integration; bool omit_forces_integration;
PhysicsServer::CombineMode restitution_combine_mode;
PhysicsServer::CombineMode friction_combine_mode;
Vector<CollisionData> collisions; Vector<CollisionData> collisions;
// these parameters are used to avoid vector resize // these parameters are used to avoid vector resize
int maxCollisionsDetection; int maxCollisionsDetection;
@ -298,12 +295,6 @@ public:
void set_angular_velocity(const Vector3 &p_velocity); void set_angular_velocity(const Vector3 &p_velocity);
Vector3 get_angular_velocity() const; 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 void set_transform__bullet(const btTransform &p_global_transform);
virtual const btTransform &get_transform__bullet() const; virtual const btTransform &get_transform__bullet() const;

34
modules/bullet/space_bullet.cpp
View File

@ -550,42 +550,12 @@ BulletPhysicsDirectSpaceState *SpaceBullet::get_direct_state() {
btScalar calculateGodotCombinedRestitution(const btCollisionObject *body0, const btCollisionObject *body1) { btScalar calculateGodotCombinedRestitution(const btCollisionObject *body0, const btCollisionObject *body1) {
const PhysicsServer::CombineMode cm = static_cast<RigidBodyBullet *>(body0->getUserPointer())->get_restitution_combine_mode(); return CLAMP(body0->getRestitution() + body1->getRestitution(), 0, 1);
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;
}
} }
btScalar calculateGodotCombinedFriction(const btCollisionObject *body0, const btCollisionObject *body1) { btScalar calculateGodotCombinedFriction(const btCollisionObject *body0, const btCollisionObject *body1) {
const PhysicsServer::CombineMode cm = static_cast<RigidBodyBullet *>(body0->getUserPointer())->get_friction_combine_mode(); return ABS(MIN(body0->getFriction(), body1->getFriction()));
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;
}
} }
void SpaceBullet::create_empty_world(bool p_create_soft_world) { void SpaceBullet::create_empty_world(bool p_create_soft_world) {

30
scene/2d/physics_body_2d.cpp
View File

@ -197,9 +197,9 @@ void StaticBody2D::set_friction(real_t p_friction) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_friction(p_friction); physics_material_override->set_friction(p_friction);
_reload_physics_characteristics();
} }
real_t StaticBody2D::get_friction() const { real_t StaticBody2D::get_friction() const {
@ -223,9 +223,9 @@ void StaticBody2D::set_bounce(real_t p_bounce) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_bounce(p_bounce); physics_material_override->set_bounce(p_bounce);
_reload_physics_characteristics();
} }
real_t StaticBody2D::get_bounce() const { 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) { void StaticBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
if (physics_material_override.is_valid()) { 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; physics_material_override = p_physics_material_override;
@ -295,13 +296,9 @@ void StaticBody2D::_reload_physics_characteristics() {
if (physics_material_override.is_null()) { 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_BOUNCE, 0);
Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1); 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 { } 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_BOUNCE, physics_material_override->computed_bounce());
Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->get_friction()); Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_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());
} }
} }
@ -620,9 +617,9 @@ void RigidBody2D::set_friction(real_t p_friction) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_friction(p_friction); physics_material_override->set_friction(p_friction);
_reload_physics_characteristics();
} }
real_t RigidBody2D::get_friction() const { real_t RigidBody2D::get_friction() const {
@ -645,9 +642,9 @@ void RigidBody2D::set_bounce(real_t p_bounce) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_bounce(p_bounce); physics_material_override->set_bounce(p_bounce);
_reload_physics_characteristics();
} }
real_t RigidBody2D::get_bounce() const { 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) { void RigidBody2D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
if (physics_material_override.is_valid()) { 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; physics_material_override = p_physics_material_override;
@ -1087,13 +1085,9 @@ void RigidBody2D::_reload_physics_characteristics() {
if (physics_material_override.is_null()) { 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_BOUNCE, 0);
Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, 1); 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 { } 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_BOUNCE, physics_material_override->computed_bounce());
Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->get_friction()); Physics2DServer::get_singleton()->body_set_param(get_rid(), Physics2DServer::BODY_PARAM_FRICTION, physics_material_override->computed_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());
} }
} }

31
scene/3d/physics_body.cpp
View File

@ -189,9 +189,10 @@ void StaticBody::set_friction(real_t p_friction) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_friction(p_friction); physics_material_override->set_friction(p_friction);
_reload_physics_characteristics();
} }
real_t StaticBody::get_friction() const { real_t StaticBody::get_friction() const {
@ -215,9 +216,9 @@ void StaticBody::set_bounce(real_t p_bounce) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_bounce(p_bounce); physics_material_override->set_bounce(p_bounce);
_reload_physics_characteristics();
} }
real_t StaticBody::get_bounce() const { 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) { void StaticBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
if (physics_material_override.is_valid()) { 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; physics_material_override = p_physics_material_override;
@ -309,13 +311,9 @@ void StaticBody::_reload_physics_characteristics() {
if (physics_material_override.is_null()) { 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_BOUNCE, 0);
PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1); 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 { } 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_BOUNCE, physics_material_override->computed_bounce());
PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction()); PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_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());
} }
} }
@ -622,9 +620,9 @@ void RigidBody::set_friction(real_t p_friction) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_friction(p_friction); physics_material_override->set_friction(p_friction);
_reload_physics_characteristics();
} }
real_t RigidBody::get_friction() const { real_t RigidBody::get_friction() const {
@ -644,9 +642,9 @@ void RigidBody::set_bounce(real_t p_bounce) {
if (physics_material_override.is_null()) { if (physics_material_override.is_null()) {
physics_material_override.instance(); physics_material_override.instance();
set_physics_material_override(physics_material_override);
} }
physics_material_override->set_bounce(p_bounce); physics_material_override->set_bounce(p_bounce);
_reload_physics_characteristics();
} }
real_t RigidBody::get_bounce() const { 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") 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) { void RigidBody::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
if (physics_material_override.is_valid()) { 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; physics_material_override = p_physics_material_override;
@ -1040,13 +1039,9 @@ void RigidBody::_reload_physics_characteristics() {
if (physics_material_override.is_null()) { 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_BOUNCE, 0);
PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, 1); 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 { } 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_BOUNCE, physics_material_override->computed_bounce());
PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->get_friction()); PhysicsServer::get_singleton()->body_set_param(get_rid(), PhysicsServer::BODY_PARAM_FRICTION, physics_material_override->computed_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());
} }
} }

78
scene/resources/physics_material.cpp
View File

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

34
scene/resources/physics_material.h
View File

@ -39,30 +39,34 @@ class PhysicsMaterial : public Resource {
OBJ_SAVE_TYPE(PhysicsMaterial); OBJ_SAVE_TYPE(PhysicsMaterial);
RES_BASE_EXTENSION("PhyMat"); RES_BASE_EXTENSION("PhyMat");
real_t bounce;
PhysicsServer::CombineMode bounce_combine_mode;
real_t friction; real_t friction;
PhysicsServer::CombineMode friction_combine_mode; bool rough;
real_t bounce;
bool absorbent;
protected: 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(); static void _bind_methods();
public: public:
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); void set_friction(real_t p_val);
_FORCE_INLINE_ real_t get_friction() const { return friction; } _FORCE_INLINE_ real_t get_friction() const { return friction; }
void set_friction_combine_mode(PhysicsServer::CombineMode p_val); void set_rough(bool p_val);
_FORCE_INLINE_ PhysicsServer::CombineMode get_friction_combine_mode() const { return friction_combine_mode; } _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_absorbent(bool p_val);
_FORCE_INLINE_ bool is_absorbent() const { return absorbent; }
_FORCE_INLINE_ real_t computed_bounce() const {
return absorbent ? -bounce : bounce;
}
PhysicsMaterial(); PhysicsMaterial();
}; };

34
servers/physics/body_pair_sw.cpp
View File

@ -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) { real_t combine_bounce(BodySW *A, BodySW *B) {
const PhysicsServer::CombineMode cm = A->get_bounce_combine_mode(); return CLAMP(A->get_bounce() + B->get_bounce(), 0, 1);
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;
}
} }
real_t combine_friction(BodySW *A, BodySW *B) { real_t combine_friction(BodySW *A, BodySW *B) {
const PhysicsServer::CombineMode cm = A->get_friction_combine_mode(); return ABS(MIN(A->get_friction(), B->get_friction()));
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;
}
} }
bool BodyPairSW::setup(real_t p_step) { bool BodyPairSW::setup(real_t p_step) {

16
servers/physics/body_sw.cpp
View File

@ -423,22 +423,6 @@ void BodySW::_compute_area_gravity_and_dampenings(const AreaSW *p_area) {
area_angular_damp += p_area->get_angular_damp(); 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) { void BodySW::set_axis_lock(PhysicsServer::BodyAxis p_axis, bool lock) {
if (lock) { if (lock) {
locked_axis |= p_axis; locked_axis |= p_axis;

8
servers/physics/body_sw.h
View File

@ -49,8 +49,6 @@ class BodySW : public CollisionObjectSW {
real_t mass; real_t mass;
real_t bounce; real_t bounce;
real_t friction; real_t friction;
PhysicsServer::CombineMode bounce_combine_mode;
PhysicsServer::CombineMode friction_combine_mode;
real_t linear_damp; real_t linear_damp;
real_t angular_damp; real_t angular_damp;
@ -300,12 +298,6 @@ public:
_FORCE_INLINE_ Vector3 get_gravity() const { return gravity; } _FORCE_INLINE_ Vector3 get_gravity() const { return gravity; }
_FORCE_INLINE_ real_t get_bounce() const { return bounce; } _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); void set_axis_lock(PhysicsServer::BodyAxis p_axis, bool lock);
bool is_axis_locked(PhysicsServer::BodyAxis p_axis) const; bool is_axis_locked(PhysicsServer::BodyAxis p_axis) const;

14
servers/physics/physics_server_sw.cpp
View File

@ -701,20 +701,6 @@ real_t PhysicsServerSW::body_get_param(RID p_body, BodyParameter p_param) const
return body->get_param(p_param); 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) { void PhysicsServerSW::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
BodySW *body = body_owner.get(p_body); BodySW *body = body_owner.get(p_body);
ERR_FAIL_COND(!body); ERR_FAIL_COND(!body);

4
servers/physics/physics_server_sw.h
View File

@ -188,10 +188,6 @@ public:
virtual void body_set_param(RID p_body, BodyParameter p_param, real_t p_value); 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; 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 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; virtual real_t body_get_kinematic_safe_margin(RID p_body) const;

16
servers/physics_2d/body_2d_sw.cpp
View File

@ -405,22 +405,6 @@ void Body2DSW::_compute_area_gravity_and_dampenings(const Area2DSW *p_area) {
area_angular_damp += p_area->get_angular_damp(); 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) { void Body2DSW::integrate_forces(real_t p_step) {
if (mode == Physics2DServer::BODY_MODE_STATIC) if (mode == Physics2DServer::BODY_MODE_STATIC)

8
servers/physics_2d/body_2d_sw.h
View File

@ -54,8 +54,6 @@ class Body2DSW : public CollisionObject2DSW {
real_t mass; real_t mass;
real_t bounce; real_t bounce;
real_t friction; real_t friction;
Physics2DServer::CombineMode bounce_combine_mode;
Physics2DServer::CombineMode friction_combine_mode;
real_t _inv_mass; real_t _inv_mass;
real_t _inv_inertia; 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_linear_damp() const { return linear_damp; }
_FORCE_INLINE_ real_t get_angular_damp() const { return angular_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_forces(real_t p_step);
void integrate_velocities(real_t p_step); void integrate_velocities(real_t p_step);

34
servers/physics_2d/body_pair_2d_sw.cpp
View File

@ -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) { real_t combine_bounce(Body2DSW *A, Body2DSW *B) {
const Physics2DServer::CombineMode cm = A->get_bounce_combine_mode(); return CLAMP(A->get_bounce() + B->get_bounce(), 0, 1);
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;
}
} }
real_t combine_friction(Body2DSW *A, Body2DSW *B) { real_t combine_friction(Body2DSW *A, Body2DSW *B) {
const Physics2DServer::CombineMode cm = A->get_friction_combine_mode(); return ABS(MIN(A->get_friction(), B->get_friction()));
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;
}
} }
bool BodyPair2DSW::setup(real_t p_step) { bool BodyPair2DSW::setup(real_t p_step) {

16
servers/physics_2d/physics_2d_server_sw.cpp
View File

@ -789,22 +789,6 @@ real_t Physics2DServerSW::body_get_param(RID p_body, BodyParameter p_param) cons
return body->get_param(p_param); 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) { void Physics2DServerSW::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
Body2DSW *body = body_owner.get(p_body); Body2DSW *body = body_owner.get(p_body);

4
servers/physics_2d/physics_2d_server_sw.h
View File

@ -200,10 +200,6 @@ public:
virtual void body_set_param(RID p_body, BodyParameter p_param, real_t p_value); 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; 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 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; virtual Variant body_get_state(RID p_body, BodyState p_state) const;

3
servers/physics_2d/physics_2d_server_wrap_mt.h
View File

@ -211,9 +211,6 @@ public:
FUNC3(body_set_param, RID, BodyParameter, real_t); FUNC3(body_set_param, RID, BodyParameter, real_t);
FUNC2RC(real_t, body_get_param, RID, BodyParameter); 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 &); FUNC3(body_set_state, RID, BodyState, const Variant &);
FUNC2RC(Variant, body_get_state, RID, BodyState); FUNC2RC(Variant, body_get_state, RID, BodyState);

13
servers/physics_2d_server.h
View File

@ -416,19 +416,6 @@ public:
virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value) = 0; 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; 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 //state
enum BodyState { enum BodyState {
BODY_STATE_TRANSFORM, BODY_STATE_TRANSFORM,

13
servers/physics_server.h
View File

@ -399,19 +399,6 @@ public:
virtual void body_set_param(RID p_body, BodyParameter p_param, float p_value) = 0; 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; 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 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; virtual real_t body_get_kinematic_safe_margin(RID p_body) const = 0;