From 862000bcdf0081ace91678ad67a6db7fdb7892cf Mon Sep 17 00:00:00 2001
From: Will Nations <willnationsdev@gmail.com>
Date: Sun, 9 Sep 2018 13:12:08 -0500
Subject: [PATCH] Add ClassType wrapper and Editor SceneTemplates

---
 editor/create_dialog.cpp                  | 131 ++--
 editor/create_dialog.h                    |   5 +
 editor/editor_node.cpp                    |  27 +
 editor/editor_plugin.cpp                  |  10 +
 editor/editor_plugin.h                    |   3 +
 editor/editor_scene_template_settings.cpp | 749 ++++++++++++++++++++
 editor/editor_scene_template_settings.h   | 121 ++++
 editor/filesystem_dock.cpp                |  31 +-
 editor/filesystem_dock.h                  |   1 +
 editor/project_settings_editor.cpp        |   6 +
 editor/project_settings_editor.h          |   4 +
 editor/scene_tree_dock.cpp                |  39 +-
 editor/scene_tree_dock.h                  |   1 +
 modules/class_type/SCsub                  |   5 +
 modules/class_type/class_type.cpp         | 801 ++++++++++++++++++++++
 modules/class_type/class_type.h           | 137 ++++
 modules/class_type/config.py              |   5 +
 modules/class_type/register_types.cpp     |  14 +
 modules/class_type/register_types.h       |   3 +
 19 files changed, 2008 insertions(+), 85 deletions(-)
 create mode 100644 editor/editor_scene_template_settings.cpp
 create mode 100644 editor/editor_scene_template_settings.h
 create mode 100644 modules/class_type/SCsub
 create mode 100644 modules/class_type/class_type.cpp
 create mode 100644 modules/class_type/class_type.h
 create mode 100644 modules/class_type/config.py
 create mode 100644 modules/class_type/register_types.cpp
 create mode 100644 modules/class_type/register_types.h

diff --git a/editor/create_dialog.cpp b/editor/create_dialog.cpp
index c4516c1f17e6..6d6ffdb71f1a 100644
--- a/editor/create_dialog.cpp
+++ b/editor/create_dialog.cpp
@@ -36,13 +36,13 @@
 #include "editor_help.h"
 #include "editor_node.h"
 #include "editor_settings.h"
+#include "modules/class_type/class_type.h"
 #include "scene/gui/box_container.h"
 
 void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode) {
 
 	type_list.clear();
-	ClassDB::get_class_list(&type_list);
-	ScriptServer::get_global_class_list(&type_list);
+	ClassType::get_class_list(&type_list);
 	type_list.sort_custom<StringName::AlphCompare>();
 
 	recent->clear();
@@ -131,6 +131,8 @@ void CreateDialog::popup_create(bool p_dont_clear, bool p_replace_mode) {
 		set_title(vformat(TTR("Create New %s"), base_type));
 		get_ok()->set_text(TTR("Create"));
 	}
+
+	_scene_template_cache = "";
 }
 
 void CreateDialog::_text_changed(const String &p_newtext) {
@@ -156,27 +158,18 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 	if (p_types.has(p_type))
 		return;
 
-	bool cpp_type = ClassDB::class_exists(p_type);
-	EditorData &ed = EditorNode::get_editor_data();
+	Ref<ClassType> class_type = ClassType::from_name(p_type);
 
 	if (p_type == base_type)
 		return;
-
-	if (cpp_type) {
-		if (!ClassDB::is_parent_class(p_type, base_type))
-			return;
-	} else {
-		if (!ScriptServer::is_global_class(p_type) || !ed.script_class_is_parent(p_type, base_type))
+	if (!class_type->exists() || !class_type->is_parent_class(base_type))
+		return;
+	if (class_type->has_valid_path() && class_type->get_path().find("res://addons/", 0) != -1) {
+		if (!EditorNode::get_singleton()->is_addon_plugin_enabled(class_type->get_path().get_slicec('/', 3)))
 			return;
-
-		String script_path = ScriptServer::get_global_class_path(p_type);
-		if (script_path.find("res://addons/", 0) != -1) {
-			if (!EditorNode::get_singleton()->is_addon_plugin_enabled(script_path.get_slicec('/', 3)))
-				return;
-		}
 	}
 
-	String inherits = cpp_type ? ClassDB::get_parent_class(p_type) : ed.script_class_get_base(p_type);
+	String inherits = class_type->get_parent_class();
 
 	TreeItem *parent = p_root;
 
@@ -189,35 +182,30 @@ void CreateDialog::add_type(const String &p_type, HashMap<String, TreeItem *> &p
 
 		if (p_types.has(inherits))
 			parent = p_types[inherits];
-		else if (ScriptServer::is_global_class(inherits))
-			return;
+		else {
+			Ref<ClassType> inherits_type = ClassType::from_name(inherits);
+			if (inherits_type.is_null() || inherits_type->is_script_class() || inherits_type->is_scene_template())
+				return;
+		}
 	}
 
-	bool can_instance = (cpp_type && ClassDB::can_instance(p_type)) || ScriptServer::is_global_class(p_type);
+	bool can_instance = class_type->can_instance();
 
 	TreeItem *item = search_options->create_item(parent);
-	if (cpp_type) {
-		item->set_text(0, p_type);
-	} else {
+	String name_text = class_type->get_name();
+	if (class_type->has_valid_path()) {
+		name_text += " (" + class_type->get_path().get_file() + ")";
 		item->set_metadata(0, p_type);
-		item->set_text(0, p_type + " (" + ScriptServer::get_global_class_path(p_type).get_file() + ")");
 	}
+	item->set_text(0, name_text);
 	if (!can_instance) {
 		item->set_custom_color(0, get_color("disabled_font_color", "Editor"));
 		item->set_selectable(0, false);
 	} else {
 		bool is_search_subsequence = search_box->get_text().is_subsequence_ofi(p_type);
-		String to_select_type = *to_select ? (*to_select)->get_text(0) : "";
-		to_select_type = to_select_type.split(" ")[0];
-		bool current_item_is_preferred;
-		if (cpp_type) {
-			String cpp_to_select_type = to_select_type;
-			if (ScriptServer::is_global_class(to_select_type))
-				cpp_to_select_type = ScriptServer::get_global_class_base(to_select_type);
-			current_item_is_preferred = ClassDB::is_parent_class(p_type, preferred_search_result_type) && !ClassDB::is_parent_class(cpp_to_select_type, preferred_search_result_type);
-		} else {
-			current_item_is_preferred = ed.script_class_is_parent(p_type, preferred_search_result_type) && !ed.script_class_is_parent(to_select_type, preferred_search_result_type) && search_box->get_text() != to_select_type;
-		}
+		Ref<ClassType> to_select_type = ClassType::from_name(*to_select ? _get_name_from_text((*to_select)->get_text(0)) : "");
+		bool current_item_is_preferred = class_type->is_parent_class(preferred_search_result_type) && !to_select_type->is_parent_class(preferred_search_result_type);
+
 		if (*to_select && p_type.length() < (*to_select)->get_text(0).length()) {
 			current_item_is_preferred = true;
 		}
@@ -261,7 +249,6 @@ void CreateDialog::_update_search() {
 	HashMap<String, TreeItem *> types;
 
 	TreeItem *root = search_options->create_item();
-	EditorData &ed = EditorNode::get_editor_data();
 
 	root->set_text(0, base_type);
 	if (has_icon(base_type, "EditorIcons")) {
@@ -273,18 +260,21 @@ void CreateDialog::_update_search() {
 	for (List<StringName>::Element *I = type_list.front(); I; I = I->next()) {
 
 		String type = I->get();
-		bool cpp_type = ClassDB::class_exists(type);
+
+		Ref<ClassType> class_type = ClassType::from_name(type);
+		if (class_type.is_null())
+			continue;
 
 		if (base_type == "Node" && type.begins_with("Editor"))
 			continue; // do not show editor nodes
 
-		if (cpp_type && !ClassDB::can_instance(type))
+		if (!class_type->can_instance())
 			continue; // can't create what can't be instanced
 
 		bool skip = false;
-		if (cpp_type) {
+		if (class_type->is_engine_class()) {
 			for (Set<StringName>::Element *E = type_blacklist.front(); E && !skip; E = E->next()) {
-				if (ClassDB::is_parent_class(type, E->get()))
+				if (class_type->is_parent_class(E->get()))
 					skip = true;
 			}
 			if (skip)
@@ -296,15 +286,15 @@ void CreateDialog::_update_search() {
 		} else {
 
 			bool found = false;
-			String type = I->get();
-			while (type != "" && (cpp_type ? ClassDB::is_parent_class(type, base_type) : ed.script_class_is_parent(type, base_type)) && type != base_type) {
-				if (search_box->get_text().is_subsequence_ofi(type)) {
+			Ref<ClassType> match_type = ClassType::from_name(I->get());
+			while (match_type.is_valid() && match_type->get_name() != "" && match_type->is_parent_class(base_type) && match_type->get_name() != base_type) {
+				if (search_box->get_text().is_subsequence_ofi(match_type->get_name())) {
 
 					found = true;
 					break;
 				}
 
-				type = cpp_type ? ClassDB::get_parent_class(type) : ed.script_class_get_base(type);
+				match_type->set_name(match_type->get_parent_class());
 			}
 
 			if (found)
@@ -453,30 +443,12 @@ String CreateDialog::get_selected_type() {
 
 Object *CreateDialog::instance_selected() {
 
-	TreeItem *selected = search_options->get_selected();
-
-	if (selected) {
-
-		Variant md = selected->get_metadata(0);
-
-		String custom;
-		if (md.get_type() != Variant::NIL)
-			custom = md;
-
-		if (custom != String()) {
-			if (ScriptServer::is_global_class(custom)) {
-				Object *obj = EditorNode::get_editor_data().script_class_instance(custom);
-				Node *n = Object::cast_to<Node>(obj);
-				if (n)
-					n->set_name(custom);
-				return obj;
-			}
-			return EditorNode::get_editor_data().instance_custom_type(selected->get_text(0), custom);
-		} else {
-			return ClassDB::instance(selected->get_text(0));
-		}
+	Ref<ClassType> type = ClassType::from_name(_get_name_from_text(get_selected_type()));
+	if (type.is_valid() && type->exists()) {
+		if (!type->is_scene_template())
+			return type->instance();
+		_scene_template_cache = type->get_path();
 	}
-
 	return NULL;
 }
 
@@ -486,10 +458,11 @@ void CreateDialog::_item_selected() {
 	if (!item)
 		return;
 
-	String name = item->get_text(0);
+	String text = item->get_text(0);
+	String name = _get_name_from_text(text);
 
 	favorite->set_disabled(false);
-	favorite->set_pressed(favorite_list.find(name) != -1);
+	favorite->set_pressed(favorite_list.find(text) != -1);
 
 	if (!EditorHelp::get_doc_data()->class_list.has(name))
 		return;
@@ -505,13 +478,13 @@ void CreateDialog::_favorite_toggled() {
 	if (!item)
 		return;
 
-	String name = item->get_text(0);
+	String text = item->get_text(0);
 
-	if (favorite_list.find(name) == -1) {
-		favorite_list.push_back(name);
+	if (favorite_list.find(text) == -1) {
+		favorite_list.push_back(text);
 		favorite->set_pressed(true);
 	} else {
-		favorite_list.erase(name);
+		favorite_list.erase(text);
 		favorite->set_pressed(false);
 	}
 
@@ -526,7 +499,7 @@ void CreateDialog::_save_favorite_list() {
 
 		for (int i = 0; i < favorite_list.size(); i++) {
 			String l = favorite_list[i];
-			String name = l.split(" ")[0];
+			String name = _get_name_from_text(l);
 			if (!(ClassDB::class_exists(name) || ScriptServer::is_global_class(name)))
 				continue;
 			f->store_line(l);
@@ -541,7 +514,7 @@ void CreateDialog::_update_favorite_list() {
 	TreeItem *root = favorites->create_item();
 	for (int i = 0; i < favorite_list.size(); i++) {
 		String l = favorite_list[i];
-		String name = l.split(" ")[0];
+		String name = _get_name_from_text(l);
 		if (!(ClassDB::class_exists(name) || ScriptServer::is_global_class(name)))
 			continue;
 		TreeItem *ti = favorites->create_item(root);
@@ -557,7 +530,7 @@ void CreateDialog::_history_selected() {
 	if (!item)
 		return;
 
-	search_box->set_text(item->get_text(0).get_slicec(' ', 0));
+	search_box->set_text(_get_name_from_text(item->get_text(0)));
 	favorites->deselect_all();
 	_update_search();
 }
@@ -568,7 +541,7 @@ void CreateDialog::_favorite_selected() {
 	if (!item)
 		return;
 
-	search_box->set_text(item->get_text(0).get_slicec(' ', 0));
+	search_box->set_text(_get_name_from_text(item->get_text(0)));
 	recent->deselect_all();
 	_update_search();
 }
@@ -656,6 +629,10 @@ void CreateDialog::drop_data_fw(const Point2 &p_point, const Variant &p_data, Co
 	_save_and_update_favorite_list();
 }
 
+String CreateDialog::_get_name_from_text(const String &p_text) const {
+	return p_text.split(" ")[0];
+}
+
 void CreateDialog::_save_and_update_favorite_list() {
 	_save_favorite_list();
 	_update_favorite_list();
diff --git a/editor/create_dialog.h b/editor/create_dialog.h
index 6df9eebc8cd7..f90629b78d35 100644
--- a/editor/create_dialog.h
+++ b/editor/create_dialog.h
@@ -59,6 +59,7 @@ class CreateDialog : public ConfirmationDialog {
 	EditorHelpBit *help_bit;
 	List<StringName> type_list;
 	Set<StringName> type_blacklist;
+	String _scene_template_cache;
 
 	void _item_selected();
 
@@ -86,6 +87,8 @@ class CreateDialog : public ConfirmationDialog {
 	bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const;
 	void drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from);
 
+	String _get_name_from_text(const String &p_text) const;
+
 protected:
 	void _notification(int p_what);
 	static void _bind_methods();
@@ -102,6 +105,8 @@ class CreateDialog : public ConfirmationDialog {
 	void set_preferred_search_result_type(const String &p_preferred_type);
 	String get_preferred_search_result_type();
 
+	String get_scene_template_cache() const { return _scene_template_cache; }
+
 	void popup_create(bool p_dont_clear, bool p_replace_mode = false);
 
 	CreateDialog();
diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index dbbf5d08b88e..dc3fdc2e1fbe 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -3191,6 +3191,33 @@ Ref<Texture> EditorNode::get_class_icon(const String &p_class, const String &p_f
 		return gui_base->get_icon(p_class, "EditorIcons");
 	}
 
+	EditorSceneTemplateSettings *scene_template_settings = project_settings->get_scene_template_settings();
+	if (scene_template_settings->scene_template_exists(p_class)) {
+		String scene_path = scene_template_settings->scene_template_get_path(p_class);
+		if (scene_path.empty() || !FileAccess::exists(scene_path))
+			return NULL;
+		Ref<PackedScene> scene = ResourceLoader::load(scene_path, "PackedScene");
+		if (scene.is_null())
+			return NULL;
+		Ref<SceneState> state = scene->get_state();
+		if (state.is_null())
+			return NULL;
+		for (int i = 0; i < state->get_node_property_count(0); i++) {
+			String name = state->get_node_property_name(0, i);
+			if ("script" == name) {
+				Ref<Script> script = state->get_node_property_value(0, i);
+				while (script.is_valid()) {
+					String script_name = script->get_language()->get_global_class_name(script->get_path());
+					if (ScriptServer::is_global_class(script_name))
+						return get_class_icon(script_name);
+					script = script->get_base_script();
+				}
+				break;
+			}
+		}
+		return get_class_icon(state->get_node_type(0));
+	}
+
 	if (ScriptServer::is_global_class(p_class)) {
 		String icon_path = EditorNode::get_editor_data().script_class_get_icon_path(p_class);
 		RES icon;
diff --git a/editor/editor_plugin.cpp b/editor/editor_plugin.cpp
index 86b2db877ee7..00a86c074ab7 100644
--- a/editor/editor_plugin.cpp
+++ b/editor/editor_plugin.cpp
@@ -474,6 +474,14 @@ void EditorPlugin::set_force_draw_over_forwarding_enabled() {
 	always_draw_over_forwarding_list->add_plugin(this);
 }
 
+void EditorPlugin::scene_template_add(const String &p_name, const String &p_path) {
+	EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->scene_template_add(p_name, p_path);
+}
+
+void EditorPlugin::scene_template_remove(const String &p_name) {
+	EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->scene_template_remove(p_name);
+}
+
 void EditorPlugin::notify_scene_changed(const Node *scn_root) {
 	emit_signal("scene_changed", scn_root);
 }
@@ -757,6 +765,8 @@ void EditorPlugin::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("remove_tool_menu_item", "name"), &EditorPlugin::remove_tool_menu_item);
 	ClassDB::bind_method(D_METHOD("add_custom_type", "type", "base", "script", "icon"), &EditorPlugin::add_custom_type);
 	ClassDB::bind_method(D_METHOD("remove_custom_type", "type"), &EditorPlugin::remove_custom_type);
+	ClassDB::bind_method(D_METHOD("scene_template_add", "name", "path"), &EditorPlugin::scene_template_add);
+	ClassDB::bind_method(D_METHOD("scene_template_remove", "name"), &EditorPlugin::scene_template_remove);
 
 	ClassDB::bind_method(D_METHOD("add_autoload_singleton", "name", "path"), &EditorPlugin::add_autoload_singleton);
 	ClassDB::bind_method(D_METHOD("remove_autoload_singleton", "name"), &EditorPlugin::remove_autoload_singleton);
diff --git a/editor/editor_plugin.h b/editor/editor_plugin.h
index e03aeb5d3080..d2c263e6ba91 100644
--- a/editor/editor_plugin.h
+++ b/editor/editor_plugin.h
@@ -168,6 +168,9 @@ class EditorPlugin : public Node {
 	void set_force_draw_over_forwarding_enabled();
 	bool is_force_draw_over_forwarding_enabled() { return force_draw_over_forwarding_enabled; }
 
+	void scene_template_add(const String &p_name, const String &p_path);
+	void scene_template_remove(const String &p_name);
+
 	void notify_main_screen_changed(const String &screen_name);
 	void notify_scene_changed(const Node *scn_root);
 	void notify_scene_closed(const String &scene_filepath);
diff --git a/editor/editor_scene_template_settings.cpp b/editor/editor_scene_template_settings.cpp
new file mode 100644
index 000000000000..63ff02b81090
--- /dev/null
+++ b/editor/editor_scene_template_settings.cpp
@@ -0,0 +1,749 @@
+/*************************************************************************/
+/*  editor_scene_template_settings.cpp                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "editor_scene_template_settings.h"
+
+#include "core/global_constants.h"
+#include "core/project_settings.h"
+#include "editor/editor_node.h"
+#include "scene/main/viewport.h"
+#include "scene/resources/packed_scene.h"
+
+#define PREVIEW_LIST_MAX_SIZE 10
+
+void EditorSceneTemplateSettings::_notification(int p_what) {
+
+	if (p_what == NOTIFICATION_ENTER_TREE) {
+
+		List<String> afn;
+		ResourceLoader::get_recognized_extensions_for_type("PackedScene", &afn);
+
+		EditorFileDialog *file_dialog = scene_template_add_path->get_file_dialog();
+
+		for (List<String>::Element *E = afn.front(); E; E = E->next()) {
+			file_dialog->add_filter("*." + E->get());
+		}
+	}
+}
+
+bool EditorSceneTemplateSettings::_scene_template_name_is_valid(const String &p_name, String *r_error) {
+
+	if (!p_name.is_valid_identifier()) {
+		if (r_error)
+			*r_error = TTR("Invalid name.") + "\n" + TTR("Valid characters:") + " a-z, A-Z, 0-9 or _";
+
+		return false;
+	}
+
+	if (ClassDB::class_exists(p_name)) {
+		if (r_error)
+			*r_error = TTR("Invalid name. Must not collide with an existing engine class name.");
+
+		return false;
+	}
+
+	if (ScriptServer::is_global_class(p_name) && !ClassDB::is_parent_class(ScriptServer::get_global_class_base(p_name), "Node")) {
+		if (r_error)
+			*r_error = TTR("Invalid name. Must not collide with an existing non-Node script class name.");
+
+		return false;
+	}
+
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (Variant::get_type_name(Variant::Type(i)) == p_name) {
+			if (r_error)
+				*r_error = TTR("Invalid name. Must not collide with an existing buit-in type name.");
+
+			return false;
+		}
+	}
+
+	for (int i = 0; i < GlobalConstants::get_global_constant_count(); i++) {
+		if (GlobalConstants::get_global_constant_name(i) == p_name) {
+			if (r_error)
+				*r_error = TTR("Invalid name. Must not collide with an existing global constant name.");
+
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void EditorSceneTemplateSettings::_scene_template_add() {
+
+	scene_template_add(scene_template_add_name->get_text(), scene_template_add_path->get_line_edit()->get_text());
+
+	scene_template_add_path->get_line_edit()->set_text("");
+	scene_template_add_name->set_text("");
+}
+
+void EditorSceneTemplateSettings::_scene_template_selected() {
+
+	TreeItem *ti = tree->get_selected();
+
+	if (!ti)
+		return;
+
+	selected_scene_template = "scene_template/" + ti->get_text(0);
+}
+
+void EditorSceneTemplateSettings::_scene_template_edited() {
+
+	if (updating_scene_template)
+		return;
+
+	TreeItem *ti = tree->get_edited();
+	int column = tree->get_edited_column();
+
+	UndoRedo *undo_redo = EditorNode::get_undo_redo();
+
+	if (column == 0) {
+		String name = ti->get_text(0);
+		String old_name = selected_scene_template.get_slice("/", 1);
+
+		if (name == old_name)
+			return;
+
+		String error;
+		if (!_scene_template_name_is_valid(name, &error)) {
+			ti->set_text(0, old_name);
+			EditorNode::get_singleton()->show_warning(error);
+			return;
+		}
+
+		if (ProjectSettings::get_singleton()->has_setting("scene_template/" + name)) {
+			ti->set_text(0, old_name);
+			EditorNode::get_singleton()->show_warning(vformat(TTR("SceneTemplate '%s' already exists!"), name));
+			return;
+		}
+
+		updating_scene_template = true;
+
+		name = "scene_template/" + name;
+
+		int order = ProjectSettings::get_singleton()->get_order(selected_scene_template);
+		String path = ProjectSettings::get_singleton()->get(selected_scene_template);
+
+		undo_redo->create_action(TTR("Rename SceneTemplate"));
+
+		undo_redo->add_do_property(ProjectSettings::get_singleton(), name, path);
+		undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", name, order);
+		undo_redo->add_do_method(ProjectSettings::get_singleton(), "clear", selected_scene_template);
+
+		undo_redo->add_undo_property(ProjectSettings::get_singleton(), selected_scene_template, path);
+		undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", selected_scene_template, order);
+		undo_redo->add_undo_method(ProjectSettings::get_singleton(), "clear", name);
+
+		undo_redo->add_do_method(this, "call_deferred", "update_scene_templates");
+		undo_redo->add_undo_method(this, "call_deferred", "update_scene_templates");
+
+		undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+		undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+		undo_redo->commit_action();
+
+		selected_scene_template = name;
+	}
+
+	updating_scene_template = false;
+}
+
+void EditorSceneTemplateSettings::_scene_template_button_pressed(Object *p_item, int p_column, int p_button) {
+
+	TreeItem *ti = Object::cast_to<TreeItem>(p_item);
+
+	String name = "scene_template/" + ti->get_text(0);
+
+	UndoRedo *undo_redo = EditorNode::get_undo_redo();
+
+	switch (p_button) {
+		case BUTTON_OPEN: {
+			_scene_template_open(ti->get_text(1));
+		} break;
+		case BUTTON_MOVE_UP:
+		case BUTTON_MOVE_DOWN: {
+
+			TreeItem *swap = NULL;
+
+			if (p_button == BUTTON_MOVE_UP) {
+				swap = ti->get_prev();
+			} else {
+				swap = ti->get_next();
+			}
+
+			if (!swap)
+				return;
+
+			String swap_name = "scene_template/" + swap->get_text(0);
+
+			int order = ProjectSettings::get_singleton()->get_order(name);
+			int swap_order = ProjectSettings::get_singleton()->get_order(swap_name);
+
+			undo_redo->create_action(TTR("Move SceneTemplate"));
+
+			undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", name, swap_order);
+			undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", name, order);
+
+			undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", swap_name, order);
+			undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", swap_name, swap_order);
+
+			undo_redo->add_do_method(this, "update_scene_templates");
+			undo_redo->add_undo_method(this, "update_scene_templates");
+
+			undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+			undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+			undo_redo->commit_action();
+		} break;
+		case BUTTON_DELETE: {
+
+			int order = ProjectSettings::get_singleton()->get_order(name);
+
+			undo_redo->create_action(TTR("Remove SceneTemplate"));
+
+			undo_redo->add_do_property(ProjectSettings::get_singleton(), name, Variant());
+
+			undo_redo->add_undo_property(ProjectSettings::get_singleton(), name, ProjectSettings::get_singleton()->get(name));
+			undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_persisting", name, true);
+			undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", order);
+
+			undo_redo->add_do_method(this, "update_scene_templates");
+			undo_redo->add_undo_method(this, "update_scene_templates");
+
+			undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+			undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+			undo_redo->commit_action();
+		} break;
+	}
+}
+
+void EditorSceneTemplateSettings::_scene_template_activated() {
+	TreeItem *ti = tree->get_selected();
+	if (!ti)
+		return;
+	_scene_template_open(ti->get_text(1));
+}
+
+void EditorSceneTemplateSettings::_scene_template_open(const String &fpath) {
+	if (ResourceLoader::get_resource_type(fpath) == "PackedScene") {
+		EditorNode::get_singleton()->open_request(fpath);
+	}
+	ProjectSettingsEditor::get_singleton()->hide();
+}
+void EditorSceneTemplateSettings::_scene_template_file_callback(const String &p_path) {
+
+	StringName name = scene_template_get_base_file(p_path);
+	scene_template_add_name->set_text(p_path.get_file().get_basename());
+}
+
+StringName EditorSceneTemplateSettings::scene_template_get_base(const StringName &p_name) const {
+	if (p_name == StringName() || !scene_template_map.has(p_name))
+		return StringName();
+	ERR_FAIL_COND_V(!scene_template_map[p_name], StringName());
+
+	Ref<PackedScene> scene = ResourceLoader::load(scene_template_map[p_name]->path, "PackedScene");
+	if (scene.is_null())
+		return StringName();
+
+	Ref<SceneState> state = scene->get_state();
+	if (state.is_null())
+		return StringName();
+
+	Ref<PackedScene> base_scene = state->get_node_instance(0);
+	while (base_scene.is_valid()) {
+		for (const List<SceneTemplateInfo>::Element *E = scene_template_cache.front(); E; E = E->next()) {
+			if (E->get().path == base_scene->get_path()) {
+				return E->get().name;
+			}
+		}
+		base_scene = base_scene->get_state()->get_node_instance(0);
+	}
+
+	for (int i = 0; i < state->get_node_property_count(0); i++) {
+		if ("script" == state->get_node_property_name(0, i)) {
+			Ref<Script> script = state->get_node_property_value(0, i);
+			if (script.is_valid()) {
+				StringName name = EditorNode::get_editor_data().script_class_get_name(script->get_path());
+				if (ScriptServer::is_global_class(name))
+					return name;
+			}
+			break;
+		}
+	}
+	return state->get_node_type(0);
+}
+
+StringName EditorSceneTemplateSettings::scene_template_get_base_file(const String &p_path) const {
+	return scene_template_get_base(scene_template_get_name(p_path));
+}
+
+StringName EditorSceneTemplateSettings::scene_template_get_name(const String &p_path) const {
+	for (const List<SceneTemplateInfo>::Element *E = scene_template_cache.front(); E; E = E->next()) {
+		if (E->get().path == p_path)
+			return E->get().name;
+	}
+	return StringName();
+}
+
+Node *EditorSceneTemplateSettings::scene_template_instance(const StringName &p_name) {
+	return _create_scene_template(scene_template_map[p_name]->path);
+}
+
+bool EditorSceneTemplateSettings::scene_template_is_parent(const StringName &p_name, const StringName &p_inherits) {
+	if (!scene_template_map.has(p_name))
+		return false;
+
+	return EditorNode::get_editor_data().script_class_is_parent(scene_template_get_base(p_name), p_inherits);
+}
+
+Node *EditorSceneTemplateSettings::_create_scene_template(const String &p_path) {
+	RES res = ResourceLoader::load(p_path);
+	ERR_EXPLAIN("Can't instance SceneTemplate: " + p_path);
+	ERR_FAIL_COND_V(res.is_null(), NULL);
+	Node *n = NULL;
+	if (res->is_class("PackedScene")) {
+		Ref<PackedScene> ps = res;
+		n = ps->instance();
+	}
+
+	ERR_EXPLAIN("Path in SceneTemplate is not a node: " + p_path);
+	ERR_FAIL_COND_V(!n, NULL);
+
+	return n;
+}
+
+void EditorSceneTemplateSettings::update_scene_templates() {
+
+	if (updating_scene_template)
+		return;
+
+	updating_scene_template = true;
+
+	Map<String, SceneTemplateInfo> to_remove;
+	List<SceneTemplateInfo *> to_add;
+
+	for (List<SceneTemplateInfo>::Element *E = scene_template_cache.front(); E; E = E->next()) {
+		SceneTemplateInfo &info = E->get();
+		to_remove.insert(info.name, info);
+	}
+
+	scene_template_cache.clear();
+	scene_template_map.clear();
+
+	tree->clear();
+	TreeItem *root = tree->create_item();
+
+	List<PropertyInfo> props;
+	ProjectSettings::get_singleton()->get_property_list(&props);
+
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+
+		const PropertyInfo &pi = E->get();
+
+		if (!pi.name.begins_with("scene_template/"))
+			continue;
+
+		String name = pi.name.get_slice("/", 1);
+		String path = ProjectSettings::get_singleton()->get(pi.name);
+		int order = ProjectSettings::get_singleton()->get_order(pi.name);
+
+		if (name.empty())
+			continue;
+
+		SceneTemplateInfo info;
+
+		info.name = name;
+		info.path = path;
+		info.order = order;
+
+		scene_template_cache.push_back(info);
+		scene_template_map[name] = &scene_template_cache.back()->get();
+
+		TreeItem *item = tree->create_item(root);
+		item->set_text(0, name);
+		item->set_editable(0, true);
+
+		item->set_text(1, path);
+		item->set_selectable(1, true);
+
+		item->add_button(2, get_icon("FileList", "EditorIcons"), BUTTON_OPEN);
+		item->add_button(2, get_icon("MoveUp", "EditorIcons"), BUTTON_MOVE_UP);
+		item->add_button(2, get_icon("MoveDown", "EditorIcons"), BUTTON_MOVE_DOWN);
+		item->add_button(2, get_icon("Remove", "EditorIcons"), BUTTON_DELETE);
+		item->set_selectable(2, true);
+	}
+
+	updating_scene_template = false;
+}
+
+Variant EditorSceneTemplateSettings::get_drag_data_fw(const Point2 &p_point, Control *p_control) {
+
+	if (scene_template_cache.size() <= 1)
+		return false;
+
+	PoolStringArray scene_templates;
+
+	TreeItem *next = tree->get_next_selected(NULL);
+
+	while (next) {
+		scene_templates.push_back(next->get_text(0));
+		next = tree->get_next_selected(next);
+	}
+
+	if (scene_templates.size() == 0 || scene_templates.size() == scene_template_cache.size())
+		return Variant();
+
+	VBoxContainer *preview = memnew(VBoxContainer);
+
+	int max_size = MIN(PREVIEW_LIST_MAX_SIZE, scene_templates.size());
+
+	for (int i = 0; i < max_size; i++) {
+		Label *label = memnew(Label(scene_templates[i]));
+		label->set_self_modulate(Color(1, 1, 1, Math::lerp(1, 0, float(i) / PREVIEW_LIST_MAX_SIZE)));
+
+		preview->add_child(label);
+	}
+
+	tree->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN);
+	tree->set_drag_preview(preview);
+
+	Dictionary drop_data;
+	drop_data["type"] = "scene_template";
+	drop_data["scene_templates"] = scene_templates;
+
+	return drop_data;
+}
+
+bool EditorSceneTemplateSettings::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_control) const {
+	if (updating_scene_template)
+		return false;
+
+	Dictionary drop_data = p_data;
+
+	if (!drop_data.has("type"))
+		return false;
+
+	if (drop_data.has("type")) {
+		TreeItem *ti = tree->get_item_at_position(p_point);
+
+		if (!ti)
+			return false;
+
+		int section = tree->get_drop_section_at_position(p_point);
+
+		if (section < -1)
+			return false;
+
+		return true;
+	}
+
+	return false;
+}
+
+void EditorSceneTemplateSettings::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_control) {
+
+	TreeItem *ti = tree->get_item_at_position(p_point);
+
+	if (!ti)
+		return;
+
+	int section = tree->get_drop_section_at_position(p_point);
+
+	if (section < -1)
+		return;
+
+	String name;
+	bool move_to_back = false;
+
+	if (section < 0) {
+		name = ti->get_text(0);
+	} else if (ti->get_next()) {
+		name = ti->get_next()->get_text(0);
+	} else {
+		name = ti->get_text(0);
+		move_to_back = true;
+	}
+
+	int order = ProjectSettings::get_singleton()->get_order("scene_template/" + name);
+
+	SceneTemplateInfo aux;
+	List<SceneTemplateInfo>::Element *E = NULL;
+
+	if (!move_to_back) {
+		aux.order = order;
+		E = scene_template_cache.find(aux);
+	}
+
+	Dictionary drop_data = p_data;
+	PoolStringArray scene_templates = drop_data["scene_templates"];
+
+	Vector<int> orders;
+	orders.resize(scene_template_cache.size());
+
+	for (int i = 0; i < scene_templates.size(); i++) {
+		aux.order = ProjectSettings::get_singleton()->get_order("scene_template/" + scene_templates[i]);
+
+		List<SceneTemplateInfo>::Element *I = scene_template_cache.find(aux);
+
+		if (move_to_back) {
+			scene_template_cache.move_to_back(I);
+		} else if (E != I) {
+			scene_template_cache.move_before(I, E);
+		} else if (E->next()) {
+			E = E->next();
+		} else {
+			break;
+		}
+	}
+
+	int i = 0;
+
+	for (List<SceneTemplateInfo>::Element *E = scene_template_cache.front(); E; E = E->next()) {
+		orders.write[i++] = E->get().order;
+	}
+
+	orders.sort();
+
+	UndoRedo *undo_redo = EditorNode::get_undo_redo();
+
+	undo_redo->create_action(TTR("Rearrange SceneTemplates"));
+
+	i = 0;
+
+	for (List<SceneTemplateInfo>::Element *E = scene_template_cache.front(); E; E = E->next()) {
+		undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", "scene_template/" + E->get().name, orders[i++]);
+		undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", "scene_template/" + E->get().name, E->get().order);
+	}
+
+	orders.clear();
+
+	undo_redo->add_do_method(this, "update_scene_templates");
+	undo_redo->add_undo_method(this, "update_scene_templates");
+
+	undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+	undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+	undo_redo->commit_action();
+}
+
+void EditorSceneTemplateSettings::scene_template_add(const String &p_name, const String &p_path) {
+
+	String name = p_name;
+
+	String error;
+	if (!_scene_template_name_is_valid(name, &error)) {
+		EditorNode::get_singleton()->show_warning(error);
+		return;
+	}
+
+	String path = p_path;
+	if (!FileAccess::exists(path)) {
+		EditorNode::get_singleton()->show_warning(TTR("Invalid Path.") + "\n" + TTR("File does not exist."));
+		return;
+	}
+
+	if (!path.begins_with("res://")) {
+		EditorNode::get_singleton()->show_warning(TTR("Invalid Path.") + "\n" + TTR("Not in resource path."));
+		return;
+	}
+
+	name = "scene_template/" + name;
+
+	UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
+
+	undo_redo->create_action(TTR("Add SceneTemplate"));
+	undo_redo->add_do_property(ProjectSettings::get_singleton(), name, path);
+
+	if (ProjectSettings::get_singleton()->has_setting(name)) {
+		undo_redo->add_undo_property(ProjectSettings::get_singleton(), name, ProjectSettings::get_singleton()->get(name));
+	} else {
+		undo_redo->add_undo_property(ProjectSettings::get_singleton(), name, Variant());
+	}
+
+	undo_redo->add_do_method(this, "update_scene_templates");
+	undo_redo->add_undo_method(this, "update_scene_templates");
+
+	undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+	undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+	undo_redo->commit_action();
+}
+
+void EditorSceneTemplateSettings::scene_template_remove(const String &p_name) {
+
+	String name = "scene_template/" + p_name;
+
+	UndoRedo *undo_redo = EditorNode::get_singleton()->get_undo_redo();
+
+	int order = ProjectSettings::get_singleton()->get_order(name);
+
+	undo_redo->create_action(TTR("Remove SceneTemplate"));
+
+	undo_redo->add_do_property(ProjectSettings::get_singleton(), name, Variant());
+
+	undo_redo->add_undo_property(ProjectSettings::get_singleton(), name, ProjectSettings::get_singleton()->get(name));
+	undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_persisting", name, true);
+	undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", order);
+
+	undo_redo->add_do_method(this, "update_scene_templates");
+	undo_redo->add_undo_method(this, "update_scene_templates");
+
+	undo_redo->add_do_method(this, "emit_signal", scene_template_changed);
+	undo_redo->add_undo_method(this, "emit_signal", scene_template_changed);
+
+	undo_redo->commit_action();
+}
+
+void EditorSceneTemplateSettings::set_template_name(const String &p_name) {
+	scene_template_add_name->set_text(p_name);
+}
+
+String EditorSceneTemplateSettings::get_template_name() const {
+	return scene_template_add_name->get_text();
+}
+
+void EditorSceneTemplateSettings::set_template_path(const String &p_path) {
+	scene_template_add_path->get_line_edit()->set_text(p_path);
+}
+
+String EditorSceneTemplateSettings::get_template_path() const {
+	return scene_template_add_path->get_line_edit()->get_text();
+}
+
+void EditorSceneTemplateSettings::_bind_methods() {
+
+	ClassDB::bind_method("_scene_template_add", &EditorSceneTemplateSettings::_scene_template_add);
+	ClassDB::bind_method("_scene_template_selected", &EditorSceneTemplateSettings::_scene_template_selected);
+	ClassDB::bind_method("_scene_template_edited", &EditorSceneTemplateSettings::_scene_template_edited);
+	ClassDB::bind_method("_scene_template_button_pressed", &EditorSceneTemplateSettings::_scene_template_button_pressed);
+	ClassDB::bind_method("_scene_template_file_callback", &EditorSceneTemplateSettings::_scene_template_file_callback);
+	ClassDB::bind_method("_scene_template_activated", &EditorSceneTemplateSettings::_scene_template_activated);
+	ClassDB::bind_method("_scene_template_open", &EditorSceneTemplateSettings::_scene_template_open);
+
+	ClassDB::bind_method("get_drag_data_fw", &EditorSceneTemplateSettings::get_drag_data_fw);
+	ClassDB::bind_method("can_drop_data_fw", &EditorSceneTemplateSettings::can_drop_data_fw);
+	ClassDB::bind_method("drop_data_fw", &EditorSceneTemplateSettings::drop_data_fw);
+
+	ClassDB::bind_method("update_scene_templates", &EditorSceneTemplateSettings::update_scene_templates);
+	ClassDB::bind_method("scene_template_add", &EditorSceneTemplateSettings::scene_template_add);
+	ClassDB::bind_method("scene_template_remove", &EditorSceneTemplateSettings::scene_template_remove);
+
+	ADD_SIGNAL(MethodInfo("scene_template_changed"));
+}
+
+EditorSceneTemplateSettings::EditorSceneTemplateSettings() {
+
+	// Make first cache
+	List<PropertyInfo> props;
+	ProjectSettings::get_singleton()->get_property_list(&props);
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+
+		const PropertyInfo &pi = E->get();
+
+		if (!pi.name.begins_with("scene_template/"))
+			continue;
+
+		String name = pi.name.get_slice("/", 1);
+
+		if (name.empty())
+			continue;
+
+		String path = ProjectSettings::get_singleton()->get(pi.name);
+		int order = ProjectSettings::get_singleton()->get_order(pi.name);
+
+		scene_template_cache.push_back(SceneTemplateInfo(name, path, order));
+		scene_template_map[name] = &scene_template_cache.back()->get();
+	}
+
+	scene_template_changed = "scene_template_changed";
+
+	updating_scene_template = false;
+	selected_scene_template = "";
+
+	HBoxContainer *hbc = memnew(HBoxContainer);
+	add_child(hbc);
+
+	Label *l = memnew(Label);
+	l->set_text(TTR("Name:"));
+	hbc->add_child(l);
+
+	scene_template_add_name = memnew(LineEdit);
+	scene_template_add_name->set_h_size_flags(SIZE_EXPAND_FILL);
+	hbc->add_child(scene_template_add_name);
+
+	l = memnew(Label);
+	l->set_text(TTR("Path:"));
+	hbc->add_child(l);
+
+	scene_template_add_path = memnew(EditorLineEditFileChooser);
+	scene_template_add_path->set_h_size_flags(SIZE_EXPAND_FILL);
+	scene_template_add_path->get_file_dialog()->set_mode(EditorFileDialog::MODE_OPEN_FILE);
+	scene_template_add_path->get_file_dialog()->connect("file_selected", this, "_scene_template_file_callback");
+	hbc->add_child(scene_template_add_path);
+
+	Button *add_scene_template = memnew(Button);
+	add_scene_template->set_text(TTR("Add"));
+	add_scene_template->connect("pressed", this, "_scene_template_add");
+	hbc->add_child(add_scene_template);
+
+	tree = memnew(Tree);
+	tree->set_hide_root(true);
+	tree->set_select_mode(Tree::SELECT_MULTI);
+	tree->set_allow_reselect(true);
+
+	tree->set_drag_forwarding(this);
+
+	tree->set_columns(3);
+	tree->set_column_titles_visible(true);
+
+	tree->set_column_title(0, TTR("Name"));
+	tree->set_column_expand(0, true);
+	tree->set_column_min_width(0, 100);
+
+	tree->set_column_title(1, TTR("Path"));
+	tree->set_column_expand(1, true);
+	tree->set_column_min_width(1, 100);
+
+	tree->set_column_expand(2, false);
+	tree->set_column_min_width(2, 120 * EDSCALE);
+
+	tree->connect("cell_selected", this, "_scene_template_selected");
+	tree->connect("item_edited", this, "_scene_template_edited");
+	tree->connect("button_pressed", this, "_scene_template_button_pressed");
+	tree->connect("item_activated", this, "_scene_template_activated");
+	tree->set_v_size_flags(SIZE_EXPAND_FILL);
+
+	add_child(tree, true);
+}
+
+EditorSceneTemplateSettings::~EditorSceneTemplateSettings() {
+}
diff --git a/editor/editor_scene_template_settings.h b/editor/editor_scene_template_settings.h
new file mode 100644
index 000000000000..8cac7eafe23d
--- /dev/null
+++ b/editor/editor_scene_template_settings.h
@@ -0,0 +1,121 @@
+/*************************************************************************/
+/*  editor_scene_template_settings.h                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef EDITOR_SCENE_TEMPLATE_SETTINGS_H
+#define EDITOR_SCENE_TEMPLATE_SETTINGS_H
+
+#include "scene/gui/tree.h"
+
+#include "editor_file_dialog.h"
+
+class EditorSceneTemplateSettings : public VBoxContainer {
+
+	GDCLASS(EditorSceneTemplateSettings, VBoxContainer);
+
+	enum {
+		BUTTON_OPEN,
+		BUTTON_MOVE_UP,
+		BUTTON_MOVE_DOWN,
+		BUTTON_DELETE
+	};
+
+	String scene_template_changed;
+
+	struct SceneTemplateInfo {
+		StringName name;
+		String path;
+		int order;
+
+		bool operator==(const SceneTemplateInfo &p_info) {
+			return order == p_info.order;
+		}
+
+		SceneTemplateInfo(const StringName &p_name = "", const String &p_path = "", int p_order = 0) {
+			name = p_name;
+			path = p_path;
+			order = p_order;
+		}
+	};
+
+	HashMap<StringName, SceneTemplateInfo *> scene_template_map;
+	List<SceneTemplateInfo> scene_template_cache;
+	bool updating_scene_template;
+	int number_of_scene_templates;
+	String selected_scene_template;
+
+	Tree *tree;
+	EditorLineEditFileChooser *scene_template_add_path;
+	LineEdit *scene_template_add_name;
+
+	bool _scene_template_name_is_valid(const String &p_name, String *r_error = NULL);
+
+	void _scene_template_add();
+	void _scene_template_selected();
+	void _scene_template_edited();
+	void _scene_template_button_pressed(Object *p_item, int p_column, int p_button);
+	void _scene_template_activated();
+	void _scene_template_open(const String &fpath);
+	void _scene_template_file_callback(const String &p_path);
+	Node *_create_scene_template(const String &p_path);
+
+	Variant get_drag_data_fw(const Point2 &p_point, Control *p_control);
+	bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_control) const;
+	void drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_control);
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	void update_scene_templates();
+	void scene_template_add(const String &p_name, const String &p_path);
+	void scene_template_remove(const String &p_name);
+
+	void set_template_name(const String &p_name);
+	String get_template_name() const;
+	void set_template_path(const String &p_path);
+	String get_template_path() const;
+	LineEdit *get_name_line_edit() { return scene_template_add_name; }
+	LineEdit *get_path_line_edit() { return scene_template_add_path->get_line_edit(); }
+
+	void get_scene_template_list(List<StringName> *p_list) const { scene_template_map.get_key_list(p_list); }
+	bool scene_template_exists(const StringName &p_name) const { return scene_template_map.has(p_name); }
+	String scene_template_get_path(const StringName &p_name) const { return scene_template_map.has(p_name) && scene_template_map[p_name] ? scene_template_map[p_name]->path : String(); }
+	StringName scene_template_get_base(const StringName &p_name) const;
+	StringName scene_template_get_base_file(const String &p_path) const;
+	StringName scene_template_get_name(const String &p_path) const;
+	Node *scene_template_instance(const StringName &p_name);
+	bool scene_template_is_parent(const StringName &p_name, const StringName &p_inherits);
+
+	EditorSceneTemplateSettings();
+	~EditorSceneTemplateSettings();
+};
+
+#endif // EDITOR_SCENE_TEMPLATE_SETTINGS_H
diff --git a/editor/filesystem_dock.cpp b/editor/filesystem_dock.cpp
index 828e608fa4cf..ab56c5058d92 100644
--- a/editor/filesystem_dock.cpp
+++ b/editor/filesystem_dock.cpp
@@ -1125,12 +1125,14 @@ void FileSystemDock::_update_dependencies_after_move(const Map<String, String> &
 void FileSystemDock::_update_project_settings_after_move(const Map<String, String> &p_renames) const {
 
 	// Find all project settings of type FILE and replace them if needed
-	const Map<StringName, PropertyInfo> prop_info = ProjectSettings::get_singleton()->get_custom_property_info();
-	for (const Map<StringName, PropertyInfo>::Element *E = prop_info.front(); E; E = E->next()) {
-		if (E->get().hint == PROPERTY_HINT_FILE) {
-			String old_path = GLOBAL_GET(E->key());
+	List<PropertyInfo> prop_info;
+	ProjectSettings::get_singleton()->get_property_list(&prop_info);
+	for (const List<PropertyInfo>::Element *E = prop_info.front(); E; E = E->next()) {
+		String name = E->get().name;
+		if (E->get().hint == PROPERTY_HINT_FILE || name.find("scene_template/") != -1) {
+			String old_path = GLOBAL_GET(name);
 			if (p_renames.has(old_path)) {
-				ProjectSettings::get_singleton()->set_setting(E->key(), p_renames[old_path]);
+				ProjectSettings::get_singleton()->set_setting(name, p_renames[old_path]);
 			}
 		};
 	}
@@ -1574,7 +1576,21 @@ void FileSystemDock::_file_option(int p_option, const Vector<String> p_selected)
 				duplicate_dialog_text->grab_focus();
 			}
 		} break;
-
+		case FILE_SCENE_TEMPLATE: {
+			int idx = files->get_current();
+			if (idx < 0 || idx >= files->get_item_count())
+				break;
+			ProjectSettingsEditor *ps = EditorNode::get_singleton()->get_project_settings();
+			ps->popup_project_settings();
+			TabContainer *tabs = ps->get_tabs();
+			EditorSceneTemplateSettings *scene_templates = Object::cast_to<EditorSceneTemplateSettings>(tabs->get_node(NodePath("SceneTemplates")));
+			if (!scene_templates)
+				return;
+			String path = files->get_item_metadata(idx);
+			tabs->set_current_tab(scene_templates->get_index());
+			scene_templates->set_template_path(path);
+			scene_templates->get_name_line_edit()->grab_focus();
+		} break;
 		case FILE_INFO: {
 
 		} break;
@@ -2013,6 +2029,9 @@ void FileSystemDock::_file_and_folders_fill_popup(PopupMenu *p_popup, Vector<Str
 		if (all_files_scenes && filenames.size() >= 1) {
 			p_popup->add_item(TTR("Open Scene(s)"), FILE_OPEN);
 			p_popup->add_item(TTR("Instance"), FILE_INSTANCE);
+			if (filenames.size() == 1) {
+				p_popup->add_item(TTR("Create Scene Template..."), FILE_SCENE_TEMPLATE);
+			}
 			p_popup->add_separator();
 		}
 
diff --git a/editor/filesystem_dock.h b/editor/filesystem_dock.h
index df6fa5f9d24e..f01de979d5f5 100644
--- a/editor/filesystem_dock.h
+++ b/editor/filesystem_dock.h
@@ -94,6 +94,7 @@ class FileSystemDock : public VBoxContainer {
 		FILE_SHOW_IN_EXPLORER,
 		FILE_COPY_PATH,
 		FILE_NEW_RESOURCE,
+		FILE_SCENE_TEMPLATE,
 		FOLDER_EXPAND_ALL,
 		FOLDER_COLLAPSE_ALL,
 	};
diff --git a/editor/project_settings_editor.cpp b/editor/project_settings_editor.cpp
index 7a68646f40f4..cbe6380d8271 100644
--- a/editor/project_settings_editor.cpp
+++ b/editor/project_settings_editor.cpp
@@ -804,6 +804,7 @@ void ProjectSettingsEditor::popup_project_settings() {
 	_update_translations();
 	autoload_settings->update_autoload();
 	plugin_settings->update_plugins();
+	scene_template_settings->update_scene_templates();
 }
 
 void ProjectSettingsEditor::update_plugins() {
@@ -2023,6 +2024,11 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) {
 	plugin_settings->set_name(TTR("Plugins"));
 	tab_container->add_child(plugin_settings);
 
+	scene_template_settings = memnew(EditorSceneTemplateSettings);
+	scene_template_settings->set_name(TTR("SceneTemplates"));
+	tab_container->add_child(scene_template_settings);
+	scene_template_settings->connect("scene_template_changed", this, "_settings_changed");
+
 	timer = memnew(Timer);
 	timer->set_wait_time(1.5);
 	timer->connect("timeout", ProjectSettings::get_singleton(), "save");
diff --git a/editor/project_settings_editor.h b/editor/project_settings_editor.h
index 1344da1de737..ca59d2b57638 100644
--- a/editor/project_settings_editor.h
+++ b/editor/project_settings_editor.h
@@ -35,6 +35,7 @@
 #include "editor/editor_autoload_settings.h"
 #include "editor/editor_data.h"
 #include "editor/editor_plugin_settings.h"
+#include "editor/editor_scene_template_settings.h"
 #include "editor/editor_sectioned_inspector.h"
 #include "scene/gui/dialogs.h"
 #include "scene/gui/tab_container.h"
@@ -111,6 +112,8 @@ class ProjectSettingsEditor : public AcceptDialog {
 
 	EditorPluginSettings *plugin_settings;
 
+	EditorSceneTemplateSettings *scene_template_settings;
+
 	void _item_selected(const String &);
 	void _item_adds(String);
 	void _item_add();
@@ -189,6 +192,7 @@ class ProjectSettingsEditor : public AcceptDialog {
 	void update_plugins();
 
 	EditorAutoloadSettings *get_autoload_settings() { return autoload_settings; }
+	EditorSceneTemplateSettings *get_scene_template_settings() { return scene_template_settings; }
 
 	TabContainer *get_tabs();
 
diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp
index fe438236c906..49550386106d 100644
--- a/editor/scene_tree_dock.cpp
+++ b/editor/scene_tree_dock.cpp
@@ -106,6 +106,8 @@ void SceneTreeDock::_unhandled_key_input(Ref<InputEvent> p_event) {
 		_tool_selected(TOOL_MERGE_FROM_SCENE);
 	} else if (ED_IS_SHORTCUT("scene_tree/save_branch_as_scene", p_event)) {
 		_tool_selected(TOOL_NEW_SCENE_FROM);
+	} else if (ED_IS_SHORTCUT("scene_tree/create_scene_template", p_event)) {
+		_tool_selected(TOOL_SCENE_CREATE_TEMPLATE);
 	} else if (ED_IS_SHORTCUT("scene_tree/delete_no_confirm", p_event)) {
 		_tool_selected(TOOL_ERASE, true);
 	} else if (ED_IS_SHORTCUT("scene_tree/copy_node_path", p_event)) {
@@ -787,12 +789,30 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
 			if (e) {
 				Node *node = e->get();
 				if (node) {
-					if (node && node->get_scene_inherited_state().is_valid()) {
+					if (node->get_scene_inherited_state().is_valid()) {
 						scene_tree->emit_signal("open", node->get_scene_inherited_state()->get_path());
 					}
 				}
 			}
 		} break;
+		case TOOL_SCENE_CREATE_TEMPLATE: {
+			List<Node *> selection = editor_selection->get_selected_node_list();
+			List<Node *>::Element *e = selection.front();
+			if (e) {
+				Node *node = e->get();
+				if (node) {
+					ProjectSettingsEditor *ps = EditorNode::get_singleton()->get_project_settings();
+					ps->popup_project_settings();
+					TabContainer *tabs = ps->get_tabs();
+					EditorSceneTemplateSettings *scene_templates = Object::cast_to<EditorSceneTemplateSettings>(tabs->get_node(NodePath("SceneTemplates")));
+					if (!scene_templates)
+						return;
+					tabs->set_current_tab(scene_templates->get_index());
+					scene_templates->set_template_path(node->get_filename());
+					scene_templates->get_name_line_edit()->grab_focus();
+				}
+			}
+		} break;
 		case TOOL_CREATE_2D_SCENE:
 		case TOOL_CREATE_3D_SCENE:
 		case TOOL_CREATE_USER_INTERFACE:
@@ -1664,6 +1684,18 @@ void SceneTreeDock::_create() {
 
 		Object *c = create_dialog->instance_selected();
 
+		String scene_template = create_dialog->get_scene_template_cache();
+		if (!c && scene_template != "") {
+			if (!edited_scene) {
+				EditorNode::get_singleton()->load_scene(scene_template, false, true);
+				return;
+			}
+			Vector<String> scenes;
+			scenes.push_back(scene_template);
+			instance_scenes(scenes, parent);
+			return;
+		}
+
 		ERR_FAIL_COND(!c);
 		Node *child = Object::cast_to<Node>(c);
 		ERR_FAIL_COND(!child);
@@ -2094,13 +2126,15 @@ void SceneTreeDock::_tree_rmb(const Vector2 &p_menu_pos) {
 	}
 	if (selection.size() == 1) {
 
+		bool is_external = (selection[0]->get_filename() != "");
 		menu->add_icon_shortcut(get_icon("NewRoot", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/make_root"), TOOL_MAKE_ROOT);
 		menu->add_separator();
 		menu->add_icon_shortcut(get_icon("Blend", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/merge_from_scene"), TOOL_MERGE_FROM_SCENE);
 		menu->add_icon_shortcut(get_icon("CreateNewSceneFrom", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/save_branch_as_scene"), TOOL_NEW_SCENE_FROM);
+		if (is_external)
+			menu->add_icon_shortcut(get_icon("CreateNewSceneFrom", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/create_scene_template"), TOOL_SCENE_CREATE_TEMPLATE);
 		menu->add_separator();
 		menu->add_icon_shortcut(get_icon("CopyNodePath", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/copy_node_path"), TOOL_COPY_NODE_PATH);
-		bool is_external = (selection[0]->get_filename() != "");
 		if (is_external) {
 			bool is_inherited = selection[0]->get_scene_inherited_state() != NULL;
 			bool is_top_level = selection[0]->get_owner() == NULL;
@@ -2349,6 +2383,7 @@ SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSel
 	ED_SHORTCUT("scene_tree/make_root", TTR("Make Scene Root"));
 	ED_SHORTCUT("scene_tree/merge_from_scene", TTR("Merge From Scene"));
 	ED_SHORTCUT("scene_tree/save_branch_as_scene", TTR("Save Branch as Scene"));
+	ED_SHORTCUT("scene_tree/create_scene_template", TTR("Create Scene Template"));
 	ED_SHORTCUT("scene_tree/copy_node_path", TTR("Copy Node Path"), KEY_MASK_CMD | KEY_C);
 	ED_SHORTCUT("scene_tree/delete_no_confirm", TTR("Delete (No Confirm)"), KEY_MASK_SHIFT | KEY_DELETE);
 	ED_SHORTCUT("scene_tree/delete", TTR("Delete"), KEY_DELETE);
diff --git a/editor/scene_tree_dock.h b/editor/scene_tree_dock.h
index 3939f4f36125..125ceb4d9d83 100644
--- a/editor/scene_tree_dock.h
+++ b/editor/scene_tree_dock.h
@@ -84,6 +84,7 @@ class SceneTreeDock : public VBoxContainer {
 		TOOL_SCENE_CLEAR_INHERITANCE,
 		TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM,
 		TOOL_SCENE_OPEN_INHERITED,
+		TOOL_SCENE_CREATE_TEMPLATE,
 
 		TOOL_CREATE_2D_SCENE,
 		TOOL_CREATE_3D_SCENE,
diff --git a/modules/class_type/SCsub b/modules/class_type/SCsub
new file mode 100644
index 000000000000..04049beebe0d
--- /dev/null
+++ b/modules/class_type/SCsub
@@ -0,0 +1,5 @@
+# SCsub
+Import('env')
+
+module_env = env.Clone()
+module_env.add_source_files(env.modules_sources,"*.cpp")
diff --git a/modules/class_type/class_type.cpp b/modules/class_type/class_type.cpp
new file mode 100644
index 000000000000..3b8c94c2421e
--- /dev/null
+++ b/modules/class_type/class_type.cpp
@@ -0,0 +1,801 @@
+/*************************************************************************/
+/*  class_type.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "class_type.h"
+
+#include "core/io/resource_loader.h"
+#include "core/os/file_access.h"
+#include "editor_node.h"
+#include "scene/resources/packed_scene.h"
+
+StringName ClassType::_get_name_by_path(const String &p_path, Source *r_source) {
+	if (!is_valid_path(p_path)) {
+		return StringName();
+	}
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		StringName name = EditorNode::get_editor_data().script_class_get_name(p_path);
+		if (r_source && name != StringName())
+			*r_source = SOURCE_SCRIPT;
+		return name;
+	}
+#else
+	Ref<Script> script = ResourceLoader::load(p_path, "Script");
+	if (script.is_valid()) {
+		StringName name = script->get_language()->get_global_class_name(p_path);
+		if (r_source && name != StringName())
+			*r_source = SOURCE_SCRIPT;
+		return name;
+	}
+#endif
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		StringName name = EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->scene_template_get_name(p_path);
+		if (r_source && name != StringName())
+			*r_source = SOURCE_SCENE;
+		return name;
+	}
+#endif
+	if (r_source)
+		*r_source = SOURCE_NONE;
+	return StringName();
+}
+
+void ClassType::_update_path_by_name() {
+	if (_source_dirty)
+		_update_source_by_name();
+	if (_name == "") { //shortcut
+		_path = "";
+	} else if (is_scene_template()) {
+#ifdef TOOLS_ENABLED
+		if (Engine::get_singleton()->is_editor_hint())
+			_path = EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->scene_template_get_path(_name);
+#else
+		_path = "";
+#endif
+	} else if (is_script_class()) {
+		_path = ScriptServer::get_global_class_path(_name);
+	} else {
+		_path = "";
+	}
+}
+
+void ClassType::_update_source_by_name() {
+	if (!_source_dirty)
+		return;
+
+	_source_dirty = false;
+	_source = SOURCE_NONE;
+
+	if (_name == StringName()) {
+		return;
+	} else if (ClassDB::class_exists(_name)) {
+		_source = SOURCE_ENGINE;
+	} else if (ScriptServer::is_global_class(_name)) {
+		_source = SOURCE_SCRIPT;
+	} else {
+#ifdef TOOLS_ENABLED
+		if (Engine::get_singleton()->is_editor_hint()) {
+			if (EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->scene_template_exists(_name)) {
+				_source = SOURCE_SCENE;
+			}
+		}
+#endif
+	}
+}
+
+Array ClassType::_get_engine_class_list() const {
+	List<StringName> names;
+	get_engine_class_list(&names);
+	names.sort_custom<StringName::AlphCompare>();
+	Array ret;
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+Array ClassType::_get_script_class_list() const {
+	List<StringName> names;
+	get_script_class_list(&names);
+	names.sort_custom<StringName::AlphCompare>();
+	Array ret;
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+Array ClassType::_get_scene_template_list() const {
+	List<StringName> names;
+	get_scene_template_list(&names);
+	names.sort_custom<StringName::AlphCompare>();
+	Array ret;
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+Array ClassType::_get_class_list() const {
+	List<StringName> names;
+	get_class_list(&names);
+	names.sort_custom<StringName::AlphCompare>();
+	Array ret;
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+Array ClassType::_get_inheritors_list() const {
+	List<StringName> names;
+	get_inheritors_list(_name, &names);
+	names.sort_custom<StringName::AlphCompare>();
+	Array ret;
+	for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+Array ClassType::_get_class_signal_list() const {
+	List<MethodInfo> list;
+	get_class_signal_list(&list);
+	Array ret;
+	for (List<MethodInfo>::Element *E = list.front(); E; E = E->next()) {
+		ret.push_back(E->get().name);
+	}
+	return ret;
+}
+
+Array ClassType::_get_class_method_list() const {
+	List<MethodInfo> list;
+	get_class_method_list(&list);
+	Array ret;
+	for (List<MethodInfo>::Element *E = list.front(); E; E = E->next()) {
+		ret.push_back(E->get().name);
+	}
+	return ret;
+}
+
+Array ClassType::_get_class_property_list() const {
+	List<PropertyInfo> list;
+	get_class_property_list(&list);
+	Array ret;
+	for (List<PropertyInfo>::Element *E = list.front(); E; E = E->next()) {
+		ret.push_back(E->get().name);
+	}
+	return ret;
+}
+
+Array ClassType::_get_class_constant_list() const {
+	List<String> list;
+	get_class_constant_list(&list);
+	Array ret;
+	for (List<String>::Element *E = list.front(); E; E = E->next()) {
+		ret.push_back(E->get());
+	}
+	return ret;
+}
+
+StringName ClassType::get_name_by_path(const String &p_path) {
+	return _get_name_by_path(p_path, NULL);
+}
+
+StringName ClassType::get_name_by_object(const Object *p_object, String *r_path) {
+	if (!p_object)
+		return StringName();
+
+	const Node *n = Object::cast_to<Node>(p_object);
+	if (n && !n->get_filename().empty()) {
+		if (r_path)
+			*r_path = n->get_filename();
+		return get_name_by_path(n->get_filename());
+	}
+
+	Ref<Script> s = p_object->get_script();
+	if (s.is_null() && p_object->is_class("Script")) {
+		s = p_object;
+	}
+
+	if (s.is_valid()) {
+		if (r_path)
+			*r_path = s->get_path();
+		return get_name_by_path(s->get_path());
+	}
+
+	return p_object->get_class();
+}
+
+RES ClassType::get_scene_root_script(const String &p_path) {
+	if (!is_valid_path(p_path))
+		return NULL;
+	Ref<PackedScene> scene = ResourceLoader::load(p_path, "PackedScene");
+	if (scene.is_null())
+		return NULL;
+	Ref<SceneState> state = scene->get_state();
+	if (state.is_null())
+		return NULL;
+	for (int i = 0; i < state->get_node_property_count(0); i++) {
+		String name = state->get_node_property_name(0, i);
+		if ("script" == name) {
+			return state->get_node_property_value(0, i);
+		}
+	}
+	return NULL;
+}
+
+RES ClassType::get_scene_root_scene(const String &p_path) {
+	if (!is_valid_path(p_path))
+		return NULL;
+	Ref<PackedScene> scene = ResourceLoader::load(p_path, "PackedScene");
+	if (scene.is_null())
+		return NULL;
+	Ref<SceneState> state = scene->get_state();
+	if (state.is_null())
+		return NULL;
+	return state->get_node_instance(0);
+}
+
+void ClassType::set_name(const String &p_name) {
+	_name = p_name;
+	_source_dirty = true;
+	_update_path_by_name();
+}
+
+String ClassType::get_name() const {
+	return _name;
+}
+
+void ClassType::set_path(const String &p_path) {
+	if (p_path == _path)
+		return;
+	_path = p_path;
+	_source_dirty = true;
+	_name = get_name_by_path(_path);
+}
+
+String ClassType::get_path() const {
+	return _path;
+}
+
+bool ClassType::is_valid_path(const String &p_path) {
+	return !p_path.empty() && FileAccess::exists(p_path);
+}
+
+bool ClassType::is_engine_class() const {
+	return _source == SOURCE_ENGINE;
+}
+
+bool ClassType::is_script_class() const {
+	return _source == SOURCE_SCRIPT;
+}
+
+bool ClassType::is_scene_template() const {
+	return _source == SOURCE_SCENE;
+}
+
+bool ClassType::exists() const {
+	return _source != SOURCE_NONE;
+}
+
+bool ClassType::is_non_class_res() const {
+	return !_path.empty() && _name == StringName();
+}
+
+RES ClassType::get_res() const {
+	if (!has_valid_path())
+		return NULL;
+	return ResourceLoader::load(_path);
+}
+
+RES ClassType::get_editor_icon() const {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint() && exists())
+		return EditorNode::get_singleton()->get_class_icon(_name);
+#endif
+	return NULL;
+}
+
+StringName ClassType::get_engine_parent() const {
+	if (is_engine_class())
+		return ClassDB::get_parent_class(_name);
+	if (is_script_class())
+		return ScriptServer::get_global_class_base(_name);
+	if (is_scene_template()) {
+#ifdef TOOLS_ENABLED
+		if (Engine::get_singleton()->is_editor_hint()) {
+			Ref<PackedScene> scene = get_res();
+			if (scene.is_null())
+				return StringName();
+			Ref<SceneState> state = scene->get_state();
+			if (state.is_null())
+				return StringName();
+			return state->get_node_type(0);
+		}
+#endif
+	}
+	return StringName();
+}
+
+StringName ClassType::get_script_parent() const {
+	if (is_engine_class())
+		return StringName();
+	if (is_script_class()) {
+
+		Ref<Script> script = get_res();
+		if (script.is_null())
+			return StringName();
+
+		script = script->get_base_script();
+		while (script.is_valid()) {
+			Ref<ClassType> base = ClassType::from_object(script.operator->());
+			if (base->is_script_class())
+				return base->get_name();
+			script = script->get_base_script();
+		}
+
+		return get_engine_parent();
+	}
+	if (is_scene_template()) {
+		Ref<Script> script = get_scene_root_script(_path);
+		while (script.is_valid()) {
+			StringName tmp = get_name_by_path(script->get_path());
+			if (StringName() != tmp)
+				return tmp;
+			script = script->get_base_script();
+		}
+	}
+	return StringName();
+}
+
+StringName ClassType::get_scene_parent() const {
+	if (!is_scene_template())
+		return StringName();
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		EditorSceneTemplateSettings *templates = EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings();
+		return templates->scene_template_exists(_name) ? templates->scene_template_get_base(_name) : StringName();
+	}
+#endif
+	return StringName();
+}
+
+StringName ClassType::get_parent_class() const {
+	StringName ret = get_scene_parent();
+	if (StringName() != ret)
+		return ret;
+	else {
+		ret = get_script_parent();
+		if (StringName() != ret)
+			return ret;
+		else {
+			ret = get_engine_parent();
+			return ret;
+		}
+	}
+}
+
+Array ClassType::get_parents() const {
+	Array ret;
+	ret.resize(3);
+	ret[0] = get_engine_parent();
+	ret[1] = get_script_parent();
+	ret[2] = get_scene_parent();
+	return ret;
+}
+
+Ref<ClassType> ClassType::get_type_parent() const {
+	switch (_source) {
+		case SOURCE_ENGINE:
+			return ClassType::from_name(get_engine_parent());
+		case SOURCE_SCRIPT: {
+			Ref<Script> script = get_res();
+			script = script->get_base_script();
+			if (script.is_valid())
+				return ClassType::from_path(script->get_path());
+			else
+				return ClassType::from_name(get_engine_class());
+		} break;
+		case SOURCE_SCENE: {
+			Ref<PackedScene> scene = get_scene_root_scene(_path);
+			if (scene.is_valid())
+				return ClassType::from_path(scene->get_path());
+			else
+				return ClassType::from_name(get_engine_class());
+		} break;
+		case SOURCE_NONE:
+			return Ref<ClassType>();
+	}
+	return Ref<ClassType>();
+}
+
+RES ClassType::get_type_script() const {
+	RES res = get_res();
+	if (res.is_valid()) {
+		Ref<Script> script = res;
+		if (script.is_null())
+			script = get_scene_root_script(_path);
+		return script;
+	}
+	return res;
+}
+
+StringName ClassType::get_engine_class() const {
+	if (has_valid_path())
+		return get_engine_parent();
+	else if (is_engine_class())
+		return _name;
+	return StringName();
+}
+
+bool ClassType::is_engine_parent(const StringName &p_class) const {
+	StringName parent = get_engine_parent();
+	return ClassDB::class_exists(parent) && ClassDB::is_parent_class(parent, p_class);
+}
+
+bool ClassType::is_script_parent(const StringName &p_class) const {
+	if (is_engine_class())
+		return false;
+
+	Ref<Script> script;
+	if (is_script_class())
+		script = get_res();
+	else if (is_scene_template())
+		script = get_scene_root_script(_path);
+	else if (is_non_class_res()) {
+		for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+			List<String> exts;
+			for (int i = 0; i < ScriptServer::get_language_count(); i++)
+				ScriptServer::get_language(i)->get_recognized_extensions(&exts);
+			if (exts.find(_path.get_extension()))
+				script = get_res();
+		}
+	}
+
+	while (script.is_valid()) {
+		Ref<ClassType> script_type = ClassType::from_object(script.operator->());
+		if (script_type->is_script_class() && script_type->get_name() == p_class)
+			return true;
+		script = script->get_base_script();
+	}
+	return false;
+}
+
+bool ClassType::is_scene_parent(const StringName &p_class) const {
+	if (is_engine_class() || is_script_class())
+		return false;
+	Ref<PackedScene> scene = get_scene_root_scene(_path);
+	while (scene.is_valid()) {
+		Ref<ClassType> scene_type = ClassType::from_path(scene->get_path());
+		if (scene_type->is_scene_template() && scene_type->get_name() == p_class)
+			return true;
+		scene = get_scene_root_scene(scene->get_path());
+	}
+	return false;
+}
+
+bool ClassType::is_parent_class(const StringName &p_class) const {
+	return is_engine_parent(p_class) || is_script_parent(p_class) || is_scene_parent(p_class);
+}
+
+bool ClassType::can_instance() const {
+	if (is_engine_class())
+		return ClassDB::can_instance(_name);
+	StringName base = get_engine_parent();
+	if (StringName() != base)
+		return ClassDB::can_instance(base);
+	return false;
+}
+
+Object *ClassType::instance() const {
+	if (is_engine_class())
+		return ClassDB::instance(_name);
+	if (!has_valid_path())
+		return NULL;
+	if (is_script_class()) {
+		RES res = get_res();
+		Object *obj = ClassType::from_name(get_engine_parent())->instance();
+		if (!obj)
+			return NULL;
+		obj->set_script(res.get_ref_ptr());
+		return obj;
+	}
+	if (is_scene_template()) {
+		Ref<PackedScene> scene = get_res();
+		if (scene.is_null())
+			return NULL;
+		return scene->instance();
+	}
+	if (is_non_class_res()) {
+		RES res = ResourceLoader::load(_path);
+		Ref<Script> script = res;
+		if (script.is_valid()) {
+			StringName base = script->get_instance_base_type();
+			if (StringName() == base)
+				return NULL;
+			Object *obj = ClassDB::instance(base);
+			obj->set_script(script.get_ref_ptr());
+		}
+		Ref<PackedScene> scene = res;
+		if (scene.is_valid()) {
+			return scene->instance();
+		}
+	}
+	return NULL;
+}
+
+void ClassType::get_class_list(List<StringName> *p_list) {
+	get_engine_class_list(p_list);
+	get_script_class_list(p_list);
+	get_scene_template_list(p_list);
+}
+
+void ClassType::get_engine_class_list(List<StringName> *p_list) {
+	ClassDB::get_class_list(p_list);
+}
+
+void ClassType::get_script_class_list(List<StringName> *p_list) {
+	ScriptServer::get_global_class_list(p_list);
+}
+
+void ClassType::get_scene_template_list(List<StringName> *p_list) {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint())
+		EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->get_scene_template_list(p_list);
+#endif
+}
+
+void ClassType::get_inheritors_list(const StringName &p_class, List<StringName> *p_list) {
+	Ref<ClassType> type = ClassType::from_name(p_class);
+	if (type->is_engine_class()) {
+		List<StringName> names;
+		ClassDB::get_class_list(&names);
+		for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+			if (ClassDB::is_parent_class(E->get(), p_class))
+				p_list->push_back(E->get());
+		}
+	}
+	RES res = type->get_res();
+	Ref<Script> script = res;
+	if (script.is_valid()) {
+		Ref<ClassType> ancestor_script = ClassType::from_name(type->get_script_parent());
+		if (ancestor_script.is_valid() && ancestor_script->has_valid_path()) {
+			List<StringName> names;
+			ScriptServer::get_global_class_list(&names);
+			for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+				Ref<ClassType> script_type = ClassType::from_name(E->get());
+				if (script_type->is_parent_class(p_class))
+					p_list->push_back(E->get());
+			}
+		}
+	}
+	Ref<PackedScene> scene = res;
+	if (scene.is_valid()) {
+		Ref<ClassType> ancestor_scene = ClassType::from_name(type->get_scene_parent());
+		if (ancestor_scene.is_valid() && ancestor_scene->has_valid_path()) {
+			List<StringName> names;
+#ifdef TOOLS_ENABLED
+			if (Engine::get_singleton()->is_editor_hint())
+				EditorNode::get_singleton()->get_project_settings()->get_scene_template_settings()->get_scene_template_list(p_list);
+#endif
+			for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
+				Ref<ClassType> scene_type = ClassType::from_name(E->get());
+				if (scene_type->is_parent_class(p_class))
+					p_list->push_back(E->get());
+			}
+		}
+	}
+}
+
+bool ClassType::class_has_signal(const StringName &p_signal) const {
+	Ref<Script> script = get_type_script();
+	if (script.is_valid() && script->has_script_signal(p_signal))
+		return true;
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return false;
+	return ClassDB::has_signal(base, p_signal);
+}
+
+bool ClassType::class_has_method(const StringName &p_method) const {
+	Ref<Script> script = get_type_script();
+	if (script.is_valid() && script->has_method(p_method))
+		return true;
+	StringName base = _name;
+	if (!is_engine_class())
+		base = get_engine_parent();
+	return ClassDB::has_method(base, p_method);
+}
+
+bool ClassType::class_has_property(const StringName &p_property) const {
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		List<PropertyInfo> plist;
+		script->get_script_property_list(&plist);
+		for (List<PropertyInfo>::Element *E = plist.front(); E; E = E->next()) {
+			if (E->get().name == p_property)
+				return true;
+		}
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return false;
+	return ClassDB::has_property(base, p_property);
+}
+
+bool ClassType::class_has_constant(const StringName &p_constant) const {
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		Map<StringName, Variant> map;
+		script->get_constants(&map);
+		if (map.has(p_constant))
+			return true;
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return false;
+	List<String> list;
+	ClassDB::get_integer_constant_list(base, &list);
+	return list.find(p_constant);
+}
+
+void ClassType::get_class_signal_list(List<MethodInfo> *p_signals) const {
+	ERR_FAIL_COND(!p_signals);
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		script->get_script_signal_list(p_signals);
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return;
+	ClassDB::get_signal_list(base, p_signals);
+}
+
+void ClassType::get_class_method_list(List<MethodInfo> *p_methods) const {
+	ERR_FAIL_COND(!p_methods);
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		script->get_script_method_list(p_methods);
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return;
+	ClassDB::get_method_list(base, p_methods);
+}
+
+void ClassType::get_class_property_list(List<PropertyInfo> *p_properties) const {
+	ERR_FAIL_COND(!p_properties);
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		script->get_script_property_list(p_properties);
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return;
+	ClassDB::get_property_list(base, p_properties);
+}
+
+void ClassType::get_class_constant_list(List<String> *p_constants) const {
+	ERR_FAIL_COND(!p_constants);
+	Ref<Script> script = get_type_script();
+	if (script.is_valid()) {
+		Map<StringName, Variant> map;
+		script->get_constants(&map);
+		for (Map<StringName, Variant>::Element *E = map.front(); E; E = E->next()) {
+			p_constants->push_back(E->key());
+		}
+	}
+	StringName base = get_engine_class();
+	if (!ClassDB::class_exists(base))
+		return;
+	ClassDB::get_integer_constant_list(base, p_constants);
+}
+
+void ClassType::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_name"), &ClassType::get_name);
+	ClassDB::bind_method(D_METHOD("set_name", "name"), &ClassType::set_name);
+	ClassDB::bind_method(D_METHOD("get_path"), &ClassType::get_path);
+	ClassDB::bind_method(D_METHOD("set_path", "path"), &ClassType::set_path);
+	ClassDB::bind_method(D_METHOD("has_valid_path"), &ClassType::has_valid_path);
+
+	ClassDB::bind_method(D_METHOD("is_engine_class"), &ClassType::is_engine_class);
+	ClassDB::bind_method(D_METHOD("is_script_class"), &ClassType::is_script_class);
+	ClassDB::bind_method(D_METHOD("is_scene_template"), &ClassType::is_scene_template);
+	ClassDB::bind_method(D_METHOD("exists"), &ClassType::exists);
+	ClassDB::bind_method(D_METHOD("is_non_class_res"), &ClassType::is_non_class_res);
+
+	ClassDB::bind_method(D_METHOD("get_res"), &ClassType::get_res);
+	ClassDB::bind_method(D_METHOD("get_editor_icon"), &ClassType::get_editor_icon);
+
+	ClassDB::bind_method(D_METHOD("get_engine_parent"), &ClassType::get_engine_parent);
+	ClassDB::bind_method(D_METHOD("get_script_parent"), &ClassType::get_script_parent);
+	ClassDB::bind_method(D_METHOD("get_scene_parent"), &ClassType::get_scene_parent);
+	ClassDB::bind_method(D_METHOD("get_parent_class"), &ClassType::get_parent_class);
+	ClassDB::bind_method(D_METHOD("get_parents"), &ClassType::get_parents);
+
+	ClassDB::bind_method(D_METHOD("get_type_script"), &ClassType::get_type_script);
+	ClassDB::bind_method(D_METHOD("get_engine_class"), &ClassType::get_engine_class);
+
+	ClassDB::bind_method(D_METHOD("is_engine_parent", "p_class"), &ClassType::is_engine_parent);
+	ClassDB::bind_method(D_METHOD("is_script_parent", "p_class"), &ClassType::is_script_parent);
+	ClassDB::bind_method(D_METHOD("is_scene_parent", "p_class"), &ClassType::is_scene_parent);
+	ClassDB::bind_method(D_METHOD("is_parent_class", "p_class"), &ClassType::is_parent_class);
+
+	ClassDB::bind_method(D_METHOD("get_engine_class_list"), &ClassType::_get_engine_class_list);
+	ClassDB::bind_method(D_METHOD("get_script_class_list"), &ClassType::_get_script_class_list);
+	ClassDB::bind_method(D_METHOD("get_scene_template_list"), &ClassType::_get_scene_template_list);
+	ClassDB::bind_method(D_METHOD("get_class_list"), &ClassType::_get_class_list);
+
+	ClassDB::bind_method(D_METHOD("get_inheritors_list"), &ClassType::_get_inheritors_list);
+
+	ClassDB::bind_method(D_METHOD("instance"), &ClassType::instance);
+
+	ClassDB::bind_method(D_METHOD("class_has_signal"), &ClassType::class_has_signal);
+	ClassDB::bind_method(D_METHOD("class_has_method"), &ClassType::class_has_method);
+	ClassDB::bind_method(D_METHOD("class_has_property"), &ClassType::class_has_property);
+	ClassDB::bind_method(D_METHOD("class_has_constant"), &ClassType::class_has_constant);
+
+	ClassDB::bind_method(D_METHOD("get_class_signal_list"), &ClassType::_get_class_signal_list);
+	ClassDB::bind_method(D_METHOD("get_class_method_list"), &ClassType::_get_class_method_list);
+	ClassDB::bind_method(D_METHOD("get_class_property_list"), &ClassType::_get_class_property_list);
+	ClassDB::bind_method(D_METHOD("get_class_constant_list"), &ClassType::_get_class_constant_list);
+
+	ClassDB::bind_method(D_METHOD("become", "p_object"), &ClassType::_become);
+
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "name"), "set_name", "get_name");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "path"), "set_path", "get_path");
+}
+
+Ref<ClassType> ClassType::from_name(const StringName &p_name) {
+	Ref<ClassType> ret = memnew(ClassType);
+	ret->set_name(p_name);
+	return ret;
+}
+
+Ref<ClassType> ClassType::from_path(const String &p_path) {
+	Ref<ClassType> ret = memnew(ClassType);
+	ret->set_path(p_path);
+	return ret;
+}
+
+Ref<ClassType> ClassType::from_object(const Object *p_object) {
+	Ref<ClassType> ret = memnew(ClassType);
+	ret->set_name(get_name_by_object(p_object));
+	return ret;
+}
+
+ClassType::ClassType() {
+	_name = StringName();
+	_path = String();
+	_source = SOURCE_NONE;
+	_source_dirty = false;
+}
diff --git a/modules/class_type/class_type.h b/modules/class_type/class_type.h
new file mode 100644
index 000000000000..df9d76e77b39
--- /dev/null
+++ b/modules/class_type/class_type.h
@@ -0,0 +1,137 @@
+/*************************************************************************/
+/*  class_type.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CLASS_TYPE_H
+#define CLASS_TYPE_H
+
+#include "core/array.h"
+#include "core/reference.h"
+#include "core/resource.h"
+
+class ClassType : public Reference {
+	GDCLASS(ClassType, Reference);
+
+public:
+	enum Source {
+		SOURCE_NONE,
+		SOURCE_ENGINE,
+		SOURCE_SCRIPT,
+		SOURCE_SCENE
+	};
+
+private:
+	StringName _name;
+	String _path;
+	Source _source;
+	bool _source_dirty;
+
+	static StringName _get_name_by_path(const String &p_path, Source *r_source = NULL);
+
+protected:
+	static void _bind_methods();
+
+	void _update_path_by_name();
+	void _update_source_by_name();
+	Array _get_engine_class_list() const;
+	Array _get_script_class_list() const;
+	Array _get_scene_template_list() const;
+	Array _get_class_list() const;
+	Array _get_inheritors_list() const;
+
+	Array _get_class_signal_list() const;
+	Array _get_class_method_list() const;
+	Array _get_class_property_list() const;
+	Array _get_class_constant_list() const;
+
+	void _become(const Object *p_object) { set_name(get_name_by_object(p_object)); }
+
+public:
+	static void get_engine_class_list(List<StringName> *p_list);
+	static void get_script_class_list(List<StringName> *p_list);
+	static void get_scene_template_list(List<StringName> *p_list);
+	static void get_class_list(List<StringName> *p_list);
+	static void get_inheritors_list(const StringName &p_class, List<StringName> *p_list);
+	static StringName get_name_by_path(const String &p_path);
+	static StringName get_name_by_object(const Object *p_object, String *r_path = NULL);
+	static bool is_valid_path(const String &p_path);
+	static RES get_scene_root_script(const String &p_path);
+	static RES get_scene_root_scene(const String &p_path);
+
+	void set_name(const String &p_name);
+	String get_name() const;
+	void set_path(const String &p_path);
+	String get_path() const;
+	bool has_valid_path() const { return is_valid_path(_path); }
+
+	bool is_engine_class() const;
+	bool is_script_class() const;
+	bool is_scene_template() const;
+	bool exists() const;
+
+	bool is_non_class_res() const;
+
+	RES get_res() const;
+	RES get_editor_icon() const;
+
+	StringName get_engine_parent() const;
+	StringName get_script_parent() const;
+	StringName get_scene_parent() const;
+	StringName get_parent_class() const;
+	Array get_parents() const;
+	Ref<ClassType> get_type_parent() const;
+
+	RES get_type_script() const;
+	StringName get_engine_class() const;
+
+	bool is_engine_parent(const StringName &p_class) const;
+	bool is_script_parent(const StringName &p_class) const;
+	bool is_scene_parent(const StringName &p_class) const;
+	bool is_parent_class(const StringName &p_class) const;
+
+	bool can_instance() const;
+	Object *instance() const;
+
+	// only engine classes and Scripts, not ScriptInstances (until generic annotation data is available)
+	bool class_has_signal(const StringName &p_signal) const;
+	bool class_has_method(const StringName &p_method) const;
+	bool class_has_property(const StringName &p_property) const;
+	bool class_has_constant(const StringName &p_constant) const;
+	void get_class_signal_list(List<MethodInfo> *p_signals) const;
+	void get_class_method_list(List<MethodInfo> *p_methods) const;
+	void get_class_property_list(List<PropertyInfo> *p_properties) const;
+	void get_class_constant_list(List<String> *p_constants) const;
+
+	static Ref<ClassType> from_name(const StringName &p_name);
+	static Ref<ClassType> from_path(const String &p_path);
+	static Ref<ClassType> from_object(const Object *p_object);
+	ClassType();
+};
+
+#endif
diff --git a/modules/class_type/config.py b/modules/class_type/config.py
new file mode 100644
index 000000000000..1c8cd12a2dc0
--- /dev/null
+++ b/modules/class_type/config.py
@@ -0,0 +1,5 @@
+def can_build(env, platform):
+    return True
+
+def configure(env):
+    pass
diff --git a/modules/class_type/register_types.cpp b/modules/class_type/register_types.cpp
new file mode 100644
index 000000000000..7b419cdcf566
--- /dev/null
+++ b/modules/class_type/register_types.cpp
@@ -0,0 +1,14 @@
+/* register_types.cpp */
+
+#include "register_types.h"
+
+#include "class_type.h"
+#include "core/class_db.h"
+
+void register_class_type_types() {
+
+	ClassDB::register_class<ClassType>();
+}
+
+void unregister_class_type_types() {
+}
diff --git a/modules/class_type/register_types.h b/modules/class_type/register_types.h
new file mode 100644
index 000000000000..88dcb92cbe3a
--- /dev/null
+++ b/modules/class_type/register_types.h
@@ -0,0 +1,3 @@
+/* register_types.h */
+void register_class_type_types();
+void unregister_class_type_types();