Rename RID's `getornull()` to `get_or_null()`

2 files changed, 193 insertions, 193 deletions

diff --git a/servers/physics_3d/physics_server_3d_sw.cpp b/servers/physics_3d/physics_server_3d_sw.cpp
index 8fbb0ba477..ece1fe46e7 100644
--- a/servers/physics_3d/physics_server_3d_sw.cpp
+++ b/servers/physics_3d/physics_server_3d_sw.cpp
@@ -102,25 +102,25 @@ RID PhysicsServer3DSW::custom_shape_create() {
 }
 
 void PhysicsServer3DSW::shape_set_data(RID p_shape, const Variant &p_data) {
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_data(p_data);
 };
 
 void PhysicsServer3DSW::shape_set_custom_solver_bias(RID p_shape, real_t p_bias) {
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_custom_bias(p_bias);
 }
 
 PhysicsServer3D::ShapeType PhysicsServer3DSW::shape_get_type(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, SHAPE_CUSTOM);
 	return shape->get_type();
 };
 
 Variant PhysicsServer3DSW::shape_get_data(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, Variant());
 	ERR_FAIL_COND_V(!shape->is_configured(), Variant());
 	return shape->get_data();
@@ -134,7 +134,7 @@ real_t PhysicsServer3DSW::shape_get_margin(RID p_shape) const {
 }
 
 real_t PhysicsServer3DSW::shape_get_custom_solver_bias(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 	return shape->get_custom_bias();
 }
@@ -144,7 +144,7 @@ RID PhysicsServer3DSW::space_create() {
 	RID id = space_owner.make_rid(space);
 	space->set_self(id);
 	RID area_id = area_create();
-	Area3DSW *area = area_owner.getornull(area_id);
+	Area3DSW *area = area_owner.get_or_null(area_id);
 	ERR_FAIL_COND_V(!area, RID());
 	space->set_default_area(area);
 	area->set_space(space);
@@ -158,7 +158,7 @@ RID PhysicsServer3DSW::space_create() {
 };
 
 void PhysicsServer3DSW::space_set_active(RID p_space, bool p_active) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	if (p_active) {
 		active_spaces.insert(space);
@@ -168,27 +168,27 @@ void PhysicsServer3DSW::space_set_active(RID p_space, bool p_active) {
 }
 
 bool PhysicsServer3DSW::space_is_active(RID p_space) const {
-	const Space3DSW *space = space_owner.getornull(p_space);
+	const Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, false);
 
 	return active_spaces.has(space);
 }
 
 void PhysicsServer3DSW::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 
 	space->set_param(p_param, p_value);
 }
 
 real_t PhysicsServer3DSW::space_get_param(RID p_space, SpaceParameter p_param) const {
-	const Space3DSW *space = space_owner.getornull(p_space);
+	const Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_param(p_param);
 }
 
 PhysicsDirectSpaceState3D *PhysicsServer3DSW::space_get_direct_state(RID p_space) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, nullptr);
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync) || space->is_locked(), nullptr, "Space state is inaccessible right now, wait for iteration or physics process notification.");
 
@@ -196,19 +196,19 @@ PhysicsDirectSpaceState3D *PhysicsServer3DSW::space_get_direct_state(RID p_space
 }
 
 void PhysicsServer3DSW::space_set_debug_contacts(RID p_space, int p_max_contacts) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	space->set_debug_contacts(p_max_contacts);
 }
 
 Vector<Vector3> PhysicsServer3DSW::space_get_contacts(RID p_space) const {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, Vector<Vector3>());
 	return space->get_debug_contacts();
 }
 
 int PhysicsServer3DSW::space_get_contact_count(RID p_space) const {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_debug_contact_count();
 }
@@ -221,12 +221,12 @@ RID PhysicsServer3DSW::area_create() {
 };
 
 void PhysicsServer3DSW::area_set_space(RID p_area, RID p_space) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -239,7 +239,7 @@ void PhysicsServer3DSW::area_set_space(RID p_area, RID p_space) {
 };
 
 RID PhysicsServer3DSW::area_get_space(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Space3DSW *space = area->get_space();
@@ -250,34 +250,34 @@ RID PhysicsServer3DSW::area_get_space(RID p_area) const {
 };
 
 void PhysicsServer3DSW::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_space_override_mode(p_mode);
 }
 
 PhysicsServer3D::AreaSpaceOverrideMode PhysicsServer3DSW::area_get_space_override_mode(RID p_area) const {
-	const Area3DSW *area = area_owner.getornull(p_area);
+	const Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, AREA_SPACE_OVERRIDE_DISABLED);
 
 	return area->get_space_override_mode();
 }
 
 void PhysicsServer3DSW::area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer3DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
@@ -285,21 +285,21 @@ void PhysicsServer3DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape)
 }
 
 void PhysicsServer3DSW::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int PhysicsServer3DSW::area_get_shape_count(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, -1);
 
 	return area->get_shape_count();
 }
 
 RID PhysicsServer3DSW::area_get_shape(RID p_area, int p_shape_idx) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Shape3DSW *shape = area->get_shape(p_shape_idx);
@@ -309,21 +309,21 @@ RID PhysicsServer3DSW::area_get_shape(RID p_area, int p_shape_idx) const {
 }
 
 Transform3D PhysicsServer3DSW::area_get_shape_transform(RID p_area, int p_shape_idx) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer3DSW::area_remove_shape(RID p_area, int p_shape_idx) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer3DSW::area_clear_shapes(RID p_area) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	while (area->get_shape_count()) {
@@ -332,7 +332,7 @@ void PhysicsServer3DSW::area_clear_shapes(RID p_area) {
 }
 
 void PhysicsServer3DSW::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	ERR_FAIL_INDEX(p_shape_idx, area->get_shape_count());
 	FLUSH_QUERY_CHECK(area);
@@ -341,74 +341,74 @@ void PhysicsServer3DSW::area_set_shape_disabled(RID p_area, int p_shape_idx, boo
 
 void PhysicsServer3DSW::area_attach_object_instance_id(RID p_area, ObjectID p_id) {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_instance_id(p_id);
 }
 
 ObjectID PhysicsServer3DSW::area_get_object_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_instance_id();
 }
 
 void PhysicsServer3DSW::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_param(p_param, p_value);
 };
 
 void PhysicsServer3DSW::area_set_transform(RID p_area, const Transform3D &p_transform) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 };
 
 Variant PhysicsServer3DSW::area_get_param(RID p_area, AreaParameter p_param) const {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Variant());
 
 	return area->get_param(p_param);
 };
 
 Transform3D PhysicsServer3DSW::area_get_transform(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_transform();
 };
 
 void PhysicsServer3DSW::area_set_collision_layer(RID p_area, uint32_t p_layer) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_layer(p_layer);
 }
 
 void PhysicsServer3DSW::area_set_collision_mask(RID p_area, uint32_t p_mask) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_mask(p_mask);
 }
 
 void PhysicsServer3DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	FLUSH_QUERY_CHECK(area);
 
@@ -416,21 +416,21 @@ void PhysicsServer3DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
 }
 
 void PhysicsServer3DSW::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
 }
 
 void PhysicsServer3DSW::area_set_ray_pickable(RID p_area, bool p_enable) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_ray_pickable(p_enable);
 }
 
 void PhysicsServer3DSW::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_area_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
@@ -446,12 +446,12 @@ RID PhysicsServer3DSW::body_create() {
 };
 
 void PhysicsServer3DSW::body_set_space(RID p_body, RID p_space) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -464,7 +464,7 @@ void PhysicsServer3DSW::body_set_space(RID p_body, RID p_space) {
 };
 
 RID PhysicsServer3DSW::body_get_space(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Space3DSW *space = body->get_space();
@@ -475,55 +475,55 @@ RID PhysicsServer3DSW::body_get_space(RID p_body) const {
 };
 
 void PhysicsServer3DSW::body_set_mode(RID p_body, BodyMode p_mode) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_mode(p_mode);
 };
 
 PhysicsServer3D::BodyMode PhysicsServer3DSW::body_get_mode(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);
 
 	return body->get_mode();
 };
 
 void PhysicsServer3DSW::body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer3DSW::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
 	body->set_shape(p_shape_idx, shape);
 }
 void PhysicsServer3DSW::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int PhysicsServer3DSW::body_get_shape_count(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 
 	return body->get_shape_count();
 }
 
 RID PhysicsServer3DSW::body_get_shape(RID p_body, int p_shape_idx) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Shape3DSW *shape = body->get_shape(p_shape_idx);
@@ -533,7 +533,7 @@ RID PhysicsServer3DSW::body_get_shape(RID p_body, int p_shape_idx) const {
 }
 
 void PhysicsServer3DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count());
 	FLUSH_QUERY_CHECK(body);
@@ -542,21 +542,21 @@ void PhysicsServer3DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, boo
 }
 
 Transform3D PhysicsServer3DSW::body_get_shape_transform(RID p_body, int p_shape_idx) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Transform3D());
 
 	return body->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer3DSW::body_remove_shape(RID p_body, int p_shape_idx) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer3DSW::body_clear_shapes(RID p_body) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	while (body->get_shape_count()) {
@@ -565,21 +565,21 @@ void PhysicsServer3DSW::body_clear_shapes(RID p_body) {
 }
 
 void PhysicsServer3DSW::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_continuous_collision_detection(p_enable);
 }
 
 bool PhysicsServer3DSW::body_is_continuous_collision_detection_enabled(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->is_continuous_collision_detection_enabled();
 }
 
 void PhysicsServer3DSW::body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
@@ -587,14 +587,14 @@ void PhysicsServer3DSW::body_set_collision_layer(RID p_body, uint32_t p_layer) {
 }
 
 uint32_t PhysicsServer3DSW::body_get_collision_layer(RID p_body) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void PhysicsServer3DSW::body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
@@ -602,20 +602,20 @@ void PhysicsServer3DSW::body_set_collision_mask(RID p_body, uint32_t p_mask) {
 }
 
 uint32_t PhysicsServer3DSW::body_get_collision_mask(RID p_body) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
 }
 
 void PhysicsServer3DSW::body_attach_object_instance_id(RID p_body, ObjectID p_id) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	if (body) {
 		body->set_instance_id(p_id);
 		return;
 	}
 
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	if (soft_body) {
 		soft_body->set_instance_id(p_id);
 		return;
@@ -625,61 +625,61 @@ void PhysicsServer3DSW::body_attach_object_instance_id(RID p_body, ObjectID p_id
 };
 
 ObjectID PhysicsServer3DSW::body_get_object_instance_id(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, ObjectID());
 
 	return body->get_instance_id();
 };
 
 void PhysicsServer3DSW::body_set_user_flags(RID p_body, uint32_t p_flags) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 };
 
 uint32_t PhysicsServer3DSW::body_get_user_flags(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return 0;
 };
 
 void PhysicsServer3DSW::body_set_param(RID p_body, BodyParameter p_param, const Variant &p_value) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_param(p_param, p_value);
 };
 
 Variant PhysicsServer3DSW::body_get_param(RID p_body, BodyParameter p_param) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_param(p_param);
 };
 
 void PhysicsServer3DSW::body_reset_mass_properties(RID p_body) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	return body->reset_mass_properties();
 }
 
 void PhysicsServer3DSW::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_state(p_state, p_variant);
 };
 
 Variant PhysicsServer3DSW::body_get_state(RID p_body, BodyState p_state) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 
 	return body->get_state(p_state);
 };
 
 void PhysicsServer3DSW::body_set_applied_force(RID p_body, const Vector3 &p_force) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_force(p_force);
@@ -687,13 +687,13 @@ void PhysicsServer3DSW::body_set_applied_force(RID p_body, const Vector3 &p_forc
 };
 
 Vector3 PhysicsServer3DSW::body_get_applied_force(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 	return body->get_applied_force();
 };
 
 void PhysicsServer3DSW::body_set_applied_torque(RID p_body, const Vector3 &p_torque) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_torque(p_torque);
@@ -701,14 +701,14 @@ void PhysicsServer3DSW::body_set_applied_torque(RID p_body, const Vector3 &p_tor
 };
 
 Vector3 PhysicsServer3DSW::body_get_applied_torque(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 
 	return body->get_applied_torque();
 };
 
 void PhysicsServer3DSW::body_add_central_force(RID p_body, const Vector3 &p_force) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_central_force(p_force);
@@ -716,7 +716,7 @@ void PhysicsServer3DSW::body_add_central_force(RID p_body, const Vector3 &p_forc
 }
 
 void PhysicsServer3DSW::body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_force(p_force, p_position);
@@ -724,7 +724,7 @@ void PhysicsServer3DSW::body_add_force(RID p_body, const Vector3 &p_force, const
 };
 
 void PhysicsServer3DSW::body_add_torque(RID p_body, const Vector3 &p_torque) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_torque(p_torque);
@@ -732,7 +732,7 @@ void PhysicsServer3DSW::body_add_torque(RID p_body, const Vector3 &p_torque) {
 };
 
 void PhysicsServer3DSW::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -742,7 +742,7 @@ void PhysicsServer3DSW::body_apply_central_impulse(RID p_body, const Vector3 &p_
 }
 
 void PhysicsServer3DSW::body_apply_impulse(RID p_body, const Vector3 &p_impulse, const Vector3 &p_position) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -752,7 +752,7 @@ void PhysicsServer3DSW::body_apply_impulse(RID p_body, const Vector3 &p_impulse,
 };
 
 void PhysicsServer3DSW::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -762,7 +762,7 @@ void PhysicsServer3DSW::body_apply_torque_impulse(RID p_body, const Vector3 &p_i
 };
 
 void PhysicsServer3DSW::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -776,7 +776,7 @@ void PhysicsServer3DSW::body_set_axis_velocity(RID p_body, const Vector3 &p_axis
 };
 
 void PhysicsServer3DSW::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_axis_lock(p_axis, p_lock);
@@ -784,13 +784,13 @@ void PhysicsServer3DSW::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_l
 }
 
 bool PhysicsServer3DSW::body_is_axis_locked(RID p_body, BodyAxis p_axis) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->is_axis_locked(p_axis);
 }
 
 void PhysicsServer3DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_exception(p_body_b);
@@ -798,7 +798,7 @@ void PhysicsServer3DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
 };
 
 void PhysicsServer3DSW::body_remove_collision_exception(RID p_body, RID p_body_b) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_exception(p_body_b);
@@ -806,7 +806,7 @@ void PhysicsServer3DSW::body_remove_collision_exception(RID p_body, RID p_body_b
 };
 
 void PhysicsServer3DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
@@ -815,61 +815,61 @@ void PhysicsServer3DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_e
 };
 
 void PhysicsServer3DSW::body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 };
 
 real_t PhysicsServer3DSW::body_get_contacts_reported_depth_threshold(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return 0;
 };
 
 void PhysicsServer3DSW::body_set_omit_force_integration(RID p_body, bool p_omit) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_omit_force_integration(p_omit);
 };
 
 bool PhysicsServer3DSW::body_is_omitting_force_integration(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	return body->get_omit_force_integration();
 };
 
 void PhysicsServer3DSW::body_set_max_contacts_reported(RID p_body, int p_contacts) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_max_contacts_reported(p_contacts);
 }
 
 int PhysicsServer3DSW::body_get_max_contacts_reported(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 	return body->get_max_contacts_reported();
 }
 
 void PhysicsServer3DSW::body_set_state_sync_callback(RID p_body, void *p_instance, BodyStateCallback p_callback) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_state_sync_callback(p_instance, p_callback);
 }
 
 void PhysicsServer3DSW::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_force_integration_callback(p_callable, p_udata);
 }
 
 void PhysicsServer3DSW::body_set_ray_pickable(RID p_body, bool p_enable) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 bool PhysicsServer3DSW::body_test_motion(RID p_body, const Transform3D &p_from, const Vector3 &p_motion, real_t p_margin, MotionResult *r_result, int p_max_collisions, bool p_collide_separation_ray, const Set<RID> &p_exclude) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
 	ERR_FAIL_COND_V(body->get_space()->is_locked(), false);
@@ -882,7 +882,7 @@ bool PhysicsServer3DSW::body_test_motion(RID p_body, const Transform3D &p_from,
 PhysicsDirectBodyState3D *PhysicsServer3DSW::body_get_direct_state(RID p_body) {
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync), nullptr, "Body state is inaccessible right now, wait for iteration or physics process notification.");
 
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_NULL_V(body, nullptr);
 
 	ERR_FAIL_NULL_V(body->get_space(), nullptr);
@@ -901,19 +901,19 @@ RID PhysicsServer3DSW::soft_body_create() {
 }
 
 void PhysicsServer3DSW::soft_body_update_rendering_server(RID p_body, RenderingServerHandler *p_rendering_server_handler) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->update_rendering_server(p_rendering_server_handler);
 }
 
 void PhysicsServer3DSW::soft_body_set_space(RID p_body, RID p_space) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -925,7 +925,7 @@ void PhysicsServer3DSW::soft_body_set_space(RID p_body, RID p_space) {
 }
 
 RID PhysicsServer3DSW::soft_body_get_space(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, RID());
 
 	Space3DSW *space = soft_body->get_space();
@@ -936,49 +936,49 @@ RID PhysicsServer3DSW::soft_body_get_space(RID p_body) const {
 }
 
 void PhysicsServer3DSW::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_collision_layer(p_layer);
 }
 
 uint32_t PhysicsServer3DSW::soft_body_get_collision_layer(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0);
 
 	return soft_body->get_collision_layer();
 }
 
 void PhysicsServer3DSW::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_collision_mask(p_mask);
 }
 
 uint32_t PhysicsServer3DSW::soft_body_get_collision_mask(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0);
 
 	return soft_body->get_collision_mask();
 }
 
 void PhysicsServer3DSW::soft_body_add_collision_exception(RID p_body, RID p_body_b) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->add_exception(p_body_b);
 }
 
 void PhysicsServer3DSW::soft_body_remove_collision_exception(RID p_body, RID p_body_b) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->remove_exception(p_body_b);
 }
 
 void PhysicsServer3DSW::soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	for (int i = 0; i < soft_body->get_exceptions().size(); i++) {
@@ -987,154 +987,154 @@ void PhysicsServer3DSW::soft_body_get_collision_exceptions(RID p_body, List<RID>
 }
 
 void PhysicsServer3DSW::soft_body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_state(p_state, p_variant);
 }
 
 Variant PhysicsServer3DSW::soft_body_get_state(RID p_body, BodyState p_state) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, Variant());
 
 	return soft_body->get_state(p_state);
 }
 
 void PhysicsServer3DSW::soft_body_set_transform(RID p_body, const Transform3D &p_transform) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_state(BODY_STATE_TRANSFORM, p_transform);
 }
 
 void PhysicsServer3DSW::soft_body_set_ray_pickable(RID p_body, bool p_enable) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_ray_pickable(p_enable);
 }
 
 void PhysicsServer3DSW::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_iteration_count(p_simulation_precision);
 }
 
 int PhysicsServer3DSW::soft_body_get_simulation_precision(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_iteration_count();
 }
 
 void PhysicsServer3DSW::soft_body_set_total_mass(RID p_body, real_t p_total_mass) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_total_mass(p_total_mass);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_total_mass(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_total_mass();
 }
 
 void PhysicsServer3DSW::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_linear_stiffness(p_stiffness);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_linear_stiffness(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_linear_stiffness();
 }
 
 void PhysicsServer3DSW::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_pressure_coefficient(p_pressure_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_pressure_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_pressure_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_damping_coefficient(p_damping_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_damping_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_damping_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_drag_coefficient(p_drag_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_drag_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_drag_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_mesh(RID p_body, const REF &p_mesh) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_mesh(p_mesh);
 }
 
 AABB PhysicsServer3DSW::soft_body_get_bounds(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, AABB());
 
 	return soft_body->get_bounds();
 }
 
 void PhysicsServer3DSW::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_vertex_position(p_point_index, p_global_position);
 }
 
 Vector3 PhysicsServer3DSW::soft_body_get_point_global_position(RID p_body, int p_point_index) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, Vector3());
 
 	return soft_body->get_vertex_position(p_point_index);
 }
 
 void PhysicsServer3DSW::soft_body_remove_all_pinned_points(RID p_body) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->unpin_all_vertices();
 }
 
 void PhysicsServer3DSW::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	if (p_pin) {
@@ -1145,7 +1145,7 @@ void PhysicsServer3DSW::soft_body_pin_point(RID p_body, int p_point_index, bool
 }
 
 bool PhysicsServer3DSW::soft_body_is_point_pinned(RID p_body, int p_point_index) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, false);
 
 	return soft_body->is_vertex_pinned(p_point_index);
@@ -1161,7 +1161,7 @@ RID PhysicsServer3DSW::joint_create() {
 }
 
 void PhysicsServer3DSW::joint_clear(RID p_joint) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	if (joint->get_type() != JOINT_TYPE_MAX) {
 		Joint3DSW *empty_joint = memnew(Joint3DSW);
 		empty_joint->copy_settings_from(joint);
@@ -1172,7 +1172,7 @@ void PhysicsServer3DSW::joint_clear(RID p_joint) {
 }
 
 void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1180,12 +1180,12 @@ void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(PinJoint3DSW(body_A, p_local_A, body_B, p_local_B));
@@ -1196,7 +1196,7 @@ void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3
 }
 
 void PhysicsServer3DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1204,7 +1204,7 @@ void PhysicsServer3DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param,
 }
 
 real_t PhysicsServer3DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, 0);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1212,7 +1212,7 @@ real_t PhysicsServer3DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param
 }
 
 void PhysicsServer3DSW::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1220,7 +1220,7 @@ void PhysicsServer3DSW::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
 }
 
 Vector3 PhysicsServer3DSW::pin_joint_get_local_a(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3());
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1228,7 +1228,7 @@ Vector3 PhysicsServer3DSW::pin_joint_get_local_a(RID p_joint) const {
 }
 
 void PhysicsServer3DSW::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1236,7 +1236,7 @@ void PhysicsServer3DSW::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
 }
 
 Vector3 PhysicsServer3DSW::pin_joint_get_local_b(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3());
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1244,7 +1244,7 @@ Vector3 PhysicsServer3DSW::pin_joint_get_local_b(RID p_joint) const {
 }
 
 void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transform3D &p_frame_A, RID p_body_B, const Transform3D &p_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1252,12 +1252,12 @@ void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transf
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(HingeJoint3DSW(body_A, body_B, p_frame_A, p_frame_B));
@@ -1268,7 +1268,7 @@ void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transf
 }
 
 void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1276,12 +1276,12 @@ void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, RID p_body_A, const
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(HingeJoint3DSW(body_A, body_B, p_pivot_A, p_pivot_B, p_axis_A, p_axis_B));
@@ -1292,7 +1292,7 @@ void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, RID p_body_A, const
 }
 
 void PhysicsServer3DSW::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1300,7 +1300,7 @@ void PhysicsServer3DSW::hinge_joint_set_param(RID p_joint, HingeJointParam p_par
 }
 
 real_t PhysicsServer3DSW::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, 0);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1308,7 +1308,7 @@ real_t PhysicsServer3DSW::hinge_joint_get_param(RID p_joint, HingeJointParam p_p
 }
 
 void PhysicsServer3DSW::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1316,7 +1316,7 @@ void PhysicsServer3DSW::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag,
 }
 
 bool PhysicsServer3DSW::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, false);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1324,19 +1324,19 @@ bool PhysicsServer3DSW::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag)
 }
 
 void PhysicsServer3DSW::joint_set_solver_priority(RID p_joint, int p_priority) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	joint->set_priority(p_priority);
 }
 
 int PhysicsServer3DSW::joint_get_solver_priority(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	return joint->get_priority();
 }
 
 void PhysicsServer3DSW::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	joint->disable_collisions_between_bodies(p_disable);
@@ -1356,20 +1356,20 @@ void PhysicsServer3DSW::joint_disable_collisions_between_bodies(RID p_joint, con
 }
 
 bool PhysicsServer3DSW::joint_is_disabled_collisions_between_bodies(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, true);
 
 	return joint->is_disabled_collisions_between_bodies();
 }
 
 PhysicsServer3DSW::JointType PhysicsServer3DSW::joint_get_type(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, JOINT_TYPE_PIN);
 	return joint->get_type();
 }
 
 void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1377,12 +1377,12 @@ void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Trans
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(SliderJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B));
@@ -1393,7 +1393,7 @@ void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Trans
 }
 
 void PhysicsServer3DSW::slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_SLIDER);
 	SliderJoint3DSW *slider_joint = static_cast<SliderJoint3DSW *>(joint);
@@ -1401,7 +1401,7 @@ void PhysicsServer3DSW::slider_joint_set_param(RID p_joint, SliderJointParam p_p
 }
 
 real_t PhysicsServer3DSW::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0);
 	SliderJoint3DSW *slider_joint = static_cast<SliderJoint3DSW *>(joint);
@@ -1409,7 +1409,7 @@ real_t PhysicsServer3DSW::slider_joint_get_param(RID p_joint, SliderJointParam p
 }
 
 void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1417,12 +1417,12 @@ void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const T
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(ConeTwistJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B));
@@ -1433,7 +1433,7 @@ void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const T
 }
 
 void PhysicsServer3DSW::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_CONE_TWIST);
 	ConeTwistJoint3DSW *cone_twist_joint = static_cast<ConeTwistJoint3DSW *>(joint);
@@ -1441,7 +1441,7 @@ void PhysicsServer3DSW::cone_twist_joint_set_param(RID p_joint, ConeTwistJointPa
 }
 
 real_t PhysicsServer3DSW::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0);
 	ConeTwistJoint3DSW *cone_twist_joint = static_cast<ConeTwistJoint3DSW *>(joint);
@@ -1449,7 +1449,7 @@ real_t PhysicsServer3DSW::cone_twist_joint_get_param(RID p_joint, ConeTwistJoint
 }
 
 void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1457,12 +1457,12 @@ void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(Generic6DOFJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B, true));
@@ -1473,7 +1473,7 @@ void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const
 }
 
 void PhysicsServer3DSW::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1481,7 +1481,7 @@ void PhysicsServer3DSW::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis
 }
 
 real_t PhysicsServer3DSW::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, 0);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1489,7 +1489,7 @@ real_t PhysicsServer3DSW::generic_6dof_joint_get_param(RID p_joint, Vector3::Axi
 }
 
 void PhysicsServer3DSW::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1497,7 +1497,7 @@ void PhysicsServer3DSW::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p
 }
 
 bool PhysicsServer3DSW::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, false);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1508,7 +1508,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 	_update_shapes(); //just in case
 
 	if (shape_owner.owns(p_rid)) {
-		Shape3DSW *shape = shape_owner.getornull(p_rid);
+		Shape3DSW *shape = shape_owner.get_or_null(p_rid);
 
 		while (shape->get_owners().size()) {
 			ShapeOwner3DSW *so = shape->get_owners().front()->key();
@@ -1518,7 +1518,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		shape_owner.free(p_rid);
 		memdelete(shape);
 	} else if (body_owner.owns(p_rid)) {
-		Body3DSW *body = body_owner.getornull(p_rid);
+		Body3DSW *body = body_owner.get_or_null(p_rid);
 
 		/*
 		if (body->get_state_query())
@@ -1537,14 +1537,14 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		body_owner.free(p_rid);
 		memdelete(body);
 	} else if (soft_body_owner.owns(p_rid)) {
-		SoftBody3DSW *soft_body = soft_body_owner.getornull(p_rid);
+		SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_rid);
 
 		soft_body->set_space(nullptr);
 
 		soft_body_owner.free(p_rid);
 		memdelete(soft_body);
 	} else if (area_owner.owns(p_rid)) {
-		Area3DSW *area = area_owner.getornull(p_rid);
+		Area3DSW *area = area_owner.get_or_null(p_rid);
 
 		/*
 		if (area->get_monitor_query())
@@ -1560,7 +1560,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		area_owner.free(p_rid);
 		memdelete(area);
 	} else if (space_owner.owns(p_rid)) {
-		Space3DSW *space = space_owner.getornull(p_rid);
+		Space3DSW *space = space_owner.get_or_null(p_rid);
 
 		while (space->get_objects().size()) {
 			CollisionObject3DSW *co = (CollisionObject3DSW *)space->get_objects().front()->get();
@@ -1574,7 +1574,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		space_owner.free(p_rid);
 		memdelete(space);
 	} else if (joint_owner.owns(p_rid)) {
-		Joint3DSW *joint = joint_owner.getornull(p_rid);
+		Joint3DSW *joint = joint_owner.get_or_null(p_rid);
 
 		joint_owner.free(p_rid);
 		memdelete(joint);
diff --git a/servers/physics_3d/space_3d_sw.cpp b/servers/physics_3d/space_3d_sw.cpp
index 78c4e30c83..3718babbd6 100644
--- a/servers/physics_3d/space_3d_sw.cpp
+++ b/servers/physics_3d/space_3d_sw.cpp
@@ -187,7 +187,7 @@ int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Trans
 		return 0;
 	}
 
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	AABB aabb = p_xform.xform(shape->get_aabb());
@@ -238,7 +238,7 @@ int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Trans
 }
 
 bool PhysicsDirectSpaceState3DSW::cast_motion(const RID &p_shape, const Transform3D &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &p_closest_safe, real_t &p_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, ShapeRestInfo *r_info) {
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	AABB aabb = p_xform.xform(shape->get_aabb());
@@ -361,7 +361,7 @@ bool PhysicsDirectSpaceState3DSW::collide_shape(RID p_shape, const Transform3D &
 		return false;
 	}
 
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	AABB aabb = p_shape_xform.xform(shape->get_aabb());
@@ -487,7 +487,7 @@ static void _rest_cbk_result(const Vector3 &p_point_A, int p_index_A, const Vect
 }
 
 bool PhysicsDirectSpaceState3DSW::rest_info(RID p_shape, const Transform3D &p_shape_xform, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	real_t min_contact_depth = p_margin * TEST_MOTION_MIN_CONTACT_DEPTH_FACTOR;
@@ -543,9 +543,9 @@ bool PhysicsDirectSpaceState3DSW::rest_info(RID p_shape, const Transform3D &p_sh
 }
 
 Vector3 PhysicsDirectSpaceState3DSW::get_closest_point_to_object_volume(RID p_object, const Vector3 p_point) const {
-	CollisionObject3DSW *obj = PhysicsServer3DSW::singletonsw->area_owner.getornull(p_object);
+	CollisionObject3DSW *obj = PhysicsServer3DSW::singletonsw->area_owner.get_or_null(p_object);
 	if (!obj) {
-		obj = PhysicsServer3DSW::singletonsw->body_owner.getornull(p_object);
+		obj = PhysicsServer3DSW::singletonsw->body_owner.get_or_null(p_object);
 	}
 	ERR_FAIL_COND_V(!obj, Vector3());