1 files changed, 82 insertions, 119 deletions

diff --git a/scene/3d/node_3d.cpp b/scene/3d/node_3d.cpp
index 0b7407e049..e8005f38ed 100644
--- a/scene/3d/node_3d.cpp
+++ b/scene/3d/node_3d.cpp
@@ -30,8 +30,8 @@
 
 #include "node_3d.h"
 
-#include "core/engine.h"
-#include "core/message_queue.h"
+#include "core/config/engine.h"
+#include "core/object/message_queue.h"
 #include "scene/main/scene_tree.h"
 #include "scene/main/window.h"
 #include "scene/scene_string_names.h"
@@ -74,7 +74,6 @@ Node3DGizmo::Node3DGizmo() {
 }
 
 void Node3D::_notify_dirty() {
-
 #ifdef TOOLS_ENABLED
 	if ((data.gizmo.is_valid() || data.notify_transform) && !data.ignore_notification && !xform_change.in_list()) {
 #else
@@ -90,8 +89,8 @@ void Node3D::_update_local_transform() const {
 
 	data.dirty &= ~DIRTY_LOCAL;
 }
-void Node3D::_propagate_transform_changed(Node3D *p_origin) {
 
+void Node3D::_propagate_transform_changed(Node3D *p_origin) {
 	if (!is_inside_tree()) {
 		return;
 	}
@@ -104,9 +103,9 @@ void Node3D::_propagate_transform_changed(Node3D *p_origin) {
 	data.children_lock++;
 
 	for (List<Node3D *>::Element *E = data.children.front(); E; E = E->next()) {
-
-		if (E->get()->data.toplevel_active)
-			continue; //don't propagate to a toplevel
+		if (E->get()->data.top_level_active) {
+			continue; //don't propagate to a top_level
+		}
 		E->get()->_propagate_transform_changed(p_origin);
 	}
 #ifdef TOOLS_ENABLED
@@ -122,27 +121,27 @@ void Node3D::_propagate_transform_changed(Node3D *p_origin) {
 }
 
 void Node3D::_notification(int p_what) {
-
 	switch (p_what) {
 		case NOTIFICATION_ENTER_TREE: {
 			ERR_FAIL_COND(!get_tree());
 
 			Node *p = get_parent();
-			if (p)
+			if (p) {
 				data.parent = Object::cast_to<Node3D>(p);
+			}
 
-			if (data.parent)
+			if (data.parent) {
 				data.C = data.parent->data.children.push_back(this);
-			else
+			} else {
 				data.C = nullptr;
+			}
 
-			if (data.toplevel && !Engine::get_singleton()->is_editor_hint()) {
-
+			if (data.top_level && !Engine::get_singleton()->is_editor_hint()) {
 				if (data.parent) {
 					data.local_transform = data.parent->get_global_transform() * get_transform();
 					data.dirty = DIRTY_VECTORS; //global is always dirty upon entering a scene
 				}
-				data.toplevel_active = true;
+				data.top_level_active = true;
 			}
 
 			data.dirty |= DIRTY_GLOBAL; //global is always dirty upon entering a scene
@@ -152,18 +151,18 @@ void Node3D::_notification(int p_what) {
 
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
-
 			notification(NOTIFICATION_EXIT_WORLD, true);
-			if (xform_change.in_list())
+			if (xform_change.in_list()) {
 				get_tree()->xform_change_list.remove(&xform_change);
-			if (data.C)
+			}
+			if (data.C) {
 				data.parent->data.children.erase(data.C);
+			}
 			data.parent = nullptr;
 			data.C = nullptr;
-			data.toplevel_active = false;
+			data.top_level_active = false;
 		} break;
 		case NOTIFICATION_ENTER_WORLD: {
-
 			data.inside_world = true;
 			data.viewport = nullptr;
 			Node *parent = get_parent();
@@ -175,16 +174,13 @@ void Node3D::_notification(int p_what) {
 			ERR_FAIL_COND(!data.viewport);
 
 			if (get_script_instance()) {
-
-				get_script_instance()->call_multilevel(SceneStringNames::get_singleton()->_enter_world, nullptr, 0);
+				get_script_instance()->call(SceneStringNames::get_singleton()->_enter_world);
 			}
 #ifdef TOOLS_ENABLED
 			if (Engine::get_singleton()->is_editor_hint() && get_tree()->is_node_being_edited(this)) {
-
 				//get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,SceneStringNames::get_singleton()->_spatial_editor_group,SceneStringNames::get_singleton()->_request_gizmo,this);
 				get_tree()->call_group_flags(0, SceneStringNames::get_singleton()->_spatial_editor_group, SceneStringNames::get_singleton()->_request_gizmo, this);
 				if (!data.gizmo_disabled) {
-
 					if (data.gizmo.is_valid()) {
 						data.gizmo->create();
 						if (is_visible_in_tree()) {
@@ -198,7 +194,6 @@ void Node3D::_notification(int p_what) {
 
 		} break;
 		case NOTIFICATION_EXIT_WORLD: {
-
 #ifdef TOOLS_ENABLED
 			if (data.gizmo.is_valid()) {
 				data.gizmo->free();
@@ -207,8 +202,7 @@ void Node3D::_notification(int p_what) {
 #endif
 
 			if (get_script_instance()) {
-
-				get_script_instance()->call_multilevel(SceneStringNames::get_singleton()->_exit_world, nullptr, 0);
+				get_script_instance()->call(SceneStringNames::get_singleton()->_exit_world);
 			}
 
 			data.viewport = nullptr;
@@ -217,7 +211,6 @@ void Node3D::_notification(int p_what) {
 		} break;
 
 		case NOTIFICATION_TRANSFORM_CHANGED: {
-
 #ifdef TOOLS_ENABLED
 			if (data.gizmo.is_valid()) {
 				data.gizmo->transform();
@@ -231,7 +224,6 @@ void Node3D::_notification(int p_what) {
 }
 
 void Node3D::set_transform(const Transform &p_transform) {
-
 	data.local_transform = p_transform;
 	data.dirty |= DIRTY_VECTORS;
 	_change_notify("translation");
@@ -245,9 +237,8 @@ void Node3D::set_transform(const Transform &p_transform) {
 }
 
 void Node3D::set_global_transform(const Transform &p_transform) {
-
 	Transform xform =
-			(data.parent && !data.toplevel_active) ?
+			(data.parent && !data.top_level_active) ?
 					data.parent->get_global_transform().affine_inverse() * p_transform :
 					p_transform;
 
@@ -255,30 +246,24 @@ void Node3D::set_global_transform(const Transform &p_transform) {
 }
 
 Transform Node3D::get_transform() const {
-
 	if (data.dirty & DIRTY_LOCAL) {
-
 		_update_local_transform();
 	}
 
 	return data.local_transform;
 }
-Transform Node3D::get_global_transform() const {
 
+Transform Node3D::get_global_transform() const {
 	ERR_FAIL_COND_V(!is_inside_tree(), Transform());
 
 	if (data.dirty & DIRTY_GLOBAL) {
-
 		if (data.dirty & DIRTY_LOCAL) {
-
 			_update_local_transform();
 		}
 
-		if (data.parent && !data.toplevel_active) {
-
+		if (data.parent && !data.top_level_active) {
 			data.global_transform = data.parent->get_global_transform() * data.local_transform;
 		} else {
-
 			data.global_transform = data.local_transform;
 		}
 
@@ -303,25 +288,24 @@ Transform Node3D::get_local_gizmo_transform() const {
 #endif
 
 Node3D *Node3D::get_parent_spatial() const {
-
 	return data.parent;
 }
 
 Transform Node3D::get_relative_transform(const Node *p_parent) const {
-
-	if (p_parent == this)
+	if (p_parent == this) {
 		return Transform();
+	}
 
 	ERR_FAIL_COND_V(!data.parent, Transform());
 
-	if (p_parent == data.parent)
+	if (p_parent == data.parent) {
 		return get_transform();
-	else
+	} else {
 		return data.parent->get_relative_transform(p_parent) * get_transform();
+	}
 }
 
 void Node3D::set_translation(const Vector3 &p_translation) {
-
 	data.local_transform.origin = p_translation;
 	_change_notify("transform");
 	_propagate_transform_changed(this);
@@ -331,7 +315,6 @@ void Node3D::set_translation(const Vector3 &p_translation) {
 }
 
 void Node3D::set_rotation(const Vector3 &p_euler_rad) {
-
 	if (data.dirty & DIRTY_VECTORS) {
 		data.scale = data.local_transform.basis.get_scale();
 		data.dirty &= ~DIRTY_VECTORS;
@@ -347,12 +330,10 @@ void Node3D::set_rotation(const Vector3 &p_euler_rad) {
 }
 
 void Node3D::set_rotation_degrees(const Vector3 &p_euler_deg) {
-
 	set_rotation(p_euler_deg * Math_PI / 180.0);
 }
 
 void Node3D::set_scale(const Vector3 &p_scale) {
-
 	if (data.dirty & DIRTY_VECTORS) {
 		data.rotation = data.local_transform.basis.get_rotation();
 		data.dirty &= ~DIRTY_VECTORS;
@@ -368,12 +349,10 @@ void Node3D::set_scale(const Vector3 &p_scale) {
 }
 
 Vector3 Node3D::get_translation() const {
-
 	return data.local_transform.origin;
 }
 
 Vector3 Node3D::get_rotation() const {
-
 	if (data.dirty & DIRTY_VECTORS) {
 		data.scale = data.local_transform.basis.get_scale();
 		data.rotation = data.local_transform.basis.get_rotation();
@@ -385,12 +364,10 @@ Vector3 Node3D::get_rotation() const {
 }
 
 Vector3 Node3D::get_rotation_degrees() const {
-
 	return get_rotation() * 180.0 / Math_PI;
 }
 
 Vector3 Node3D::get_scale() const {
-
 	if (data.dirty & DIRTY_VECTORS) {
 		data.scale = data.local_transform.basis.get_scale();
 		data.rotation = data.local_transform.basis.get_rotation();
@@ -402,32 +379,35 @@ Vector3 Node3D::get_scale() const {
 }
 
 void Node3D::update_gizmo() {
-
 #ifdef TOOLS_ENABLED
-	if (!is_inside_world())
+	if (!is_inside_world()) {
 		return;
-	if (!data.gizmo.is_valid())
+	}
+	if (!data.gizmo.is_valid()) {
 		get_tree()->call_group_flags(SceneTree::GROUP_CALL_REALTIME, SceneStringNames::get_singleton()->_spatial_editor_group, SceneStringNames::get_singleton()->_request_gizmo, this);
-	if (!data.gizmo.is_valid())
+	}
+	if (!data.gizmo.is_valid()) {
 		return;
-	if (data.gizmo_dirty)
+	}
+	if (data.gizmo_dirty) {
 		return;
+	}
 	data.gizmo_dirty = true;
 	MessageQueue::get_singleton()->push_call(this, "_update_gizmo");
 #endif
 }
 
 void Node3D::set_gizmo(const Ref<Node3DGizmo> &p_gizmo) {
-
 #ifdef TOOLS_ENABLED
 
-	if (data.gizmo_disabled)
+	if (data.gizmo_disabled) {
 		return;
-	if (data.gizmo.is_valid() && is_inside_world())
+	}
+	if (data.gizmo.is_valid() && is_inside_world()) {
 		data.gizmo->free();
+	}
 	data.gizmo = p_gizmo;
 	if (data.gizmo.is_valid() && is_inside_world()) {
-
 		data.gizmo->create();
 		if (is_visible_in_tree()) {
 			data.gizmo->redraw();
@@ -439,7 +419,6 @@ void Node3D::set_gizmo(const Ref<Node3DGizmo> &p_gizmo) {
 }
 
 Ref<Node3DGizmo> Node3D::get_gizmo() const {
-
 #ifdef TOOLS_ENABLED
 
 	return data.gizmo;
@@ -450,32 +429,32 @@ Ref<Node3DGizmo> Node3D::get_gizmo() const {
 }
 
 void Node3D::_update_gizmo() {
-
 #ifdef TOOLS_ENABLED
-	if (!is_inside_world())
+	if (!is_inside_world()) {
 		return;
+	}
 	data.gizmo_dirty = false;
 	if (data.gizmo.is_valid()) {
-		if (is_visible_in_tree())
+		if (is_visible_in_tree()) {
 			data.gizmo->redraw();
-		else
+		} else {
 			data.gizmo->clear();
+		}
 	}
 #endif
 }
 
 #ifdef TOOLS_ENABLED
 void Node3D::set_disable_gizmo(bool p_enabled) {
-
 	data.gizmo_disabled = p_enabled;
-	if (!p_enabled && data.gizmo.is_valid())
+	if (!p_enabled && data.gizmo.is_valid()) {
 		data.gizmo = Ref<Node3DGizmo>();
+	}
 }
 
 #endif
 
 void Node3D::set_disable_scale(bool p_enabled) {
-
 	data.disable_scale = p_enabled;
 }
 
@@ -483,85 +462,84 @@ bool Node3D::is_scale_disabled() const {
 	return data.disable_scale;
 }
 
-void Node3D::set_as_toplevel(bool p_enabled) {
-
-	if (data.toplevel == p_enabled)
+void Node3D::set_as_top_level(bool p_enabled) {
+	if (data.top_level == p_enabled) {
 		return;
+	}
 	if (is_inside_tree() && !Engine::get_singleton()->is_editor_hint()) {
-
-		if (p_enabled)
+		if (p_enabled) {
 			set_transform(get_global_transform());
-		else if (data.parent)
+		} else if (data.parent) {
 			set_transform(data.parent->get_global_transform().affine_inverse() * get_global_transform());
+		}
 
-		data.toplevel = p_enabled;
-		data.toplevel_active = p_enabled;
+		data.top_level = p_enabled;
+		data.top_level_active = p_enabled;
 
 	} else {
-		data.toplevel = p_enabled;
+		data.top_level = p_enabled;
 	}
 }
 
-bool Node3D::is_set_as_toplevel() const {
-
-	return data.toplevel;
+bool Node3D::is_set_as_top_level() const {
+	return data.top_level;
 }
 
-Ref<World3D> Node3D::get_world() const {
-
+Ref<World3D> Node3D::get_world_3d() const {
 	ERR_FAIL_COND_V(!is_inside_world(), Ref<World3D>());
 	ERR_FAIL_COND_V(!data.viewport, Ref<World3D>());
 
-	return data.viewport->find_world();
+	return data.viewport->find_world_3d();
 }
 
 void Node3D::_propagate_visibility_changed() {
-
 	notification(NOTIFICATION_VISIBILITY_CHANGED);
 	emit_signal(SceneStringNames::get_singleton()->visibility_changed);
 	_change_notify("visible");
 #ifdef TOOLS_ENABLED
-	if (data.gizmo.is_valid())
+	if (data.gizmo.is_valid()) {
 		_update_gizmo();
+	}
 #endif
 
 	for (List<Node3D *>::Element *E = data.children.front(); E; E = E->next()) {
-
 		Node3D *c = E->get();
-		if (!c || !c->data.visible)
+		if (!c || !c->data.visible) {
 			continue;
+		}
 		c->_propagate_visibility_changed();
 	}
 }
 
 void Node3D::show() {
-
-	if (data.visible)
+	if (data.visible) {
 		return;
+	}
 
 	data.visible = true;
 
-	if (!is_inside_tree())
+	if (!is_inside_tree()) {
 		return;
+	}
 
 	_propagate_visibility_changed();
 }
 
 void Node3D::hide() {
-
-	if (!data.visible)
+	if (!data.visible) {
 		return;
+	}
 
 	data.visible = false;
 
-	if (!is_inside_tree())
+	if (!is_inside_tree()) {
 		return;
+	}
 
 	_propagate_visibility_changed();
 }
 
 bool Node3D::is_visible_in_tree() const {
-
 	const Node3D *s = this;
 
 	while (s) {
@@ -575,15 +553,14 @@ bool Node3D::is_visible_in_tree() const {
 }
 
 void Node3D::set_visible(bool p_visible) {
-
-	if (p_visible)
+	if (p_visible) {
 		show();
-	else
+	} else {
 		hide();
+	}
 }
 
 bool Node3D::is_visible() const {
-
 	return data.visible;
 }
 
@@ -594,34 +571,30 @@ void Node3D::rotate_object_local(const Vector3 &p_axis, float p_angle) {
 }
 
 void Node3D::rotate(const Vector3 &p_axis, float p_angle) {
-
 	Transform t = get_transform();
 	t.basis.rotate(p_axis, p_angle);
 	set_transform(t);
 }
 
 void Node3D::rotate_x(float p_angle) {
-
 	Transform t = get_transform();
 	t.basis.rotate(Vector3(1, 0, 0), p_angle);
 	set_transform(t);
 }
 
 void Node3D::rotate_y(float p_angle) {
-
 	Transform t = get_transform();
 	t.basis.rotate(Vector3(0, 1, 0), p_angle);
 	set_transform(t);
 }
-void Node3D::rotate_z(float p_angle) {
 
+void Node3D::rotate_z(float p_angle) {
 	Transform t = get_transform();
 	t.basis.rotate(Vector3(0, 0, 1), p_angle);
 	set_transform(t);
 }
 
 void Node3D::translate(const Vector3 &p_offset) {
-
 	Transform t = get_transform();
 	t.translate(p_offset);
 	set_transform(t);
@@ -636,7 +609,6 @@ void Node3D::translate_object_local(const Vector3 &p_offset) {
 }
 
 void Node3D::scale(const Vector3 &p_ratio) {
-
 	Transform t = get_transform();
 	t.basis.scale(p_ratio);
 	set_transform(t);
@@ -649,14 +621,12 @@ void Node3D::scale_object_local(const Vector3 &p_scale) {
 }
 
 void Node3D::global_rotate(const Vector3 &p_axis, float p_angle) {
-
 	Transform t = get_global_transform();
 	t.basis.rotate(p_axis, p_angle);
 	set_global_transform(t);
 }
 
 void Node3D::global_scale(const Vector3 &p_scale) {
-
 	Transform t = get_global_transform();
 	t.basis.scale(p_scale);
 	set_global_transform(t);
@@ -669,25 +639,21 @@ void Node3D::global_translate(const Vector3 &p_offset) {
 }
 
 void Node3D::orthonormalize() {
-
 	Transform t = get_transform();
 	t.orthonormalize();
 	set_transform(t);
 }
 
 void Node3D::set_identity() {
-
 	set_transform(Transform());
 }
 
 void Node3D::look_at(const Vector3 &p_target, const Vector3 &p_up) {
-
 	Vector3 origin(get_global_transform().origin);
 	look_at_from_position(origin, p_target, p_up);
 }
 
 void Node3D::look_at_from_position(const Vector3 &p_pos, const Vector3 &p_target, const Vector3 &p_up) {
-
 	ERR_FAIL_COND_MSG(p_pos == p_target, "Node origin and target are in the same position, look_at() failed.");
 	ERR_FAIL_COND_MSG(p_up.cross(p_target - p_pos) == Vector3(), "Up vector and direction between node origin and target are aligned, look_at() failed.");
 
@@ -701,12 +667,10 @@ void Node3D::look_at_from_position(const Vector3 &p_pos, const Vector3 &p_target
 }
 
 Vector3 Node3D::to_local(Vector3 p_global) const {
-
 	return get_global_transform().affine_inverse().xform(p_global);
 }
 
 Vector3 Node3D::to_global(Vector3 p_local) const {
-
 	return get_global_transform().xform(p_local);
 }
 
@@ -737,7 +701,6 @@ void Node3D::force_update_transform() {
 }
 
 void Node3D::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("set_transform", "local"), &Node3D::set_transform);
 	ClassDB::bind_method(D_METHOD("get_transform"), &Node3D::get_transform);
 	ClassDB::bind_method(D_METHOD("set_translation", "translation"), &Node3D::set_translation);
@@ -752,11 +715,11 @@ void Node3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_global_transform"), &Node3D::get_global_transform);
 	ClassDB::bind_method(D_METHOD("get_parent_spatial"), &Node3D::get_parent_spatial);
 	ClassDB::bind_method(D_METHOD("set_ignore_transform_notification", "enabled"), &Node3D::set_ignore_transform_notification);
-	ClassDB::bind_method(D_METHOD("set_as_toplevel", "enable"), &Node3D::set_as_toplevel);
-	ClassDB::bind_method(D_METHOD("is_set_as_toplevel"), &Node3D::is_set_as_toplevel);
+	ClassDB::bind_method(D_METHOD("set_as_top_level", "enable"), &Node3D::set_as_top_level);
+	ClassDB::bind_method(D_METHOD("is_set_as_top_level"), &Node3D::is_set_as_top_level);
 	ClassDB::bind_method(D_METHOD("set_disable_scale", "disable"), &Node3D::set_disable_scale);
 	ClassDB::bind_method(D_METHOD("is_scale_disabled"), &Node3D::is_scale_disabled);
-	ClassDB::bind_method(D_METHOD("get_world"), &Node3D::get_world);
+	ClassDB::bind_method(D_METHOD("get_world_3d"), &Node3D::get_world_3d);
 
 	ClassDB::bind_method(D_METHOD("force_update_transform"), &Node3D::force_update_transform);
 
@@ -810,6 +773,7 @@ void Node3D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "rotation_degrees", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_rotation_degrees", "get_rotation_degrees");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "rotation", PROPERTY_HINT_NONE, "", 0), "set_rotation", "get_rotation");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "scale", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_scale", "get_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "top_level"), "set_as_top_level", "is_set_as_top_level");
 	ADD_GROUP("Matrix", "");
 	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform", PROPERTY_HINT_NONE, ""), "set_transform", "get_transform");
 	ADD_GROUP("Visibility", "");
@@ -821,13 +785,12 @@ void Node3D::_bind_methods() {
 
 Node3D::Node3D() :
 		xform_change(this) {
-
 	data.dirty = DIRTY_NONE;
 	data.children_lock = 0;
 
 	data.ignore_notification = false;
-	data.toplevel = false;
-	data.toplevel_active = false;
+	data.top_level = false;
+	data.top_level_active = false;
 	data.scale = Vector3(1, 1, 1);
 	data.viewport = nullptr;
 	data.inside_world = false;