Merge pull request #52681 from nekomatata/rename-rigid-body
Rename RigidBody to RigidDynamicBody and SoftBody to SoftDynamicBody
This commit is contained in:
Camille Mohr-Daurat
GitHub
commit
3581b893ed
45 changed files with 498 additions and 527 deletions
|
|
@ -170,7 +170,7 @@ TypedArray<String> CollisionPolygon3D::get_configuration_warnings() const {
|
|||
TypedArray<String> warnings = Node::get_configuration_warnings();
|
||||
|
||||
if (!Object::cast_to<CollisionObject3D>(get_parent())) {
|
||||
warnings.push_back(TTR("CollisionPolygon3D only serves to provide a collision shape to a CollisionObject3D derived node. Please only use it as a child of Area3D, StaticBody3D, RigidBody3D, CharacterBody3D, etc. to give them a shape."));
|
||||
warnings.push_back(TTR("CollisionPolygon3D only serves to provide a collision shape to a CollisionObject3D derived node. Please only use it as a child of Area3D, StaticBody3D, RigidDynamicBody3D, CharacterBody3D, etc. to give them a shape."));
|
||||
}
|
||||
|
||||
if (polygon.is_empty()) {
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ TypedArray<String> CollisionShape3D::get_configuration_warnings() const {
|
|||
TypedArray<String> warnings = Node::get_configuration_warnings();
|
||||
|
||||
if (!Object::cast_to<CollisionObject3D>(get_parent())) {
|
||||
warnings.push_back(TTR("CollisionShape3D only serves to provide a collision shape to a CollisionObject3D derived node. Please only use it as a child of Area3D, StaticBody3D, RigidBody3D, CharacterBody3D, etc. to give them a shape."));
|
||||
warnings.push_back(TTR("CollisionShape3D only serves to provide a collision shape to a CollisionObject3D derived node. Please only use it as a child of Area3D, StaticBody3D, RigidDynamicBody3D, CharacterBody3D, etc. to give them a shape."));
|
||||
}
|
||||
|
||||
if (!shape.is_valid()) {
|
||||
|
|
@ -123,10 +123,10 @@ TypedArray<String> CollisionShape3D::get_configuration_warnings() const {
|
|||
}
|
||||
|
||||
if (shape.is_valid() &&
|
||||
Object::cast_to<RigidBody3D>(get_parent()) &&
|
||||
Object::cast_to<RigidDynamicBody3D>(get_parent()) &&
|
||||
Object::cast_to<ConcavePolygonShape3D>(*shape) &&
|
||||
Object::cast_to<RigidBody3D>(get_parent())->get_mode() != RigidBody3D::MODE_STATIC) {
|
||||
warnings.push_back(TTR("ConcavePolygonShape3D doesn't support RigidBody3D in another mode than static."));
|
||||
Object::cast_to<RigidDynamicBody3D>(get_parent())->get_mode() != RigidDynamicBody3D::MODE_STATIC) {
|
||||
warnings.push_back(TTR("ConcavePolygonShape3D doesn't support RigidDynamicBody3D in another mode than static."));
|
||||
}
|
||||
|
||||
return warnings;
|
||||
|
|
|
|||
|
|
@ -364,7 +364,7 @@ AnimatableBody3D::AnimatableBody3D() :
|
|||
_update_kinematic_motion();
|
||||
}
|
||||
|
||||
void RigidBody3D::_body_enter_tree(ObjectID p_id) {
|
||||
void RigidDynamicBody3D::_body_enter_tree(ObjectID p_id) {
|
||||
Object *obj = ObjectDB::get_instance(p_id);
|
||||
Node *node = Object::cast_to<Node>(obj);
|
||||
ERR_FAIL_COND(!node);
|
||||
|
|
@ -387,7 +387,7 @@ void RigidBody3D::_body_enter_tree(ObjectID p_id) {
|
|||
contact_monitor->locked = false;
|
||||
}
|
||||
|
||||
void RigidBody3D::_body_exit_tree(ObjectID p_id) {
|
||||
void RigidDynamicBody3D::_body_exit_tree(ObjectID p_id) {
|
||||
Object *obj = ObjectDB::get_instance(p_id);
|
||||
Node *node = Object::cast_to<Node>(obj);
|
||||
ERR_FAIL_COND(!node);
|
||||
|
|
@ -408,7 +408,7 @@ void RigidBody3D::_body_exit_tree(ObjectID p_id) {
|
|||
contact_monitor->locked = false;
|
||||
}
|
||||
|
||||
void RigidBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_local_shape) {
|
||||
void RigidDynamicBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instance, int p_body_shape, int p_local_shape) {
|
||||
bool body_in = p_status == 1;
|
||||
ObjectID objid = p_instance;
|
||||
|
||||
|
|
@ -427,8 +427,8 @@ void RigidBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instan
|
|||
//E->get().rc=0;
|
||||
E->get().in_tree = node && node->is_inside_tree();
|
||||
if (node) {
|
||||
node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree), make_binds(objid));
|
||||
node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree), make_binds(objid));
|
||||
node->connect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody3D::_body_enter_tree), make_binds(objid));
|
||||
node->connect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody3D::_body_exit_tree), make_binds(objid));
|
||||
if (E->get().in_tree) {
|
||||
emit_signal(SceneStringNames::get_singleton()->body_entered, node);
|
||||
}
|
||||
|
|
@ -454,8 +454,8 @@ void RigidBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instan
|
|||
|
||||
if (E->get().shapes.is_empty()) {
|
||||
if (node) {
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody3D::_body_enter_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody3D::_body_exit_tree));
|
||||
if (in_tree) {
|
||||
emit_signal(SceneStringNames::get_singleton()->body_exited, node);
|
||||
}
|
||||
|
|
@ -469,19 +469,19 @@ void RigidBody3D::_body_inout(int p_status, const RID &p_body, ObjectID p_instan
|
|||
}
|
||||
}
|
||||
|
||||
struct _RigidBodyInOut {
|
||||
struct _RigidDynamicBodyInOut {
|
||||
RID rid;
|
||||
ObjectID id;
|
||||
int shape = 0;
|
||||
int local_shape = 0;
|
||||
};
|
||||
|
||||
void RigidBody3D::_body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state) {
|
||||
RigidBody3D *body = (RigidBody3D *)p_instance;
|
||||
void RigidDynamicBody3D::_body_state_changed_callback(void *p_instance, PhysicsDirectBodyState3D *p_state) {
|
||||
RigidDynamicBody3D *body = (RigidDynamicBody3D *)p_instance;
|
||||
body->_body_state_changed(p_state);
|
||||
}
|
||||
|
||||
void RigidBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
|
||||
void RigidDynamicBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
|
||||
set_ignore_transform_notification(true);
|
||||
set_global_transform(p_state->get_transform());
|
||||
|
||||
|
|
@ -512,9 +512,9 @@ void RigidBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
|
|||
}
|
||||
}
|
||||
|
||||
_RigidBodyInOut *toadd = (_RigidBodyInOut *)alloca(p_state->get_contact_count() * sizeof(_RigidBodyInOut));
|
||||
_RigidDynamicBodyInOut *toadd = (_RigidDynamicBodyInOut *)alloca(p_state->get_contact_count() * sizeof(_RigidDynamicBodyInOut));
|
||||
int toadd_count = 0; //state->get_contact_count();
|
||||
RigidBody3D_RemoveAction *toremove = (RigidBody3D_RemoveAction *)alloca(rc * sizeof(RigidBody3D_RemoveAction));
|
||||
RigidDynamicBody3D_RemoveAction *toremove = (RigidDynamicBody3D_RemoveAction *)alloca(rc * sizeof(RigidDynamicBody3D_RemoveAction));
|
||||
int toremove_count = 0;
|
||||
|
||||
//put the ones to add
|
||||
|
|
@ -580,7 +580,7 @@ void RigidBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
|
|||
}
|
||||
}
|
||||
|
||||
void RigidBody3D::_notification(int p_what) {
|
||||
void RigidDynamicBody3D::_notification(int p_what) {
|
||||
#ifdef TOOLS_ENABLED
|
||||
switch (p_what) {
|
||||
case NOTIFICATION_ENTER_TREE: {
|
||||
|
|
@ -598,7 +598,7 @@ void RigidBody3D::_notification(int p_what) {
|
|||
#endif
|
||||
}
|
||||
|
||||
void RigidBody3D::set_mode(Mode p_mode) {
|
||||
void RigidDynamicBody3D::set_mode(Mode p_mode) {
|
||||
mode = p_mode;
|
||||
switch (p_mode) {
|
||||
case MODE_DYNAMIC: {
|
||||
|
|
@ -617,21 +617,21 @@ void RigidBody3D::set_mode(Mode p_mode) {
|
|||
update_configuration_warnings();
|
||||
}
|
||||
|
||||
RigidBody3D::Mode RigidBody3D::get_mode() const {
|
||||
RigidDynamicBody3D::Mode RigidDynamicBody3D::get_mode() const {
|
||||
return mode;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_mass(real_t p_mass) {
|
||||
void RigidDynamicBody3D::set_mass(real_t p_mass) {
|
||||
ERR_FAIL_COND(p_mass <= 0);
|
||||
mass = p_mass;
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_MASS, mass);
|
||||
}
|
||||
|
||||
real_t RigidBody3D::get_mass() const {
|
||||
real_t RigidDynamicBody3D::get_mass() const {
|
||||
return mass;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_inertia(const Vector3 &p_inertia) {
|
||||
void RigidDynamicBody3D::set_inertia(const Vector3 &p_inertia) {
|
||||
ERR_FAIL_COND(p_inertia.x < 0);
|
||||
ERR_FAIL_COND(p_inertia.y < 0);
|
||||
ERR_FAIL_COND(p_inertia.z < 0);
|
||||
|
|
@ -640,11 +640,11 @@ void RigidBody3D::set_inertia(const Vector3 &p_inertia) {
|
|||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_INERTIA, inertia);
|
||||
}
|
||||
|
||||
const Vector3 &RigidBody3D::get_inertia() const {
|
||||
const Vector3 &RigidDynamicBody3D::get_inertia() const {
|
||||
return inertia;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_center_of_mass_mode(CenterOfMassMode p_mode) {
|
||||
void RigidDynamicBody3D::set_center_of_mass_mode(CenterOfMassMode p_mode) {
|
||||
if (center_of_mass_mode == p_mode) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -666,11 +666,11 @@ void RigidBody3D::set_center_of_mass_mode(CenterOfMassMode p_mode) {
|
|||
}
|
||||
}
|
||||
|
||||
RigidBody3D::CenterOfMassMode RigidBody3D::get_center_of_mass_mode() const {
|
||||
RigidDynamicBody3D::CenterOfMassMode RigidDynamicBody3D::get_center_of_mass_mode() const {
|
||||
return center_of_mass_mode;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_center_of_mass(const Vector3 &p_center_of_mass) {
|
||||
void RigidDynamicBody3D::set_center_of_mass(const Vector3 &p_center_of_mass) {
|
||||
if (center_of_mass == p_center_of_mass) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -681,88 +681,88 @@ void RigidBody3D::set_center_of_mass(const Vector3 &p_center_of_mass) {
|
|||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_CENTER_OF_MASS, center_of_mass);
|
||||
}
|
||||
|
||||
const Vector3 &RigidBody3D::get_center_of_mass() const {
|
||||
const Vector3 &RigidDynamicBody3D::get_center_of_mass() const {
|
||||
return center_of_mass;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
|
||||
void RigidDynamicBody3D::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
|
||||
if (physics_material_override.is_valid()) {
|
||||
if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidBody3D::_reload_physics_characteristics))) {
|
||||
physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidBody3D::_reload_physics_characteristics));
|
||||
if (physics_material_override->is_connected(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidDynamicBody3D::_reload_physics_characteristics))) {
|
||||
physics_material_override->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidDynamicBody3D::_reload_physics_characteristics));
|
||||
}
|
||||
}
|
||||
|
||||
physics_material_override = p_physics_material_override;
|
||||
|
||||
if (physics_material_override.is_valid()) {
|
||||
physics_material_override->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidBody3D::_reload_physics_characteristics));
|
||||
physics_material_override->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &RigidDynamicBody3D::_reload_physics_characteristics));
|
||||
}
|
||||
_reload_physics_characteristics();
|
||||
}
|
||||
|
||||
Ref<PhysicsMaterial> RigidBody3D::get_physics_material_override() const {
|
||||
Ref<PhysicsMaterial> RigidDynamicBody3D::get_physics_material_override() const {
|
||||
return physics_material_override;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_gravity_scale(real_t p_gravity_scale) {
|
||||
void RigidDynamicBody3D::set_gravity_scale(real_t p_gravity_scale) {
|
||||
gravity_scale = p_gravity_scale;
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_GRAVITY_SCALE, gravity_scale);
|
||||
}
|
||||
|
||||
real_t RigidBody3D::get_gravity_scale() const {
|
||||
real_t RigidDynamicBody3D::get_gravity_scale() const {
|
||||
return gravity_scale;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_linear_damp(real_t p_linear_damp) {
|
||||
void RigidDynamicBody3D::set_linear_damp(real_t p_linear_damp) {
|
||||
ERR_FAIL_COND(p_linear_damp < -1);
|
||||
linear_damp = p_linear_damp;
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_LINEAR_DAMP, linear_damp);
|
||||
}
|
||||
|
||||
real_t RigidBody3D::get_linear_damp() const {
|
||||
real_t RigidDynamicBody3D::get_linear_damp() const {
|
||||
return linear_damp;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_angular_damp(real_t p_angular_damp) {
|
||||
void RigidDynamicBody3D::set_angular_damp(real_t p_angular_damp) {
|
||||
ERR_FAIL_COND(p_angular_damp < -1);
|
||||
angular_damp = p_angular_damp;
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_ANGULAR_DAMP, angular_damp);
|
||||
}
|
||||
|
||||
real_t RigidBody3D::get_angular_damp() const {
|
||||
real_t RigidDynamicBody3D::get_angular_damp() const {
|
||||
return angular_damp;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_axis_velocity(const Vector3 &p_axis) {
|
||||
void RigidDynamicBody3D::set_axis_velocity(const Vector3 &p_axis) {
|
||||
Vector3 axis = p_axis.normalized();
|
||||
linear_velocity -= axis * axis.dot(linear_velocity);
|
||||
linear_velocity += p_axis;
|
||||
PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
|
||||
}
|
||||
|
||||
void RigidBody3D::set_linear_velocity(const Vector3 &p_velocity) {
|
||||
void RigidDynamicBody3D::set_linear_velocity(const Vector3 &p_velocity) {
|
||||
linear_velocity = p_velocity;
|
||||
PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_LINEAR_VELOCITY, linear_velocity);
|
||||
}
|
||||
|
||||
Vector3 RigidBody3D::get_linear_velocity() const {
|
||||
Vector3 RigidDynamicBody3D::get_linear_velocity() const {
|
||||
return linear_velocity;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_angular_velocity(const Vector3 &p_velocity) {
|
||||
void RigidDynamicBody3D::set_angular_velocity(const Vector3 &p_velocity) {
|
||||
angular_velocity = p_velocity;
|
||||
PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_ANGULAR_VELOCITY, angular_velocity);
|
||||
}
|
||||
|
||||
Vector3 RigidBody3D::get_angular_velocity() const {
|
||||
Vector3 RigidDynamicBody3D::get_angular_velocity() const {
|
||||
return angular_velocity;
|
||||
}
|
||||
|
||||
Basis RigidBody3D::get_inverse_inertia_tensor() const {
|
||||
Basis RigidDynamicBody3D::get_inverse_inertia_tensor() const {
|
||||
return inverse_inertia_tensor;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_use_custom_integrator(bool p_enable) {
|
||||
void RigidDynamicBody3D::set_use_custom_integrator(bool p_enable) {
|
||||
if (custom_integrator == p_enable) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -771,73 +771,73 @@ void RigidBody3D::set_use_custom_integrator(bool p_enable) {
|
|||
PhysicsServer3D::get_singleton()->body_set_omit_force_integration(get_rid(), p_enable);
|
||||
}
|
||||
|
||||
bool RigidBody3D::is_using_custom_integrator() {
|
||||
bool RigidDynamicBody3D::is_using_custom_integrator() {
|
||||
return custom_integrator;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_sleeping(bool p_sleeping) {
|
||||
void RigidDynamicBody3D::set_sleeping(bool p_sleeping) {
|
||||
sleeping = p_sleeping;
|
||||
PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_SLEEPING, sleeping);
|
||||
}
|
||||
|
||||
void RigidBody3D::set_can_sleep(bool p_active) {
|
||||
void RigidDynamicBody3D::set_can_sleep(bool p_active) {
|
||||
can_sleep = p_active;
|
||||
PhysicsServer3D::get_singleton()->body_set_state(get_rid(), PhysicsServer3D::BODY_STATE_CAN_SLEEP, p_active);
|
||||
}
|
||||
|
||||
bool RigidBody3D::is_able_to_sleep() const {
|
||||
bool RigidDynamicBody3D::is_able_to_sleep() const {
|
||||
return can_sleep;
|
||||
}
|
||||
|
||||
bool RigidBody3D::is_sleeping() const {
|
||||
bool RigidDynamicBody3D::is_sleeping() const {
|
||||
return sleeping;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_max_contacts_reported(int p_amount) {
|
||||
void RigidDynamicBody3D::set_max_contacts_reported(int p_amount) {
|
||||
max_contacts_reported = p_amount;
|
||||
PhysicsServer3D::get_singleton()->body_set_max_contacts_reported(get_rid(), p_amount);
|
||||
}
|
||||
|
||||
int RigidBody3D::get_max_contacts_reported() const {
|
||||
int RigidDynamicBody3D::get_max_contacts_reported() const {
|
||||
return max_contacts_reported;
|
||||
}
|
||||
|
||||
void RigidBody3D::add_central_force(const Vector3 &p_force) {
|
||||
void RigidDynamicBody3D::add_central_force(const Vector3 &p_force) {
|
||||
PhysicsServer3D::get_singleton()->body_add_central_force(get_rid(), p_force);
|
||||
}
|
||||
|
||||
void RigidBody3D::add_force(const Vector3 &p_force, const Vector3 &p_position) {
|
||||
void RigidDynamicBody3D::add_force(const Vector3 &p_force, const Vector3 &p_position) {
|
||||
PhysicsServer3D *singleton = PhysicsServer3D::get_singleton();
|
||||
singleton->body_add_force(get_rid(), p_force, p_position);
|
||||
}
|
||||
|
||||
void RigidBody3D::add_torque(const Vector3 &p_torque) {
|
||||
void RigidDynamicBody3D::add_torque(const Vector3 &p_torque) {
|
||||
PhysicsServer3D::get_singleton()->body_add_torque(get_rid(), p_torque);
|
||||
}
|
||||
|
||||
void RigidBody3D::apply_central_impulse(const Vector3 &p_impulse) {
|
||||
void RigidDynamicBody3D::apply_central_impulse(const Vector3 &p_impulse) {
|
||||
PhysicsServer3D::get_singleton()->body_apply_central_impulse(get_rid(), p_impulse);
|
||||
}
|
||||
|
||||
void RigidBody3D::apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position) {
|
||||
void RigidDynamicBody3D::apply_impulse(const Vector3 &p_impulse, const Vector3 &p_position) {
|
||||
PhysicsServer3D *singleton = PhysicsServer3D::get_singleton();
|
||||
singleton->body_apply_impulse(get_rid(), p_impulse, p_position);
|
||||
}
|
||||
|
||||
void RigidBody3D::apply_torque_impulse(const Vector3 &p_impulse) {
|
||||
void RigidDynamicBody3D::apply_torque_impulse(const Vector3 &p_impulse) {
|
||||
PhysicsServer3D::get_singleton()->body_apply_torque_impulse(get_rid(), p_impulse);
|
||||
}
|
||||
|
||||
void RigidBody3D::set_use_continuous_collision_detection(bool p_enable) {
|
||||
void RigidDynamicBody3D::set_use_continuous_collision_detection(bool p_enable) {
|
||||
ccd = p_enable;
|
||||
PhysicsServer3D::get_singleton()->body_set_enable_continuous_collision_detection(get_rid(), p_enable);
|
||||
}
|
||||
|
||||
bool RigidBody3D::is_using_continuous_collision_detection() const {
|
||||
bool RigidDynamicBody3D::is_using_continuous_collision_detection() const {
|
||||
return ccd;
|
||||
}
|
||||
|
||||
void RigidBody3D::set_contact_monitor(bool p_enabled) {
|
||||
void RigidDynamicBody3D::set_contact_monitor(bool p_enabled) {
|
||||
if (p_enabled == is_contact_monitor_enabled()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -851,8 +851,8 @@ void RigidBody3D::set_contact_monitor(bool p_enabled) {
|
|||
Node *node = Object::cast_to<Node>(obj);
|
||||
|
||||
if (node) {
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidBody3D::_body_enter_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidBody3D::_body_exit_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_entered, callable_mp(this, &RigidDynamicBody3D::_body_enter_tree));
|
||||
node->disconnect(SceneStringNames::get_singleton()->tree_exiting, callable_mp(this, &RigidDynamicBody3D::_body_exit_tree));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -864,11 +864,11 @@ void RigidBody3D::set_contact_monitor(bool p_enabled) {
|
|||
}
|
||||
}
|
||||
|
||||
bool RigidBody3D::is_contact_monitor_enabled() const {
|
||||
bool RigidDynamicBody3D::is_contact_monitor_enabled() const {
|
||||
return contact_monitor != nullptr;
|
||||
}
|
||||
|
||||
Array RigidBody3D::get_colliding_bodies() const {
|
||||
Array RigidDynamicBody3D::get_colliding_bodies() const {
|
||||
ERR_FAIL_COND_V(!contact_monitor, Array());
|
||||
|
||||
Array ret;
|
||||
|
|
@ -886,83 +886,83 @@ Array RigidBody3D::get_colliding_bodies() const {
|
|||
return ret;
|
||||
}
|
||||
|
||||
TypedArray<String> RigidBody3D::get_configuration_warnings() const {
|
||||
TypedArray<String> RigidDynamicBody3D::get_configuration_warnings() const {
|
||||
Transform3D t = get_transform();
|
||||
|
||||
TypedArray<String> warnings = Node::get_configuration_warnings();
|
||||
|
||||
if ((get_mode() == MODE_DYNAMIC || get_mode() == MODE_DYNAMIC_LOCKED) && (ABS(t.basis.get_axis(0).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(1).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(2).length() - 1.0) > 0.05)) {
|
||||
warnings.push_back(TTR("Size changes to RigidBody3D (in dynamic modes) will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
|
||||
warnings.push_back(TTR("Size changes to RigidDynamicBody (in dynamic modes) will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
|
||||
}
|
||||
|
||||
return warnings;
|
||||
}
|
||||
|
||||
void RigidBody3D::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_mode", "mode"), &RigidBody3D::set_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_mode"), &RigidBody3D::get_mode);
|
||||
void RigidDynamicBody3D::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_mode", "mode"), &RigidDynamicBody3D::set_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_mode"), &RigidDynamicBody3D::get_mode);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_mass", "mass"), &RigidBody3D::set_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_mass"), &RigidBody3D::get_mass);
|
||||
ClassDB::bind_method(D_METHOD("set_mass", "mass"), &RigidDynamicBody3D::set_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_mass"), &RigidDynamicBody3D::get_mass);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_inertia", "inertia"), &RigidBody3D::set_inertia);
|
||||
ClassDB::bind_method(D_METHOD("get_inertia"), &RigidBody3D::get_inertia);
|
||||
ClassDB::bind_method(D_METHOD("set_inertia", "inertia"), &RigidDynamicBody3D::set_inertia);
|
||||
ClassDB::bind_method(D_METHOD("get_inertia"), &RigidDynamicBody3D::get_inertia);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_center_of_mass_mode", "mode"), &RigidBody3D::set_center_of_mass_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_center_of_mass_mode"), &RigidBody3D::get_center_of_mass_mode);
|
||||
ClassDB::bind_method(D_METHOD("set_center_of_mass_mode", "mode"), &RigidDynamicBody3D::set_center_of_mass_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_center_of_mass_mode"), &RigidDynamicBody3D::get_center_of_mass_mode);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_center_of_mass", "center_of_mass"), &RigidBody3D::set_center_of_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_center_of_mass"), &RigidBody3D::get_center_of_mass);
|
||||
ClassDB::bind_method(D_METHOD("set_center_of_mass", "center_of_mass"), &RigidDynamicBody3D::set_center_of_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_center_of_mass"), &RigidDynamicBody3D::get_center_of_mass);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidBody3D::set_physics_material_override);
|
||||
ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidBody3D::get_physics_material_override);
|
||||
ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &RigidDynamicBody3D::set_physics_material_override);
|
||||
ClassDB::bind_method(D_METHOD("get_physics_material_override"), &RigidDynamicBody3D::get_physics_material_override);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &RigidBody3D::set_linear_velocity);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_velocity"), &RigidBody3D::get_linear_velocity);
|
||||
ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &RigidDynamicBody3D::set_linear_velocity);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_velocity"), &RigidDynamicBody3D::get_linear_velocity);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &RigidBody3D::set_angular_velocity);
|
||||
ClassDB::bind_method(D_METHOD("get_angular_velocity"), &RigidBody3D::get_angular_velocity);
|
||||
ClassDB::bind_method(D_METHOD("set_angular_velocity", "angular_velocity"), &RigidDynamicBody3D::set_angular_velocity);
|
||||
ClassDB::bind_method(D_METHOD("get_angular_velocity"), &RigidDynamicBody3D::get_angular_velocity);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("get_inverse_inertia_tensor"), &RigidBody3D::get_inverse_inertia_tensor);
|
||||
ClassDB::bind_method(D_METHOD("get_inverse_inertia_tensor"), &RigidDynamicBody3D::get_inverse_inertia_tensor);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &RigidBody3D::set_gravity_scale);
|
||||
ClassDB::bind_method(D_METHOD("get_gravity_scale"), &RigidBody3D::get_gravity_scale);
|
||||
ClassDB::bind_method(D_METHOD("set_gravity_scale", "gravity_scale"), &RigidDynamicBody3D::set_gravity_scale);
|
||||
ClassDB::bind_method(D_METHOD("get_gravity_scale"), &RigidDynamicBody3D::get_gravity_scale);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &RigidBody3D::set_linear_damp);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_damp"), &RigidBody3D::get_linear_damp);
|
||||
ClassDB::bind_method(D_METHOD("set_linear_damp", "linear_damp"), &RigidDynamicBody3D::set_linear_damp);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_damp"), &RigidDynamicBody3D::get_linear_damp);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &RigidBody3D::set_angular_damp);
|
||||
ClassDB::bind_method(D_METHOD("get_angular_damp"), &RigidBody3D::get_angular_damp);
|
||||
ClassDB::bind_method(D_METHOD("set_angular_damp", "angular_damp"), &RigidDynamicBody3D::set_angular_damp);
|
||||
ClassDB::bind_method(D_METHOD("get_angular_damp"), &RigidDynamicBody3D::get_angular_damp);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_max_contacts_reported", "amount"), &RigidBody3D::set_max_contacts_reported);
|
||||
ClassDB::bind_method(D_METHOD("get_max_contacts_reported"), &RigidBody3D::get_max_contacts_reported);
|
||||
ClassDB::bind_method(D_METHOD("set_max_contacts_reported", "amount"), &RigidDynamicBody3D::set_max_contacts_reported);
|
||||
ClassDB::bind_method(D_METHOD("get_max_contacts_reported"), &RigidDynamicBody3D::get_max_contacts_reported);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &RigidBody3D::set_use_custom_integrator);
|
||||
ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &RigidBody3D::is_using_custom_integrator);
|
||||
ClassDB::bind_method(D_METHOD("set_use_custom_integrator", "enable"), &RigidDynamicBody3D::set_use_custom_integrator);
|
||||
ClassDB::bind_method(D_METHOD("is_using_custom_integrator"), &RigidDynamicBody3D::is_using_custom_integrator);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_contact_monitor", "enabled"), &RigidBody3D::set_contact_monitor);
|
||||
ClassDB::bind_method(D_METHOD("is_contact_monitor_enabled"), &RigidBody3D::is_contact_monitor_enabled);
|
||||
ClassDB::bind_method(D_METHOD("set_contact_monitor", "enabled"), &RigidDynamicBody3D::set_contact_monitor);
|
||||
ClassDB::bind_method(D_METHOD("is_contact_monitor_enabled"), &RigidDynamicBody3D::is_contact_monitor_enabled);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_use_continuous_collision_detection", "enable"), &RigidBody3D::set_use_continuous_collision_detection);
|
||||
ClassDB::bind_method(D_METHOD("is_using_continuous_collision_detection"), &RigidBody3D::is_using_continuous_collision_detection);
|
||||
ClassDB::bind_method(D_METHOD("set_use_continuous_collision_detection", "enable"), &RigidDynamicBody3D::set_use_continuous_collision_detection);
|
||||
ClassDB::bind_method(D_METHOD("is_using_continuous_collision_detection"), &RigidDynamicBody3D::is_using_continuous_collision_detection);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_axis_velocity", "axis_velocity"), &RigidBody3D::set_axis_velocity);
|
||||
ClassDB::bind_method(D_METHOD("set_axis_velocity", "axis_velocity"), &RigidDynamicBody3D::set_axis_velocity);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("add_central_force", "force"), &RigidBody3D::add_central_force);
|
||||
ClassDB::bind_method(D_METHOD("add_force", "force", "position"), &RigidBody3D::add_force, Vector3());
|
||||
ClassDB::bind_method(D_METHOD("add_torque", "torque"), &RigidBody3D::add_torque);
|
||||
ClassDB::bind_method(D_METHOD("add_central_force", "force"), &RigidDynamicBody3D::add_central_force);
|
||||
ClassDB::bind_method(D_METHOD("add_force", "force", "position"), &RigidDynamicBody3D::add_force, Vector3());
|
||||
ClassDB::bind_method(D_METHOD("add_torque", "torque"), &RigidDynamicBody3D::add_torque);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidBody3D::apply_central_impulse);
|
||||
ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &RigidBody3D::apply_impulse, Vector3());
|
||||
ClassDB::bind_method(D_METHOD("apply_torque_impulse", "impulse"), &RigidBody3D::apply_torque_impulse);
|
||||
ClassDB::bind_method(D_METHOD("apply_central_impulse", "impulse"), &RigidDynamicBody3D::apply_central_impulse);
|
||||
ClassDB::bind_method(D_METHOD("apply_impulse", "impulse", "position"), &RigidDynamicBody3D::apply_impulse, Vector3());
|
||||
ClassDB::bind_method(D_METHOD("apply_torque_impulse", "impulse"), &RigidDynamicBody3D::apply_torque_impulse);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_sleeping", "sleeping"), &RigidBody3D::set_sleeping);
|
||||
ClassDB::bind_method(D_METHOD("is_sleeping"), &RigidBody3D::is_sleeping);
|
||||
ClassDB::bind_method(D_METHOD("set_sleeping", "sleeping"), &RigidDynamicBody3D::set_sleeping);
|
||||
ClassDB::bind_method(D_METHOD("is_sleeping"), &RigidDynamicBody3D::is_sleeping);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &RigidBody3D::set_can_sleep);
|
||||
ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &RigidBody3D::is_able_to_sleep);
|
||||
ClassDB::bind_method(D_METHOD("set_can_sleep", "able_to_sleep"), &RigidDynamicBody3D::set_can_sleep);
|
||||
ClassDB::bind_method(D_METHOD("is_able_to_sleep"), &RigidDynamicBody3D::is_able_to_sleep);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidBody3D::get_colliding_bodies);
|
||||
ClassDB::bind_method(D_METHOD("get_colliding_bodies"), &RigidDynamicBody3D::get_colliding_bodies);
|
||||
|
||||
GDVIRTUAL_BIND(_integrate_forces, "state");
|
||||
|
||||
|
|
@ -1002,7 +1002,7 @@ void RigidBody3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(CENTER_OF_MASS_MODE_CUSTOM);
|
||||
}
|
||||
|
||||
void RigidBody3D::_validate_property(PropertyInfo &property) const {
|
||||
void RigidDynamicBody3D::_validate_property(PropertyInfo &property) const {
|
||||
if (center_of_mass_mode != CENTER_OF_MASS_MODE_CUSTOM) {
|
||||
if (property.name == "center_of_mass") {
|
||||
property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
|
||||
|
|
@ -1010,18 +1010,18 @@ void RigidBody3D::_validate_property(PropertyInfo &property) const {
|
|||
}
|
||||
}
|
||||
|
||||
RigidBody3D::RigidBody3D() :
|
||||
RigidDynamicBody3D::RigidDynamicBody3D() :
|
||||
PhysicsBody3D(PhysicsServer3D::BODY_MODE_DYNAMIC) {
|
||||
PhysicsServer3D::get_singleton()->body_set_state_sync_callback(get_rid(), this, _body_state_changed_callback);
|
||||
}
|
||||
|
||||
RigidBody3D::~RigidBody3D() {
|
||||
RigidDynamicBody3D::~RigidDynamicBody3D() {
|
||||
if (contact_monitor) {
|
||||
memdelete(contact_monitor);
|
||||
}
|
||||
}
|
||||
|
||||
void RigidBody3D::_reload_physics_characteristics() {
|
||||
void RigidDynamicBody3D::_reload_physics_characteristics() {
|
||||
if (physics_material_override.is_null()) {
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_BOUNCE, 0);
|
||||
PhysicsServer3D::get_singleton()->body_set_param(get_rid(), PhysicsServer3D::BODY_PARAM_FRICTION, 1);
|
||||
|
|
|
|||
|
|
@ -129,8 +129,8 @@ private:
|
|||
bool is_sync_to_physics_enabled() const;
|
||||
};
|
||||
|
||||
class RigidBody3D : public PhysicsBody3D {
|
||||
GDCLASS(RigidBody3D, PhysicsBody3D);
|
||||
class RigidDynamicBody3D : public PhysicsBody3D {
|
||||
GDCLASS(RigidDynamicBody3D, PhysicsBody3D);
|
||||
|
||||
public:
|
||||
enum Mode {
|
||||
|
|
@ -191,7 +191,7 @@ protected:
|
|||
tagged = false;
|
||||
}
|
||||
};
|
||||
struct RigidBody3D_RemoveAction {
|
||||
struct RigidDynamicBody3D_RemoveAction {
|
||||
RID rid;
|
||||
ObjectID body_id;
|
||||
ShapePair pair;
|
||||
|
|
@ -291,15 +291,15 @@ public:
|
|||
|
||||
virtual TypedArray<String> get_configuration_warnings() const override;
|
||||
|
||||
RigidBody3D();
|
||||
~RigidBody3D();
|
||||
RigidDynamicBody3D();
|
||||
~RigidDynamicBody3D();
|
||||
|
||||
private:
|
||||
void _reload_physics_characteristics();
|
||||
};
|
||||
|
||||
VARIANT_ENUM_CAST(RigidBody3D::Mode);
|
||||
VARIANT_ENUM_CAST(RigidBody3D::CenterOfMassMode);
|
||||
VARIANT_ENUM_CAST(RigidDynamicBody3D::Mode);
|
||||
VARIANT_ENUM_CAST(RigidDynamicBody3D::CenterOfMassMode);
|
||||
|
||||
class KinematicCollision3D;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*************************************************************************/
|
||||
/* soft_body_3d.cpp */
|
||||
/* soft_dynamic_body_3d.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
|
|
@ -28,13 +28,13 @@
|
|||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#include "soft_body_3d.h"
|
||||
#include "soft_dynamic_body_3d.h"
|
||||
|
||||
#include "scene/3d/physics_body_3d.h"
|
||||
|
||||
SoftBodyRenderingServerHandler::SoftBodyRenderingServerHandler() {}
|
||||
SoftDynamicBodyRenderingServerHandler::SoftDynamicBodyRenderingServerHandler() {}
|
||||
|
||||
void SoftBodyRenderingServerHandler::prepare(RID p_mesh, int p_surface) {
|
||||
void SoftDynamicBodyRenderingServerHandler::prepare(RID p_mesh, int p_surface) {
|
||||
clear();
|
||||
|
||||
ERR_FAIL_COND(!p_mesh.is_valid());
|
||||
|
|
@ -56,7 +56,7 @@ void SoftBodyRenderingServerHandler::prepare(RID p_mesh, int p_surface) {
|
|||
offset_normal = surface_offsets[RS::ARRAY_NORMAL];
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::clear() {
|
||||
void SoftDynamicBodyRenderingServerHandler::clear() {
|
||||
buffer.resize(0);
|
||||
stride = 0;
|
||||
offset_vertices = 0;
|
||||
|
|
@ -66,41 +66,41 @@ void SoftBodyRenderingServerHandler::clear() {
|
|||
mesh = RID();
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::open() {
|
||||
void SoftDynamicBodyRenderingServerHandler::open() {
|
||||
write_buffer = buffer.ptrw();
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::close() {
|
||||
void SoftDynamicBodyRenderingServerHandler::close() {
|
||||
write_buffer = nullptr;
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::commit_changes() {
|
||||
void SoftDynamicBodyRenderingServerHandler::commit_changes() {
|
||||
RS::get_singleton()->mesh_surface_update_vertex_region(mesh, surface, 0, buffer);
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::set_vertex(int p_vertex_id, const void *p_vector3) {
|
||||
void SoftDynamicBodyRenderingServerHandler::set_vertex(int p_vertex_id, const void *p_vector3) {
|
||||
memcpy(&write_buffer[p_vertex_id * stride + offset_vertices], p_vector3, sizeof(float) * 3);
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::set_normal(int p_vertex_id, const void *p_vector3) {
|
||||
void SoftDynamicBodyRenderingServerHandler::set_normal(int p_vertex_id, const void *p_vector3) {
|
||||
memcpy(&write_buffer[p_vertex_id * stride + offset_normal], p_vector3, sizeof(float) * 3);
|
||||
}
|
||||
|
||||
void SoftBodyRenderingServerHandler::set_aabb(const AABB &p_aabb) {
|
||||
void SoftDynamicBodyRenderingServerHandler::set_aabb(const AABB &p_aabb) {
|
||||
RS::get_singleton()->mesh_set_custom_aabb(mesh, p_aabb);
|
||||
}
|
||||
|
||||
SoftBody3D::PinnedPoint::PinnedPoint() {
|
||||
SoftDynamicBody3D::PinnedPoint::PinnedPoint() {
|
||||
}
|
||||
|
||||
SoftBody3D::PinnedPoint::PinnedPoint(const PinnedPoint &obj_tocopy) {
|
||||
SoftDynamicBody3D::PinnedPoint::PinnedPoint(const PinnedPoint &obj_tocopy) {
|
||||
point_index = obj_tocopy.point_index;
|
||||
spatial_attachment_path = obj_tocopy.spatial_attachment_path;
|
||||
spatial_attachment = obj_tocopy.spatial_attachment;
|
||||
offset = obj_tocopy.offset;
|
||||
}
|
||||
|
||||
SoftBody3D::PinnedPoint &SoftBody3D::PinnedPoint::operator=(const PinnedPoint &obj) {
|
||||
SoftDynamicBody3D::PinnedPoint &SoftDynamicBody3D::PinnedPoint::operator=(const PinnedPoint &obj) {
|
||||
point_index = obj.point_index;
|
||||
spatial_attachment_path = obj.spatial_attachment_path;
|
||||
spatial_attachment = obj.spatial_attachment;
|
||||
|
|
@ -108,7 +108,7 @@ SoftBody3D::PinnedPoint &SoftBody3D::PinnedPoint::operator=(const PinnedPoint &o
|
|||
return *this;
|
||||
}
|
||||
|
||||
void SoftBody3D::_update_pickable() {
|
||||
void SoftDynamicBody3D::_update_pickable() {
|
||||
if (!is_inside_tree()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -116,7 +116,7 @@ void SoftBody3D::_update_pickable() {
|
|||
PhysicsServer3D::get_singleton()->soft_body_set_ray_pickable(physics_rid, pickable);
|
||||
}
|
||||
|
||||
bool SoftBody3D::_set(const StringName &p_name, const Variant &p_value) {
|
||||
bool SoftDynamicBody3D::_set(const StringName &p_name, const Variant &p_value) {
|
||||
String name = p_name;
|
||||
String which = name.get_slicec('/', 0);
|
||||
|
||||
|
|
@ -133,7 +133,7 @@ bool SoftBody3D::_set(const StringName &p_name, const Variant &p_value) {
|
|||
return false;
|
||||
}
|
||||
|
||||
bool SoftBody3D::_get(const StringName &p_name, Variant &r_ret) const {
|
||||
bool SoftDynamicBody3D::_get(const StringName &p_name, Variant &r_ret) const {
|
||||
String name = p_name;
|
||||
String which = name.get_slicec('/', 0);
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ bool SoftBody3D::_get(const StringName &p_name, Variant &r_ret) const {
|
|||
return false;
|
||||
}
|
||||
|
||||
void SoftBody3D::_get_property_list(List<PropertyInfo> *p_list) const {
|
||||
void SoftDynamicBody3D::_get_property_list(List<PropertyInfo> *p_list) const {
|
||||
const int pinned_points_indices_size = pinned_points.size();
|
||||
|
||||
p_list->push_back(PropertyInfo(Variant::PACKED_INT32_ARRAY, "pinned_points"));
|
||||
|
|
@ -172,7 +172,7 @@ void SoftBody3D::_get_property_list(List<PropertyInfo> *p_list) const {
|
|||
}
|
||||
}
|
||||
|
||||
bool SoftBody3D::_set_property_pinned_points_indices(const Array &p_indices) {
|
||||
bool SoftDynamicBody3D::_set_property_pinned_points_indices(const Array &p_indices) {
|
||||
const int p_indices_size = p_indices.size();
|
||||
|
||||
{ // Remove the pined points on physics server that will be removed by resize
|
||||
|
|
@ -201,7 +201,7 @@ bool SoftBody3D::_set_property_pinned_points_indices(const Array &p_indices) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool SoftBody3D::_set_property_pinned_points_attachment(int p_item, const String &p_what, const Variant &p_value) {
|
||||
bool SoftDynamicBody3D::_set_property_pinned_points_attachment(int p_item, const String &p_what, const Variant &p_value) {
|
||||
if (pinned_points.size() <= p_item) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -220,7 +220,7 @@ bool SoftBody3D::_set_property_pinned_points_attachment(int p_item, const String
|
|||
return true;
|
||||
}
|
||||
|
||||
bool SoftBody3D::_get_property_pinned_points(int p_item, const String &p_what, Variant &r_ret) const {
|
||||
bool SoftDynamicBody3D::_get_property_pinned_points(int p_item, const String &p_what, Variant &r_ret) const {
|
||||
if (pinned_points.size() <= p_item) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -239,15 +239,7 @@ bool SoftBody3D::_get_property_pinned_points(int p_item, const String &p_what, V
|
|||
return true;
|
||||
}
|
||||
|
||||
void SoftBody3D::_softbody_changed() {
|
||||
prepare_physics_server();
|
||||
_reset_points_offsets();
|
||||
#ifdef TOOLS_ENABLED
|
||||
update_configuration_warnings();
|
||||
#endif
|
||||
}
|
||||
|
||||
void SoftBody3D::_notification(int p_what) {
|
||||
void SoftDynamicBody3D::_notification(int p_what) {
|
||||
switch (p_what) {
|
||||
case NOTIFICATION_ENTER_WORLD: {
|
||||
if (Engine::get_singleton()->is_editor_hint()) {
|
||||
|
|
@ -312,56 +304,56 @@ void SoftBody3D::_notification(int p_what) {
|
|||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("get_physics_rid"), &SoftBody3D::get_physics_rid);
|
||||
void SoftDynamicBody3D::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("get_physics_rid"), &SoftDynamicBody3D::get_physics_rid);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_collision_mask", "collision_mask"), &SoftBody3D::set_collision_mask);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_mask"), &SoftBody3D::get_collision_mask);
|
||||
ClassDB::bind_method(D_METHOD("set_collision_mask", "collision_mask"), &SoftDynamicBody3D::set_collision_mask);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_mask"), &SoftDynamicBody3D::get_collision_mask);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_collision_layer", "collision_layer"), &SoftBody3D::set_collision_layer);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_layer"), &SoftBody3D::get_collision_layer);
|
||||
ClassDB::bind_method(D_METHOD("set_collision_layer", "collision_layer"), &SoftDynamicBody3D::set_collision_layer);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_layer"), &SoftDynamicBody3D::get_collision_layer);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_collision_mask_value", "layer_number", "value"), &SoftBody3D::set_collision_mask_value);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &SoftBody3D::get_collision_mask_value);
|
||||
ClassDB::bind_method(D_METHOD("set_collision_mask_value", "layer_number", "value"), &SoftDynamicBody3D::set_collision_mask_value);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &SoftDynamicBody3D::get_collision_mask_value);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_collision_layer_value", "layer_number", "value"), &SoftBody3D::set_collision_layer_value);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_layer_value", "layer_number"), &SoftBody3D::get_collision_layer_value);
|
||||
ClassDB::bind_method(D_METHOD("set_collision_layer_value", "layer_number", "value"), &SoftDynamicBody3D::set_collision_layer_value);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_layer_value", "layer_number"), &SoftDynamicBody3D::get_collision_layer_value);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_parent_collision_ignore", "parent_collision_ignore"), &SoftBody3D::set_parent_collision_ignore);
|
||||
ClassDB::bind_method(D_METHOD("get_parent_collision_ignore"), &SoftBody3D::get_parent_collision_ignore);
|
||||
ClassDB::bind_method(D_METHOD("set_parent_collision_ignore", "parent_collision_ignore"), &SoftDynamicBody3D::set_parent_collision_ignore);
|
||||
ClassDB::bind_method(D_METHOD("get_parent_collision_ignore"), &SoftDynamicBody3D::get_parent_collision_ignore);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_disable_mode", "mode"), &SoftBody3D::set_disable_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_disable_mode"), &SoftBody3D::get_disable_mode);
|
||||
ClassDB::bind_method(D_METHOD("set_disable_mode", "mode"), &SoftDynamicBody3D::set_disable_mode);
|
||||
ClassDB::bind_method(D_METHOD("get_disable_mode"), &SoftDynamicBody3D::get_disable_mode);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("get_collision_exceptions"), &SoftBody3D::get_collision_exceptions);
|
||||
ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &SoftBody3D::add_collision_exception_with);
|
||||
ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &SoftBody3D::remove_collision_exception_with);
|
||||
ClassDB::bind_method(D_METHOD("get_collision_exceptions"), &SoftDynamicBody3D::get_collision_exceptions);
|
||||
ClassDB::bind_method(D_METHOD("add_collision_exception_with", "body"), &SoftDynamicBody3D::add_collision_exception_with);
|
||||
ClassDB::bind_method(D_METHOD("remove_collision_exception_with", "body"), &SoftDynamicBody3D::remove_collision_exception_with);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_simulation_precision", "simulation_precision"), &SoftBody3D::set_simulation_precision);
|
||||
ClassDB::bind_method(D_METHOD("get_simulation_precision"), &SoftBody3D::get_simulation_precision);
|
||||
ClassDB::bind_method(D_METHOD("set_simulation_precision", "simulation_precision"), &SoftDynamicBody3D::set_simulation_precision);
|
||||
ClassDB::bind_method(D_METHOD("get_simulation_precision"), &SoftDynamicBody3D::get_simulation_precision);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_total_mass", "mass"), &SoftBody3D::set_total_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_total_mass"), &SoftBody3D::get_total_mass);
|
||||
ClassDB::bind_method(D_METHOD("set_total_mass", "mass"), &SoftDynamicBody3D::set_total_mass);
|
||||
ClassDB::bind_method(D_METHOD("get_total_mass"), &SoftDynamicBody3D::get_total_mass);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_linear_stiffness", "linear_stiffness"), &SoftBody3D::set_linear_stiffness);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_stiffness"), &SoftBody3D::get_linear_stiffness);
|
||||
ClassDB::bind_method(D_METHOD("set_linear_stiffness", "linear_stiffness"), &SoftDynamicBody3D::set_linear_stiffness);
|
||||
ClassDB::bind_method(D_METHOD("get_linear_stiffness"), &SoftDynamicBody3D::get_linear_stiffness);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_pressure_coefficient", "pressure_coefficient"), &SoftBody3D::set_pressure_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_pressure_coefficient"), &SoftBody3D::get_pressure_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("set_pressure_coefficient", "pressure_coefficient"), &SoftDynamicBody3D::set_pressure_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_pressure_coefficient"), &SoftDynamicBody3D::get_pressure_coefficient);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_damping_coefficient", "damping_coefficient"), &SoftBody3D::set_damping_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_damping_coefficient"), &SoftBody3D::get_damping_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("set_damping_coefficient", "damping_coefficient"), &SoftDynamicBody3D::set_damping_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_damping_coefficient"), &SoftDynamicBody3D::get_damping_coefficient);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_drag_coefficient", "drag_coefficient"), &SoftBody3D::set_drag_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_drag_coefficient"), &SoftBody3D::get_drag_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("set_drag_coefficient", "drag_coefficient"), &SoftDynamicBody3D::set_drag_coefficient);
|
||||
ClassDB::bind_method(D_METHOD("get_drag_coefficient"), &SoftDynamicBody3D::get_drag_coefficient);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("get_point_transform", "point_index"), &SoftBody3D::get_point_transform);
|
||||
ClassDB::bind_method(D_METHOD("get_point_transform", "point_index"), &SoftDynamicBody3D::get_point_transform);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_point_pinned", "point_index", "pinned", "attachment_path"), &SoftBody3D::pin_point, DEFVAL(NodePath()));
|
||||
ClassDB::bind_method(D_METHOD("is_point_pinned", "point_index"), &SoftBody3D::is_point_pinned);
|
||||
ClassDB::bind_method(D_METHOD("set_point_pinned", "point_index", "pinned", "attachment_path"), &SoftDynamicBody3D::pin_point, DEFVAL(NodePath()));
|
||||
ClassDB::bind_method(D_METHOD("is_point_pinned", "point_index"), &SoftDynamicBody3D::is_point_pinned);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_ray_pickable", "ray_pickable"), &SoftBody3D::set_ray_pickable);
|
||||
ClassDB::bind_method(D_METHOD("is_ray_pickable"), &SoftBody3D::is_ray_pickable);
|
||||
ClassDB::bind_method(D_METHOD("set_ray_pickable", "ray_pickable"), &SoftDynamicBody3D::set_ray_pickable);
|
||||
ClassDB::bind_method(D_METHOD("is_ray_pickable"), &SoftDynamicBody3D::is_ray_pickable);
|
||||
|
||||
ADD_GROUP("Collision", "collision_");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
|
||||
|
|
@ -383,7 +375,7 @@ void SoftBody3D::_bind_methods() {
|
|||
BIND_ENUM_CONSTANT(DISABLE_MODE_KEEP_ACTIVE);
|
||||
}
|
||||
|
||||
TypedArray<String> SoftBody3D::get_configuration_warnings() const {
|
||||
TypedArray<String> SoftDynamicBody3D::get_configuration_warnings() const {
|
||||
TypedArray<String> warnings = Node::get_configuration_warnings();
|
||||
|
||||
if (get_mesh().is_null()) {
|
||||
|
|
@ -392,13 +384,13 @@ TypedArray<String> SoftBody3D::get_configuration_warnings() const {
|
|||
|
||||
Transform3D t = get_transform();
|
||||
if ((ABS(t.basis.get_axis(0).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(1).length() - 1.0) > 0.05 || ABS(t.basis.get_axis(2).length() - 1.0) > 0.05)) {
|
||||
warnings.push_back(TTR("Size changes to SoftBody3D will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
|
||||
warnings.push_back(TTR("Size changes to SoftDynamicBody3D will be overridden by the physics engine when running.\nChange the size in children collision shapes instead."));
|
||||
}
|
||||
|
||||
return warnings;
|
||||
}
|
||||
|
||||
void SoftBody3D::_update_physics_server() {
|
||||
void SoftDynamicBody3D::_update_physics_server() {
|
||||
if (!simulation_started) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -414,7 +406,7 @@ void SoftBody3D::_update_physics_server() {
|
|||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_draw_soft_mesh() {
|
||||
void SoftDynamicBody3D::_draw_soft_mesh() {
|
||||
if (get_mesh().is_null()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -437,7 +429,7 @@ void SoftBody3D::_draw_soft_mesh() {
|
|||
rendering_server_handler.commit_changes();
|
||||
}
|
||||
|
||||
void SoftBody3D::prepare_physics_server() {
|
||||
void SoftDynamicBody3D::prepare_physics_server() {
|
||||
#ifdef TOOLS_ENABLED
|
||||
if (Engine::get_singleton()->is_editor_hint()) {
|
||||
if (get_mesh().is_valid()) {
|
||||
|
|
@ -453,16 +445,16 @@ void SoftBody3D::prepare_physics_server() {
|
|||
if (get_mesh().is_valid() && (is_enabled() || (disable_mode != DISABLE_MODE_REMOVE))) {
|
||||
become_mesh_owner();
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_mesh(physics_rid, get_mesh());
|
||||
RS::get_singleton()->connect("frame_pre_draw", callable_mp(this, &SoftBody3D::_draw_soft_mesh));
|
||||
RS::get_singleton()->connect("frame_pre_draw", callable_mp(this, &SoftDynamicBody3D::_draw_soft_mesh));
|
||||
} else {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_mesh(physics_rid, nullptr);
|
||||
if (RS::get_singleton()->is_connected("frame_pre_draw", callable_mp(this, &SoftBody3D::_draw_soft_mesh))) {
|
||||
RS::get_singleton()->disconnect("frame_pre_draw", callable_mp(this, &SoftBody3D::_draw_soft_mesh));
|
||||
if (RS::get_singleton()->is_connected("frame_pre_draw", callable_mp(this, &SoftDynamicBody3D::_draw_soft_mesh))) {
|
||||
RS::get_singleton()->disconnect("frame_pre_draw", callable_mp(this, &SoftDynamicBody3D::_draw_soft_mesh));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::become_mesh_owner() {
|
||||
void SoftDynamicBody3D::become_mesh_owner() {
|
||||
if (mesh.is_null()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -475,7 +467,7 @@ void SoftBody3D::become_mesh_owner() {
|
|||
|
||||
ERR_FAIL_COND(!mesh->get_surface_count());
|
||||
|
||||
// Get current mesh array and create new mesh array with necessary flag for softbody
|
||||
// Get current mesh array and create new mesh array with necessary flag for SoftDynamicBody
|
||||
Array surface_arrays = mesh->surface_get_arrays(0);
|
||||
Array surface_blend_arrays = mesh->surface_get_blend_shape_arrays(0);
|
||||
Dictionary surface_lods = mesh->surface_get_lods(0);
|
||||
|
|
@ -496,25 +488,25 @@ void SoftBody3D::become_mesh_owner() {
|
|||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::set_collision_mask(uint32_t p_mask) {
|
||||
void SoftDynamicBody3D::set_collision_mask(uint32_t p_mask) {
|
||||
collision_mask = p_mask;
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_collision_mask(physics_rid, p_mask);
|
||||
}
|
||||
|
||||
uint32_t SoftBody3D::get_collision_mask() const {
|
||||
uint32_t SoftDynamicBody3D::get_collision_mask() const {
|
||||
return collision_mask;
|
||||
}
|
||||
|
||||
void SoftBody3D::set_collision_layer(uint32_t p_layer) {
|
||||
void SoftDynamicBody3D::set_collision_layer(uint32_t p_layer) {
|
||||
collision_layer = p_layer;
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_collision_layer(physics_rid, p_layer);
|
||||
}
|
||||
|
||||
uint32_t SoftBody3D::get_collision_layer() const {
|
||||
uint32_t SoftDynamicBody3D::get_collision_layer() const {
|
||||
return collision_layer;
|
||||
}
|
||||
|
||||
void SoftBody3D::set_collision_layer_value(int p_layer_number, bool p_value) {
|
||||
void SoftDynamicBody3D::set_collision_layer_value(int p_layer_number, bool p_value) {
|
||||
ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
uint32_t collision_layer = get_collision_layer();
|
||||
|
|
@ -526,13 +518,13 @@ void SoftBody3D::set_collision_layer_value(int p_layer_number, bool p_value) {
|
|||
set_collision_layer(collision_layer);
|
||||
}
|
||||
|
||||
bool SoftBody3D::get_collision_layer_value(int p_layer_number) const {
|
||||
bool SoftDynamicBody3D::get_collision_layer_value(int p_layer_number) const {
|
||||
ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
return get_collision_layer() & (1 << (p_layer_number - 1));
|
||||
}
|
||||
|
||||
void SoftBody3D::set_collision_mask_value(int p_layer_number, bool p_value) {
|
||||
void SoftDynamicBody3D::set_collision_mask_value(int p_layer_number, bool p_value) {
|
||||
ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
uint32_t mask = get_collision_mask();
|
||||
|
|
@ -544,13 +536,13 @@ void SoftBody3D::set_collision_mask_value(int p_layer_number, bool p_value) {
|
|||
set_collision_mask(mask);
|
||||
}
|
||||
|
||||
bool SoftBody3D::get_collision_mask_value(int p_layer_number) const {
|
||||
bool SoftDynamicBody3D::get_collision_mask_value(int p_layer_number) const {
|
||||
ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
|
||||
return get_collision_mask() & (1 << (p_layer_number - 1));
|
||||
}
|
||||
|
||||
void SoftBody3D::set_disable_mode(DisableMode p_mode) {
|
||||
void SoftDynamicBody3D::set_disable_mode(DisableMode p_mode) {
|
||||
if (disable_mode == p_mode) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -568,30 +560,30 @@ void SoftBody3D::set_disable_mode(DisableMode p_mode) {
|
|||
}
|
||||
}
|
||||
|
||||
SoftBody3D::DisableMode SoftBody3D::get_disable_mode() const {
|
||||
SoftDynamicBody3D::DisableMode SoftDynamicBody3D::get_disable_mode() const {
|
||||
return disable_mode;
|
||||
}
|
||||
|
||||
void SoftBody3D::set_parent_collision_ignore(const NodePath &p_parent_collision_ignore) {
|
||||
void SoftDynamicBody3D::set_parent_collision_ignore(const NodePath &p_parent_collision_ignore) {
|
||||
parent_collision_ignore = p_parent_collision_ignore;
|
||||
}
|
||||
|
||||
const NodePath &SoftBody3D::get_parent_collision_ignore() const {
|
||||
const NodePath &SoftDynamicBody3D::get_parent_collision_ignore() const {
|
||||
return parent_collision_ignore;
|
||||
}
|
||||
|
||||
void SoftBody3D::set_pinned_points_indices(Vector<SoftBody3D::PinnedPoint> p_pinned_points_indices) {
|
||||
void SoftDynamicBody3D::set_pinned_points_indices(Vector<SoftDynamicBody3D::PinnedPoint> p_pinned_points_indices) {
|
||||
pinned_points = p_pinned_points_indices;
|
||||
for (int i = pinned_points.size() - 1; 0 <= i; --i) {
|
||||
pin_point(p_pinned_points_indices[i].point_index, true);
|
||||
}
|
||||
}
|
||||
|
||||
Vector<SoftBody3D::PinnedPoint> SoftBody3D::get_pinned_points_indices() {
|
||||
Vector<SoftDynamicBody3D::PinnedPoint> SoftDynamicBody3D::get_pinned_points_indices() {
|
||||
return pinned_points;
|
||||
}
|
||||
|
||||
Array SoftBody3D::get_collision_exceptions() {
|
||||
Array SoftDynamicBody3D::get_collision_exceptions() {
|
||||
List<RID> exceptions;
|
||||
PhysicsServer3D::get_singleton()->soft_body_get_collision_exceptions(physics_rid, &exceptions);
|
||||
Array ret;
|
||||
|
|
@ -604,77 +596,77 @@ Array SoftBody3D::get_collision_exceptions() {
|
|||
return ret;
|
||||
}
|
||||
|
||||
void SoftBody3D::add_collision_exception_with(Node *p_node) {
|
||||
void SoftDynamicBody3D::add_collision_exception_with(Node *p_node) {
|
||||
ERR_FAIL_NULL(p_node);
|
||||
CollisionObject3D *collision_object = Object::cast_to<CollisionObject3D>(p_node);
|
||||
ERR_FAIL_COND_MSG(!collision_object, "Collision exception only works between two CollisionObject3Ds.");
|
||||
PhysicsServer3D::get_singleton()->soft_body_add_collision_exception(physics_rid, collision_object->get_rid());
|
||||
}
|
||||
|
||||
void SoftBody3D::remove_collision_exception_with(Node *p_node) {
|
||||
void SoftDynamicBody3D::remove_collision_exception_with(Node *p_node) {
|
||||
ERR_FAIL_NULL(p_node);
|
||||
CollisionObject3D *collision_object = Object::cast_to<CollisionObject3D>(p_node);
|
||||
ERR_FAIL_COND_MSG(!collision_object, "Collision exception only works between two CollisionObject3Ds.");
|
||||
PhysicsServer3D::get_singleton()->soft_body_remove_collision_exception(physics_rid, collision_object->get_rid());
|
||||
}
|
||||
|
||||
int SoftBody3D::get_simulation_precision() {
|
||||
int SoftDynamicBody3D::get_simulation_precision() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_simulation_precision(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_simulation_precision(int p_simulation_precision) {
|
||||
void SoftDynamicBody3D::set_simulation_precision(int p_simulation_precision) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_simulation_precision(physics_rid, p_simulation_precision);
|
||||
}
|
||||
|
||||
real_t SoftBody3D::get_total_mass() {
|
||||
real_t SoftDynamicBody3D::get_total_mass() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_total_mass(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_total_mass(real_t p_total_mass) {
|
||||
void SoftDynamicBody3D::set_total_mass(real_t p_total_mass) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_total_mass(physics_rid, p_total_mass);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_linear_stiffness(real_t p_linear_stiffness) {
|
||||
void SoftDynamicBody3D::set_linear_stiffness(real_t p_linear_stiffness) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_linear_stiffness(physics_rid, p_linear_stiffness);
|
||||
}
|
||||
|
||||
real_t SoftBody3D::get_linear_stiffness() {
|
||||
real_t SoftDynamicBody3D::get_linear_stiffness() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_linear_stiffness(physics_rid);
|
||||
}
|
||||
|
||||
real_t SoftBody3D::get_pressure_coefficient() {
|
||||
real_t SoftDynamicBody3D::get_pressure_coefficient() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_pressure_coefficient(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_pressure_coefficient(real_t p_pressure_coefficient) {
|
||||
void SoftDynamicBody3D::set_pressure_coefficient(real_t p_pressure_coefficient) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_pressure_coefficient(physics_rid, p_pressure_coefficient);
|
||||
}
|
||||
|
||||
real_t SoftBody3D::get_damping_coefficient() {
|
||||
real_t SoftDynamicBody3D::get_damping_coefficient() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_damping_coefficient(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_damping_coefficient(real_t p_damping_coefficient) {
|
||||
void SoftDynamicBody3D::set_damping_coefficient(real_t p_damping_coefficient) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_damping_coefficient(physics_rid, p_damping_coefficient);
|
||||
}
|
||||
|
||||
real_t SoftBody3D::get_drag_coefficient() {
|
||||
real_t SoftDynamicBody3D::get_drag_coefficient() {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_drag_coefficient(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_drag_coefficient(real_t p_drag_coefficient) {
|
||||
void SoftDynamicBody3D::set_drag_coefficient(real_t p_drag_coefficient) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_set_drag_coefficient(physics_rid, p_drag_coefficient);
|
||||
}
|
||||
|
||||
Vector3 SoftBody3D::get_point_transform(int p_point_index) {
|
||||
Vector3 SoftDynamicBody3D::get_point_transform(int p_point_index) {
|
||||
return PhysicsServer3D::get_singleton()->soft_body_get_point_global_position(physics_rid, p_point_index);
|
||||
}
|
||||
|
||||
void SoftBody3D::pin_point_toggle(int p_point_index) {
|
||||
void SoftDynamicBody3D::pin_point_toggle(int p_point_index) {
|
||||
pin_point(p_point_index, !(-1 != _has_pinned_point(p_point_index)));
|
||||
}
|
||||
|
||||
void SoftBody3D::pin_point(int p_point_index, bool pin, const NodePath &p_spatial_attachment_path) {
|
||||
void SoftDynamicBody3D::pin_point(int p_point_index, bool pin, const NodePath &p_spatial_attachment_path) {
|
||||
_pin_point_on_physics_server(p_point_index, pin);
|
||||
if (pin) {
|
||||
_add_pinned_point(p_point_index, p_spatial_attachment_path);
|
||||
|
|
@ -683,41 +675,33 @@ void SoftBody3D::pin_point(int p_point_index, bool pin, const NodePath &p_spatia
|
|||
}
|
||||
}
|
||||
|
||||
bool SoftBody3D::is_point_pinned(int p_point_index) const {
|
||||
bool SoftDynamicBody3D::is_point_pinned(int p_point_index) const {
|
||||
return -1 != _has_pinned_point(p_point_index);
|
||||
}
|
||||
|
||||
void SoftBody3D::set_ray_pickable(bool p_ray_pickable) {
|
||||
void SoftDynamicBody3D::set_ray_pickable(bool p_ray_pickable) {
|
||||
ray_pickable = p_ray_pickable;
|
||||
_update_pickable();
|
||||
}
|
||||
|
||||
bool SoftBody3D::is_ray_pickable() const {
|
||||
bool SoftDynamicBody3D::is_ray_pickable() const {
|
||||
return ray_pickable;
|
||||
}
|
||||
|
||||
SoftBody3D::SoftBody3D() :
|
||||
SoftDynamicBody3D::SoftDynamicBody3D() :
|
||||
physics_rid(PhysicsServer3D::get_singleton()->soft_body_create()) {
|
||||
PhysicsServer3D::get_singleton()->body_attach_object_instance_id(physics_rid, get_instance_id());
|
||||
}
|
||||
|
||||
SoftBody3D::~SoftBody3D() {
|
||||
SoftDynamicBody3D::~SoftDynamicBody3D() {
|
||||
PhysicsServer3D::get_singleton()->free(physics_rid);
|
||||
}
|
||||
|
||||
void SoftBody3D::reset_softbody_pin() {
|
||||
PhysicsServer3D::get_singleton()->soft_body_remove_all_pinned_points(physics_rid);
|
||||
const PinnedPoint *pps = pinned_points.ptr();
|
||||
for (int i = pinned_points.size() - 1; 0 < i; --i) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_pin_point(physics_rid, pps[i].point_index, true);
|
||||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_make_cache_dirty() {
|
||||
void SoftDynamicBody3D::_make_cache_dirty() {
|
||||
pinned_points_cache_dirty = true;
|
||||
}
|
||||
|
||||
void SoftBody3D::_update_cache_pin_points_datas() {
|
||||
void SoftDynamicBody3D::_update_cache_pin_points_datas() {
|
||||
if (!pinned_points_cache_dirty) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -730,17 +714,17 @@ void SoftBody3D::_update_cache_pin_points_datas() {
|
|||
w[i].spatial_attachment = Object::cast_to<Node3D>(get_node(w[i].spatial_attachment_path));
|
||||
}
|
||||
if (!w[i].spatial_attachment) {
|
||||
ERR_PRINT("Node3D node not defined in the pinned point, this is undefined behavior for SoftBody3D!");
|
||||
ERR_PRINT("Node3D node not defined in the pinned point, this is undefined behavior for SoftDynamicBody3D!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_pin_point_on_physics_server(int p_point_index, bool pin) {
|
||||
void SoftDynamicBody3D::_pin_point_on_physics_server(int p_point_index, bool pin) {
|
||||
PhysicsServer3D::get_singleton()->soft_body_pin_point(physics_rid, p_point_index, pin);
|
||||
}
|
||||
|
||||
void SoftBody3D::_add_pinned_point(int p_point_index, const NodePath &p_spatial_attachment_path) {
|
||||
SoftBody3D::PinnedPoint *pinned_point;
|
||||
void SoftDynamicBody3D::_add_pinned_point(int p_point_index, const NodePath &p_spatial_attachment_path) {
|
||||
SoftDynamicBody3D::PinnedPoint *pinned_point;
|
||||
if (-1 == _get_pinned_point(p_point_index, pinned_point)) {
|
||||
// Create new
|
||||
PinnedPoint pp;
|
||||
|
|
@ -765,7 +749,7 @@ void SoftBody3D::_add_pinned_point(int p_point_index, const NodePath &p_spatial_
|
|||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_reset_points_offsets() {
|
||||
void SoftDynamicBody3D::_reset_points_offsets() {
|
||||
if (!Engine::get_singleton()->is_editor_hint()) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -787,25 +771,25 @@ void SoftBody3D::_reset_points_offsets() {
|
|||
}
|
||||
}
|
||||
|
||||
void SoftBody3D::_remove_pinned_point(int p_point_index) {
|
||||
void SoftDynamicBody3D::_remove_pinned_point(int p_point_index) {
|
||||
const int id(_has_pinned_point(p_point_index));
|
||||
if (-1 != id) {
|
||||
pinned_points.remove(id);
|
||||
}
|
||||
}
|
||||
|
||||
int SoftBody3D::_get_pinned_point(int p_point_index, SoftBody3D::PinnedPoint *&r_point) const {
|
||||
int SoftDynamicBody3D::_get_pinned_point(int p_point_index, SoftDynamicBody3D::PinnedPoint *&r_point) const {
|
||||
const int id = _has_pinned_point(p_point_index);
|
||||
if (-1 == id) {
|
||||
r_point = nullptr;
|
||||
return -1;
|
||||
} else {
|
||||
r_point = const_cast<SoftBody3D::PinnedPoint *>(&pinned_points.ptr()[id]);
|
||||
r_point = const_cast<SoftDynamicBody3D::PinnedPoint *>(&pinned_points.ptr()[id]);
|
||||
return id;
|
||||
}
|
||||
}
|
||||
|
||||
int SoftBody3D::_has_pinned_point(int p_point_index) const {
|
||||
int SoftDynamicBody3D::_has_pinned_point(int p_point_index) const {
|
||||
const PinnedPoint *r = pinned_points.ptr();
|
||||
for (int i = pinned_points.size() - 1; 0 <= i; --i) {
|
||||
if (p_point_index == r[i].point_index) {
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*************************************************************************/
|
||||
/* soft_body_3d.h */
|
||||
/* soft_dynamic_body_3d.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
|
|
@ -28,16 +28,16 @@
|
|||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef SOFT_PHYSICS_BODY_H
|
||||
#define SOFT_PHYSICS_BODY_H
|
||||
#ifndef SOFT_DYNAMIC_BODY_H
|
||||
#define SOFT_DYNAMIC_BODY_H
|
||||
|
||||
#include "scene/3d/mesh_instance_3d.h"
|
||||
#include "servers/physics_server_3d.h"
|
||||
|
||||
class SoftBody3D;
|
||||
class SoftDynamicBody3D;
|
||||
|
||||
class SoftBodyRenderingServerHandler : public RenderingServerHandler {
|
||||
friend class SoftBody3D;
|
||||
class SoftDynamicBodyRenderingServerHandler : public RenderingServerHandler {
|
||||
friend class SoftDynamicBody3D;
|
||||
|
||||
RID mesh;
|
||||
int surface = 0;
|
||||
|
|
@ -49,7 +49,7 @@ class SoftBodyRenderingServerHandler : public RenderingServerHandler {
|
|||
uint8_t *write_buffer = nullptr;
|
||||
|
||||
private:
|
||||
SoftBodyRenderingServerHandler();
|
||||
SoftDynamicBodyRenderingServerHandler();
|
||||
bool is_ready() { return mesh.is_valid(); }
|
||||
void prepare(RID p_mesh_rid, int p_surface);
|
||||
void clear();
|
||||
|
|
@ -63,8 +63,8 @@ public:
|
|||
void set_aabb(const AABB &p_aabb) override;
|
||||
};
|
||||
|
||||
class SoftBody3D : public MeshInstance3D {
|
||||
GDCLASS(SoftBody3D, MeshInstance3D);
|
||||
class SoftDynamicBody3D : public MeshInstance3D {
|
||||
GDCLASS(SoftDynamicBody3D, MeshInstance3D);
|
||||
|
||||
public:
|
||||
enum DisableMode {
|
||||
|
|
@ -84,7 +84,7 @@ public:
|
|||
};
|
||||
|
||||
private:
|
||||
SoftBodyRenderingServerHandler rendering_server_handler;
|
||||
SoftDynamicBodyRenderingServerHandler rendering_server_handler;
|
||||
|
||||
RID physics_rid;
|
||||
|
||||
|
|
@ -106,8 +106,6 @@ private:
|
|||
|
||||
void _update_pickable();
|
||||
|
||||
void _softbody_changed();
|
||||
|
||||
protected:
|
||||
bool _set(const StringName &p_name, const Variant &p_value);
|
||||
bool _get(const StringName &p_name, Variant &r_ret) const;
|
||||
|
|
@ -184,12 +182,10 @@ public:
|
|||
void set_ray_pickable(bool p_ray_pickable);
|
||||
bool is_ray_pickable() const;
|
||||
|
||||
SoftBody3D();
|
||||
~SoftBody3D();
|
||||
SoftDynamicBody3D();
|
||||
~SoftDynamicBody3D();
|
||||
|
||||
private:
|
||||
void reset_softbody_pin();
|
||||
|
||||
void _make_cache_dirty();
|
||||
void _update_cache_pin_points_datas();
|
||||
|
||||
|
|
@ -202,6 +198,6 @@ private:
|
|||
int _has_pinned_point(int p_point_index) const;
|
||||
};
|
||||
|
||||
VARIANT_ENUM_CAST(SoftBody3D::DisableMode);
|
||||
VARIANT_ENUM_CAST(SoftDynamicBody3D::DisableMode);
|
||||
|
||||
#endif // SOFT_PHYSICS_BODY_H
|
||||
#endif // SOFT_DYNAMIC_BODY_H
|
||||
|
|
@ -803,7 +803,7 @@ void VehicleBody3D::_update_friction(PhysicsDirectBodyState3D *s) {
|
|||
}
|
||||
|
||||
void VehicleBody3D::_body_state_changed(PhysicsDirectBodyState3D *p_state) {
|
||||
RigidBody3D::_body_state_changed(p_state);
|
||||
RigidDynamicBody3D::_body_state_changed(p_state);
|
||||
|
||||
real_t step = p_state->get_step();
|
||||
|
||||
|
|
|
|||
|
|
@ -150,8 +150,8 @@ public:
|
|||
VehicleWheel3D();
|
||||
};
|
||||
|
||||
class VehicleBody3D : public RigidBody3D {
|
||||
GDCLASS(VehicleBody3D, RigidBody3D);
|
||||
class VehicleBody3D : public RigidDynamicBody3D {
|
||||
GDCLASS(VehicleBody3D, RigidDynamicBody3D);
|
||||
|
||||
real_t engine_force = 0.0;
|
||||
real_t brake = 0.0;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue