23 files changed, 257 insertions, 244 deletions

diff --git a/core/bind/core_bind.cpp b/core/bind/core_bind.cpp
index 12b892d873..e1adb250e7 100644
--- a/core/bind/core_bind.cpp
+++ b/core/bind/core_bind.cpp
@@ -1316,6 +1316,16 @@ Vector<int> _Geometry::triangulate_polygon(const Vector<Vector2> &p_polygon) {
 	return Geometry::triangulate_polygon(p_polygon);
 }
 
+Vector<Point2> _Geometry::convex_hull_2d(const Vector<Point2> &p_points) {
+
+	return Geometry::convex_hull_2d(p_points);
+}
+
+Vector<Vector3> _Geometry::clip_polygon(const Vector<Vector3> &p_points, const Plane &p_plane) {
+
+	return Geometry::clip_polygon(p_points, p_plane);
+}
+
 Dictionary _Geometry::make_atlas(const Vector<Size2> &p_rects) {
 
 	Dictionary ret;
@@ -1376,6 +1386,8 @@ void _Geometry::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("point_is_inside_triangle", "point", "a", "b", "c"), &_Geometry::point_is_inside_triangle);
 
 	ClassDB::bind_method(D_METHOD("triangulate_polygon", "polygon"), &_Geometry::triangulate_polygon);
+	ClassDB::bind_method(D_METHOD("convex_hull_2d", "points"), &_Geometry::convex_hull_2d);
+	ClassDB::bind_method(D_METHOD("clip_polygon", "points", "plane"), &_Geometry::clip_polygon);
 
 	ClassDB::bind_method(D_METHOD("make_atlas", "sizes"), &_Geometry::make_atlas);
 }
@@ -2580,6 +2592,16 @@ bool _Engine::is_in_physics_frame() const {
 	return Engine::get_singleton()->is_in_physics_frame();
 }
 
+bool _Engine::has_singleton(const String &p_name) const {
+
+	return Engine::get_singleton()->has_singleton(p_name);
+}
+
+Object *_Engine::get_singleton_object(const String &p_name) const {
+
+	return Engine::get_singleton()->get_singleton_object(p_name);
+}
+
 void _Engine::set_editor_hint(bool p_enabled) {
 
 	Engine::get_singleton()->set_editor_hint(p_enabled);
@@ -2609,6 +2631,9 @@ void _Engine::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("is_in_physics_frame"), &_Engine::is_in_physics_frame);
 
+	ClassDB::bind_method(D_METHOD("has_singleton", "name"), &_Engine::has_singleton);
+	ClassDB::bind_method(D_METHOD("get_singleton", "name"), &_Engine::get_singleton_object);
+
 	ClassDB::bind_method(D_METHOD("set_editor_hint", "enabled"), &_Engine::set_editor_hint);
 	ClassDB::bind_method(D_METHOD("is_editor_hint"), &_Engine::is_editor_hint);
 }
diff --git a/core/bind/core_bind.h b/core/bind/core_bind.h
index 7f8c734e36..9be8895443 100644
--- a/core/bind/core_bind.h
+++ b/core/bind/core_bind.h
@@ -363,6 +363,8 @@ public:
 	int get_uv84_normal_bit(const Vector3 &p_vector);
 
 	Vector<int> triangulate_polygon(const Vector<Vector2> &p_polygon);
+	Vector<Point2> convex_hull_2d(const Vector<Point2> &p_points);
+	Vector<Vector3> clip_polygon(const Vector<Vector3> &p_points, const Plane &p_plane);
 
 	Dictionary make_atlas(const Vector<Size2> &p_rects);
 
@@ -668,6 +670,9 @@ public:
 
 	bool is_in_physics_frame() const;
 
+	bool has_singleton(const String &p_name) const;
+	Object *get_singleton_object(const String &p_name) const;
+
 	void set_editor_hint(bool p_enabled);
 	bool is_editor_hint() const;
 
diff --git a/core/dictionary.cpp b/core/dictionary.cpp
index bb2e892951..48e65c734f 100644
--- a/core/dictionary.cpp
+++ b/core/dictionary.cpp
@@ -29,6 +29,7 @@
 /*************************************************************************/
 #include "dictionary.h"
 
+#include "ordered_hash_map.h"
 #include "safe_refcount.h"
 #include "variant.h"
 
@@ -39,22 +40,8 @@ struct _DictionaryVariantHash {
 
 struct DictionaryPrivate {
 
-	struct Data {
-		Variant variant;
-		int order;
-	};
-
 	SafeRefCount refcount;
-	HashMap<Variant, Data, _DictionaryVariantHash> variant_map;
-	int counter;
-};
-
-struct DictionaryPrivateSort {
-
-	bool operator()(const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *A, const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *B) const {
-
-		return A->data.order < B->data.order;
-	}
+	OrderedHashMap<Variant, Variant, _DictionaryVariantHash> variant_map;
 };
 
 void Dictionary::get_key_list(List<Variant> *p_keys) const {
@@ -62,61 +49,45 @@ void Dictionary::get_key_list(List<Variant> *p_keys) const {
 	if (_p->variant_map.empty())
 		return;
 
-	int count = _p->variant_map.size();
-	const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **pairs = (const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **)alloca(count * sizeof(HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *));
-	_p->variant_map.get_key_value_ptr_array(pairs);
-
-	SortArray<const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *, DictionaryPrivateSort> sort;
-	sort.sort(pairs, count);
-
-	for (int i = 0; i < count; i++) {
-		p_keys->push_back(pairs[i]->key);
+	for (OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::Element E = _p->variant_map.front(); E; E = E.next()) {
+		p_keys->push_back(E.key());
 	}
 }
 
 Variant &Dictionary::operator[](const Variant &p_key) {
 
-	DictionaryPrivate::Data *v = _p->variant_map.getptr(p_key);
-
-	if (!v) {
-
-		DictionaryPrivate::Data d;
-		d.order = _p->counter++;
-		_p->variant_map[p_key] = d;
-		v = _p->variant_map.getptr(p_key);
-	}
-	return v->variant;
+	return _p->variant_map[p_key];
 }
 
 const Variant &Dictionary::operator[](const Variant &p_key) const {
 
-	return _p->variant_map[p_key].variant;
+	return _p->variant_map[p_key];
 }
 const Variant *Dictionary::getptr(const Variant &p_key) const {
 
-	const DictionaryPrivate::Data *v = _p->variant_map.getptr(p_key);
-	if (!v)
+	OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::ConstElement E = ((const OrderedHashMap<Variant, Variant, _DictionaryVariantHash> *)&_p->variant_map)->find(p_key);
+
+	if (!E)
 		return NULL;
-	else
-		return &v->variant;
+	return &E.get();
 }
 
 Variant *Dictionary::getptr(const Variant &p_key) {
 
-	DictionaryPrivate::Data *v = _p->variant_map.getptr(p_key);
-	if (!v)
+	OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::Element E = _p->variant_map.find(p_key);
+
+	if (!E)
 		return NULL;
-	else
-		return &v->variant;
+	return &E.get();
 }
 
 Variant Dictionary::get_valid(const Variant &p_key) const {
 
-	DictionaryPrivate::Data *v = _p->variant_map.getptr(p_key);
-	if (!v)
+	OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::ConstElement E = ((const OrderedHashMap<Variant, Variant, _DictionaryVariantHash> *)&_p->variant_map)->find(p_key);
+
+	if (!E)
 		return Variant();
-	else
-		return v->variant;
+	return E.get();
 }
 
 int Dictionary::size() const {
@@ -171,7 +142,6 @@ void Dictionary::_ref(const Dictionary &p_from) const {
 void Dictionary::clear() {
 
 	_p->variant_map.clear();
-	_p->counter = 0;
 }
 
 void Dictionary::_unref() const {
@@ -205,15 +175,10 @@ Array Dictionary::keys() const {
 	if (_p->variant_map.empty())
 		return varr;
 
-	int count = _p->variant_map.size();
-	const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **pairs = (const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **)alloca(count * sizeof(HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *));
-	_p->variant_map.get_key_value_ptr_array(pairs);
-
-	SortArray<const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *, DictionaryPrivateSort> sort;
-	sort.sort(pairs, count);
-
-	for (int i = 0; i < count; i++) {
-		varr[i] = pairs[i]->key;
+	int i = 0;
+	for (OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::Element E = _p->variant_map.front(); E; E = E.next()) {
+		varr[i] = E.key();
+		i++;
 	}
 
 	return varr;
@@ -226,15 +191,10 @@ Array Dictionary::values() const {
 	if (_p->variant_map.empty())
 		return varr;
 
-	int count = _p->variant_map.size();
-	const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **pairs = (const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair **)alloca(count * sizeof(HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *));
-	_p->variant_map.get_key_value_ptr_array(pairs);
-
-	SortArray<const HashMap<Variant, DictionaryPrivate::Data, _DictionaryVariantHash>::Pair *, DictionaryPrivateSort> sort;
-	sort.sort(pairs, count);
-
-	for (int i = 0; i < count; i++) {
-		varr[i] = pairs[i]->data.variant;
+	int i = 0;
+	for (OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::Element E = _p->variant_map.front(); E; E = E.next()) {
+		varr[i] = E.get();
+		i++;
 	}
 
 	return varr;
@@ -242,7 +202,15 @@ Array Dictionary::values() const {
 
 const Variant *Dictionary::next(const Variant *p_key) const {
 
-	return _p->variant_map.next(p_key);
+	if (p_key == NULL) {
+		// caller wants to get the first element
+		return &_p->variant_map.front().key();
+	}
+	OrderedHashMap<Variant, Variant, _DictionaryVariantHash>::Element E = _p->variant_map.find(*p_key);
+
+	if (E && E.next())
+		return &E.next().key();
+	return NULL;
 }
 
 Dictionary Dictionary::copy() const {
@@ -273,7 +241,6 @@ Dictionary::Dictionary() {
 
 	_p = memnew(DictionaryPrivate);
 	_p->refcount.init();
-	_p->counter = 0;
 }
 Dictionary::~Dictionary() {
 
diff --git a/core/engine.cpp b/core/engine.cpp
index c609ae9520..31abcd62ef 100644
--- a/core/engine.cpp
+++ b/core/engine.cpp
@@ -100,6 +100,31 @@ Dictionary Engine::get_version_info() const {
 	return dict;
 }
 
+void Engine::add_singleton(const Singleton &p_singleton) {
+
+	singletons.push_back(p_singleton);
+	singleton_ptrs[p_singleton.name] = p_singleton.ptr;
+}
+
+Object *Engine::get_singleton_object(const String &p_name) const {
+
+	const Map<StringName, Object *>::Element *E = singleton_ptrs.find(p_name);
+	ERR_EXPLAIN("Failed to retrieve non-existent singleton '" + p_name + "'");
+	ERR_FAIL_COND_V(!E, NULL);
+	return E->get();
+};
+
+bool Engine::has_singleton(const String &p_name) const {
+
+	return singleton_ptrs.has(p_name);
+};
+
+void Engine::get_singletons(List<Singleton> *p_singletons) {
+
+	for (List<Singleton>::Element *E = singletons.front(); E; E = E->next())
+		p_singletons->push_back(E->get());
+}
+
 Engine *Engine::singleton = NULL;
 
 Engine *Engine::get_singleton() {
diff --git a/core/engine.h b/core/engine.h
index 3b4979582f..4a573c1539 100644
--- a/core/engine.h
+++ b/core/engine.h
@@ -37,6 +37,17 @@
 
 class Engine {
 
+public:
+	struct Singleton {
+		StringName name;
+		Object *ptr;
+		Singleton(const StringName &p_name = StringName(), Object *p_ptr = NULL)
+			: name(p_name),
+			  ptr(p_ptr) {
+		}
+	};
+
+private:
 	friend class Main;
 
 	uint64_t frames_drawn;
@@ -54,6 +65,9 @@ class Engine {
 	uint64_t _idle_frames;
 	bool _in_physics;
 
+	List<Singleton> singletons;
+	Map<StringName, Object *> singleton_ptrs;
+
 	bool editor_hint;
 
 	static Engine *singleton;
@@ -83,6 +97,11 @@ public:
 	void set_frame_delay(uint32_t p_msec);
 	uint32_t get_frame_delay() const;
 
+	void add_singleton(const Singleton &p_singleton);
+	void get_singletons(List<Singleton> *p_singletons);
+	bool has_singleton(const String &p_name) const;
+	Object *get_singleton_object(const String &p_name) const;
+
 	_FORCE_INLINE_ bool get_use_pixel_snap() const { return _pixel_snap; }
 
 #ifdef TOOLS_ENABLED
diff --git a/core/global_constants.cpp b/core/global_constants.cpp
index 8bddeae69a..7854f342b0 100644
--- a/core/global_constants.cpp
+++ b/core/global_constants.cpp
@@ -435,6 +435,8 @@ void register_global_constants() {
 	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_5);
 	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_6);
 	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_7);
+	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_8);
+	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_9);
 	BIND_GLOBAL_ENUM_CONSTANT(JOY_AXIS_MAX);
 
 	BIND_GLOBAL_ENUM_CONSTANT(JOY_ANALOG_LX);
diff --git a/core/io/config_file.cpp b/core/io/config_file.cpp
index daa6b01d6e..2b60150832 100644
--- a/core/io/config_file.cpp
+++ b/core/io/config_file.cpp
@@ -75,7 +75,7 @@ void ConfigFile::set_value(const String &p_section, const String &p_key, const V
 
 	} else {
 		if (!values.has(p_section)) {
-			values[p_section] = Map<String, Variant>();
+			values[p_section] = OrderedHashMap<String, Variant>();
 		}
 
 		values[p_section][p_key] = p_value;
@@ -106,16 +106,16 @@ bool ConfigFile::has_section_key(const String &p_section, const String &p_key) c
 
 void ConfigFile::get_sections(List<String> *r_sections) const {
 
-	for (const Map<String, Map<String, Variant> >::Element *E = values.front(); E; E = E->next()) {
-		r_sections->push_back(E->key());
+	for (OrderedHashMap<String, OrderedHashMap<String, Variant> >::ConstElement E = values.front(); E; E = E.next()) {
+		r_sections->push_back(E.key());
 	}
 }
 void ConfigFile::get_section_keys(const String &p_section, List<String> *r_keys) const {
 
 	ERR_FAIL_COND(!values.has(p_section));
 
-	for (const Map<String, Variant>::Element *E = values[p_section].front(); E; E = E->next()) {
-		r_keys->push_back(E->key());
+	for (OrderedHashMap<String, Variant>::ConstElement E = values[p_section].front(); E; E = E.next()) {
+		r_keys->push_back(E.key());
 	}
 }
 
@@ -135,17 +135,17 @@ Error ConfigFile::save(const String &p_path) {
 		return err;
 	}
 
-	for (Map<String, Map<String, Variant> >::Element *E = values.front(); E; E = E->next()) {
+	for (OrderedHashMap<String, OrderedHashMap<String, Variant> >::Element E = values.front(); E; E = E.next()) {
 
 		if (E != values.front())
 			file->store_string("\n");
-		file->store_string("[" + E->key() + "]\n\n");
+		file->store_string("[" + E.key() + "]\n\n");
 
-		for (Map<String, Variant>::Element *F = E->get().front(); F; F = F->next()) {
+		for (OrderedHashMap<String, Variant>::Element F = E.get().front(); F; F = F.next()) {
 
 			String vstr;
-			VariantWriter::write_to_string(F->get(), vstr);
-			file->store_string(F->key() + "=" + vstr + "\n");
+			VariantWriter::write_to_string(F.get(), vstr);
+			file->store_string(F.key() + "=" + vstr + "\n");
 		}
 	}
 
diff --git a/core/io/config_file.h b/core/io/config_file.h
index 8ed8a069e4..29bd369a24 100644
--- a/core/io/config_file.h
+++ b/core/io/config_file.h
@@ -30,13 +30,14 @@
 #ifndef CONFIG_FILE_H
 #define CONFIG_FILE_H
 
+#include "core/ordered_hash_map.h"
 #include "reference.h"
 
 class ConfigFile : public Reference {
 
 	GDCLASS(ConfigFile, Reference);
 
-	Map<String, Map<String, Variant> > values;
+	OrderedHashMap<String, OrderedHashMap<String, Variant> > values;
 
 	PoolStringArray _get_sections() const;
 	PoolStringArray _get_section_keys(const String &p_section) const;
diff --git a/core/io/http_client.cpp b/core/io/http_client.cpp
index 46d52384e5..5097898314 100644
--- a/core/io/http_client.cpp
+++ b/core/io/http_client.cpp
@@ -30,6 +30,7 @@
 #include "http_client.h"
 #include "io/stream_peer_ssl.h"
 
+#ifndef JAVASCRIPT_ENABLED
 Error HTTPClient::connect_to_host(const String &p_host, int p_port, bool p_ssl, bool p_verify_host) {
 
 	close();
@@ -405,38 +406,6 @@ Error HTTPClient::poll() {
 	return OK;
 }
 
-Dictionary HTTPClient::_get_response_headers_as_dictionary() {
-
-	List<String> rh;
-	get_response_headers(&rh);
-	Dictionary ret;
-	for (const List<String>::Element *E = rh.front(); E; E = E->next()) {
-		String s = E->get();
-		int sp = s.find(":");
-		if (sp == -1)
-			continue;
-		String key = s.substr(0, sp).strip_edges();
-		String value = s.substr(sp + 1, s.length()).strip_edges();
-		ret[key] = value;
-	}
-
-	return ret;
-}
-
-PoolStringArray HTTPClient::_get_response_headers() {
-
-	List<String> rh;
-	get_response_headers(&rh);
-	PoolStringArray ret;
-	ret.resize(rh.size());
-	int idx = 0;
-	for (const List<String>::Element *E = rh.front(); E; E = E->next()) {
-		ret.set(idx++, E->get());
-	}
-
-	return ret;
-}
-
 int HTTPClient::get_response_body_length() const {
 
 	return body_size;
@@ -612,6 +581,74 @@ Error HTTPClient::_get_http_data(uint8_t *p_buffer, int p_bytes, int &r_received
 	}
 }
 
+void HTTPClient::set_read_chunk_size(int p_size) {
+	ERR_FAIL_COND(p_size < 256 || p_size > (1 << 24));
+	read_chunk_size = p_size;
+}
+
+HTTPClient::HTTPClient() {
+
+	tcp_connection = StreamPeerTCP::create_ref();
+	resolving = IP::RESOLVER_INVALID_ID;
+	status = STATUS_DISCONNECTED;
+	conn_port = 80;
+	body_size = 0;
+	chunked = false;
+	body_left = 0;
+	chunk_left = 0;
+	response_num = 0;
+	ssl = false;
+	blocking = false;
+	read_chunk_size = 4096;
+}
+
+HTTPClient::~HTTPClient() {
+}
+
+#endif // #ifndef JAVASCRIPT_ENABLED
+
+String HTTPClient::query_string_from_dict(const Dictionary &p_dict) {
+	String query = "";
+	Array keys = p_dict.keys();
+	for (int i = 0; i < keys.size(); ++i) {
+		query += "&" + String(keys[i]).http_escape() + "=" + String(p_dict[keys[i]]).http_escape();
+	}
+	query.erase(0, 1);
+	return query;
+}
+
+Dictionary HTTPClient::_get_response_headers_as_dictionary() {
+
+	List<String> rh;
+	get_response_headers(&rh);
+	Dictionary ret;
+	for (const List<String>::Element *E = rh.front(); E; E = E->next()) {
+		String s = E->get();
+		int sp = s.find(":");
+		if (sp == -1)
+			continue;
+		String key = s.substr(0, sp).strip_edges();
+		String value = s.substr(sp + 1, s.length()).strip_edges();
+		ret[key] = value;
+	}
+
+	return ret;
+}
+
+PoolStringArray HTTPClient::_get_response_headers() {
+
+	List<String> rh;
+	get_response_headers(&rh);
+	PoolStringArray ret;
+	ret.resize(rh.size());
+	int idx = 0;
+	for (const List<String>::Element *E = rh.front(); E; E = E->next()) {
+		ret.set(idx++, E->get());
+	}
+
+	return ret;
+}
+
 void HTTPClient::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("connect_to_host", "host", "port", "use_ssl", "verify_host"), &HTTPClient::connect_to_host, DEFVAL(false), DEFVAL(true));
@@ -717,37 +754,3 @@ void HTTPClient::_bind_methods() {
 	BIND_ENUM_CONSTANT(RESPONSE_INSUFFICIENT_STORAGE);
 	BIND_ENUM_CONSTANT(RESPONSE_NOT_EXTENDED);
 }
-
-void HTTPClient::set_read_chunk_size(int p_size) {
-	ERR_FAIL_COND(p_size < 256 || p_size > (1 << 24));
-	read_chunk_size = p_size;
-}
-
-String HTTPClient::query_string_from_dict(const Dictionary &p_dict) {
-	String query = "";
-	Array keys = p_dict.keys();
-	for (int i = 0; i < keys.size(); ++i) {
-		query += "&" + String(keys[i]).http_escape() + "=" + String(p_dict[keys[i]]).http_escape();
-	}
-	query.erase(0, 1);
-	return query;
-}
-
-HTTPClient::HTTPClient() {
-
-	tcp_connection = StreamPeerTCP::create_ref();
-	resolving = IP::RESOLVER_INVALID_ID;
-	status = STATUS_DISCONNECTED;
-	conn_port = 80;
-	body_size = 0;
-	chunked = false;
-	body_left = 0;
-	chunk_left = 0;
-	response_num = 0;
-	ssl = false;
-	blocking = false;
-	read_chunk_size = 4096;
-}
-
-HTTPClient::~HTTPClient() {
-}
diff --git a/core/io/http_client.h b/core/io/http_client.h
index f8a3349e6e..db5dd115bd 100644
--- a/core/io/http_client.h
+++ b/core/io/http_client.h
@@ -131,6 +131,7 @@ public:
 	};
 
 private:
+#ifndef JAVASCRIPT_ENABLED
 	Status status;
 	IP::ResolverID resolving;
 	int conn_port;
@@ -152,13 +153,18 @@ private:
 
 	int response_num;
 	Vector<String> response_headers;
+	int read_chunk_size;
+
+	Error _get_http_data(uint8_t *p_buffer, int p_bytes, int &r_received);
+
+#else
+#include "platform/javascript/http_client.h.inc"
+#endif
 
-	static void _bind_methods();
 	PoolStringArray _get_response_headers();
 	Dictionary _get_response_headers_as_dictionary();
-	int read_chunk_size;
 
-	Error _get_http_data(uint8_t *p_buffer, int p_bytes, int &r_received);
+	static void _bind_methods();
 
 public:
 	//Error connect_and_get(const String& p_url,bool p_verify_host=true); //connects to a full url and perform request
diff --git a/core/math/a_star.cpp b/core/math/a_star.cpp
index f43af49754..7e26761abf 100644
--- a/core/math/a_star.cpp
+++ b/core/math/a_star.cpp
@@ -159,6 +159,21 @@ Array AStar::get_points() {
 	return point_list;
 }
 
+PoolVector<int> AStar::get_point_connections(int p_id) {
+
+	ERR_FAIL_COND_V(!points.has(p_id), PoolVector<int>());
+
+	PoolVector<int> point_list;
+
+	Point *p = points[p_id];
+
+	for (int i = 0; i < p->neighbours.size(); i++) {
+		point_list.push_back(p->neighbours[i]->id);
+	}
+
+	return point_list;
+}
+
 bool AStar::are_points_connected(int p_id, int p_with_id) const {
 
 	Segment s(p_id, p_with_id);
@@ -444,6 +459,8 @@ void AStar::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("has_point", "id"), &AStar::has_point);
 	ClassDB::bind_method(D_METHOD("get_points"), &AStar::get_points);
 
+	ClassDB::bind_method(D_METHOD("get_point_connections"), &AStar::get_point_connections);
+
 	ClassDB::bind_method(D_METHOD("connect_points", "id", "to_id", "bidirectional"), &AStar::connect_points, DEFVAL(true));
 	ClassDB::bind_method(D_METHOD("disconnect_points", "id", "to_id"), &AStar::disconnect_points);
 	ClassDB::bind_method(D_METHOD("are_points_connected", "id", "to_id"), &AStar::are_points_connected);
diff --git a/core/math/a_star.h b/core/math/a_star.h
index 23773e82e2..b7b7e54125 100644
--- a/core/math/a_star.h
+++ b/core/math/a_star.h
@@ -109,6 +109,7 @@ public:
 	void set_point_weight_scale(int p_id, real_t p_weight_scale);
 	void remove_point(int p_id);
 	bool has_point(int p_id) const;
+	PoolVector<int> get_point_connections(int p_id);
 	Array get_points();
 
 	void connect_points(int p_id, int p_with_id, bool bidirectional = true);
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index 7715e5d6e5..bc0b3717ed 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -39,6 +39,7 @@
 #include <math.h>
 
 #define Math_PI 3.14159265358979323846
+#define Math_TAU 6.28318530717958647692
 #define Math_SQRT12 0.7071067811865475244008443621048490
 #define Math_LN2 0.693147180559945309417
 #define Math_INF INFINITY
@@ -271,7 +272,7 @@ public:
 
 #elif defined(_MSC_VER) && _MSC_VER < 1800
 		__asm fld a __asm fistp b
-		/*#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
+/*#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 		// use AT&T inline assembly style, document that
 		// we use memory as output (=m) and input (m)
 		__asm__ __volatile__ (
diff --git a/core/ordered_hash_map.h b/core/ordered_hash_map.h
index 9e95f963e1..1ed5a5d369 100644
--- a/core/ordered_hash_map.h
+++ b/core/ordered_hash_map.h
@@ -93,8 +93,12 @@ public:
 			return *this;
 		}
 
-		friend bool operator==(const Element &, const Element &);
-		friend bool operator!=(const Element &, const Element &);
+		_FORCE_INLINE_ bool operator==(const Element &p_other) const {
+			return this->list_element == p_other.list_element;
+		}
+		_FORCE_INLINE_ bool operator!=(const Element &p_other) const {
+			return this->list_element != p_other.list_element;
+		}
 
 		operator bool() const {
 			return (list_element != NULL);
@@ -157,8 +161,12 @@ public:
 			return ConstElement(list_element ? list_element->prev() : NULL);
 		}
 
-		friend bool operator==(const ConstElement &, const ConstElement &);
-		friend bool operator!=(const ConstElement &, const ConstElement &);
+		_FORCE_INLINE_ bool operator==(const ConstElement &p_other) const {
+			return this->list_element == p_other.list_element;
+		}
+		_FORCE_INLINE_ bool operator!=(const ConstElement &p_other) const {
+			return this->list_element != p_other.list_element;
+		}
 
 		operator bool() const {
 			return (list_element != NULL);
@@ -181,7 +189,7 @@ public:
 	};
 
 	ConstElement find(const K &p_key) const {
-		typename InternalList::Element **list_element = map.getptr(p_key);
+		typename InternalList::Element *const *list_element = map.getptr(p_key);
 		if (list_element) {
 			return ConstElement(*list_element);
 		}
@@ -288,28 +296,4 @@ public:
 	}
 };
 
-template <class K, class V, class Hasher, class Comparator, uint8_t MIN_HASH_TABLE_POWER, uint8_t RELATIONSHIP>
-bool operator==(const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::Element &first,
-		const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::Element &second) {
-	return (first.list_element == second.list_element);
-}
-
-template <class K, class V, class Hasher, class Comparator, uint8_t MIN_HASH_TABLE_POWER, uint8_t RELATIONSHIP>
-bool operator!=(const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::Element &first,
-		const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::Element &second) {
-	return (first.list_element != second.list_element);
-}
-
-template <class K, class V, class Hasher, class Comparator, uint8_t MIN_HASH_TABLE_POWER, uint8_t RELATIONSHIP>
-bool operator==(const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::ConstElement &first,
-		const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::ConstElement &second) {
-	return (first.list_element == second.list_element);
-}
-
-template <class K, class V, class Hasher, class Comparator, uint8_t MIN_HASH_TABLE_POWER, uint8_t RELATIONSHIP>
-bool operator!=(const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::ConstElement &first,
-		const typename OrderedHashMap<K, V, Hasher, Comparator, MIN_HASH_TABLE_POWER, RELATIONSHIP>::ConstElement &second) {
-	return (first.list_element != second.list_element);
-}
-
 #endif // ORDERED_HASH_MAP_H
diff --git a/core/os/input_event.h b/core/os/input_event.h
index f2c8cc802d..de3c0232ff 100644
--- a/core/os/input_event.h
+++ b/core/os/input_event.h
@@ -122,7 +122,9 @@ enum JoystickList {
 	JOY_AXIS_5 = 5,
 	JOY_AXIS_6 = 6,
 	JOY_AXIS_7 = 7,
-	JOY_AXIS_MAX = 8,
+	JOY_AXIS_8 = 8,
+	JOY_AXIS_9 = 9,
+	JOY_AXIS_MAX = 10,
 
 	JOY_ANALOG_LX = JOY_AXIS_0,
 	JOY_ANALOG_LY = JOY_AXIS_1,
diff --git a/core/os/os.h b/core/os/os.h
index f5e479ac0b..faecdb0e07 100644
--- a/core/os/os.h
+++ b/core/os/os.h
@@ -109,8 +109,6 @@ protected:
 	virtual int get_video_driver_count() const = 0;
 	virtual const char *get_video_driver_name(int p_driver) const = 0;
 
-	virtual VideoMode get_default_video_mode() const = 0;
-
 	virtual int get_audio_driver_count() const = 0;
 	virtual const char *get_audio_driver_name(int p_driver) const = 0;
 
diff --git a/core/project_settings.cpp b/core/project_settings.cpp
index 2e4fc26784..65a6f2b83c 100644
--- a/core/project_settings.cpp
+++ b/core/project_settings.cpp
@@ -776,32 +776,6 @@ Variant _GLOBAL_DEF(const String &p_var, const Variant &p_default) {
 	return ret;
 }
 
-void ProjectSettings::add_singleton(const Singleton &p_singleton) {
-
-	singletons.push_back(p_singleton);
-	singleton_ptrs[p_singleton.name] = p_singleton.ptr;
-}
-
-Object *ProjectSettings::get_singleton_object(const String &p_name) const {
-
-	const Map<StringName, Object *>::Element *E = singleton_ptrs.find(p_name);
-	if (!E)
-		return NULL;
-	else
-		return E->get();
-};
-
-bool ProjectSettings::has_singleton(const String &p_name) const {
-
-	return get_singleton_object(p_name) != NULL;
-};
-
-void ProjectSettings::get_singletons(List<Singleton> *p_singletons) {
-
-	for (List<Singleton>::Element *E = singletons.front(); E; E = E->next())
-		p_singletons->push_back(E->get());
-}
-
 Vector<String> ProjectSettings::get_optimizer_presets() const {
 
 	List<PropertyInfo> pi;
@@ -893,8 +867,6 @@ void ProjectSettings::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("localize_path", "path"), &ProjectSettings::localize_path);
 	ClassDB::bind_method(D_METHOD("globalize_path", "path"), &ProjectSettings::globalize_path);
 	ClassDB::bind_method(D_METHOD("save"), &ProjectSettings::save);
-	ClassDB::bind_method(D_METHOD("has_singleton", "name"), &ProjectSettings::has_singleton);
-	ClassDB::bind_method(D_METHOD("get_singleton", "name"), &ProjectSettings::get_singleton_object);
 	ClassDB::bind_method(D_METHOD("load_resource_pack", "pack"), &ProjectSettings::_load_resource_pack);
 	ClassDB::bind_method(D_METHOD("property_can_revert", "name"), &ProjectSettings::property_can_revert);
 	ClassDB::bind_method(D_METHOD("property_get_revert", "name"), &ProjectSettings::property_get_revert);
diff --git a/core/project_settings.h b/core/project_settings.h
index f75cad815f..1c4078cebb 100644
--- a/core/project_settings.h
+++ b/core/project_settings.h
@@ -45,14 +45,6 @@ class ProjectSettings : public Object {
 public:
 	typedef Map<String, Variant> CustomMap;
 
-	struct Singleton {
-		StringName name;
-		Object *ptr;
-		Singleton(const StringName &p_name = StringName(), Object *p_ptr = NULL)
-			: name(p_name),
-			  ptr(p_ptr) {
-		}
-	};
 	enum {
 		//properties that are not for built in values begin from this value, so builtin ones are displayed first
 		NO_BUILTIN_ORDER_BASE = 1 << 16
@@ -106,9 +98,6 @@ protected:
 	Error _save_settings_text(const String &p_file, const Map<String, List<String> > &props, const CustomMap &p_custom = CustomMap(), const String &p_custom_features = String());
 	Error _save_settings_binary(const String &p_file, const Map<String, List<String> > &props, const CustomMap &p_custom = CustomMap(), const String &p_custom_features = String());
 
-	List<Singleton> singletons;
-	Map<StringName, Object *> singleton_ptrs;
-
 	Error _save_custom_bnd(const String &p_file);
 
 	bool _load_resource_pack(const String &p_pack);
@@ -145,17 +134,11 @@ public:
 	Error save();
 	void set_custom_property_info(const String &p_prop, const PropertyInfo &p_info);
 
-	void add_singleton(const Singleton &p_singleton);
-	void get_singletons(List<Singleton> *p_singletons);
-
-	bool has_singleton(const String &p_name) const;
-
 	Vector<String> get_optimizer_presets() const;
 
 	List<String> get_input_presets() const { return input_presets; }
 
 	void set_disable_feature_overrides(bool p_disable);
-	Object *get_singleton_object(const String &p_name) const;
 
 	void register_global_defaults();
 
diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp
index c6d7cd44e8..baaf738b42 100644
--- a/core/register_core_types.cpp
+++ b/core/register_core_types.cpp
@@ -34,6 +34,7 @@
 #include "compressed_translation.h"
 #include "core/io/xml_parser.h"
 #include "core_string_names.h"
+#include "engine.h"
 #include "func_ref.h"
 #include "geometry.h"
 #include "input_map.h"
@@ -203,19 +204,19 @@ void register_core_singletons() {
 	ClassDB::register_class<InputMap>();
 	ClassDB::register_class<_JSON>();
 
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("ProjectSettings", ProjectSettings::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("IP", IP::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("Geometry", _Geometry::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("ResourceLoader", _ResourceLoader::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("ResourceSaver", _ResourceSaver::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("OS", _OS::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("Engine", _Engine::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("ClassDB", _classdb));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("Marshalls", _Marshalls::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("TranslationServer", TranslationServer::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("Input", Input::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("InputMap", InputMap::get_singleton()));
-	ProjectSettings::get_singleton()->add_singleton(ProjectSettings::Singleton("JSON", _JSON::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("ProjectSettings", ProjectSettings::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("IP", IP::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("Geometry", _Geometry::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("ResourceLoader", _ResourceLoader::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("ResourceSaver", _ResourceSaver::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("OS", _OS::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("Engine", _Engine::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("ClassDB", _classdb));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("Marshalls", _Marshalls::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("TranslationServer", TranslationServer::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("Input", Input::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("InputMap", InputMap::get_singleton()));
+	Engine::get_singleton()->add_singleton(Engine::Singleton("JSON", _JSON::get_singleton()));
 }
 
 void unregister_core_types() {
diff --git a/core/script_debugger_remote.cpp b/core/script_debugger_remote.cpp
index 2feb068ecb..f77fb116c7 100644
--- a/core/script_debugger_remote.cpp
+++ b/core/script_debugger_remote.cpp
@@ -29,6 +29,7 @@
 /*************************************************************************/
 #include "script_debugger_remote.h"
 
+#include "engine.h"
 #include "io/ip.h"
 #include "io/marshalls.h"
 #include "os/input.h"
@@ -939,7 +940,7 @@ ScriptDebuggerRemote::ScriptDebuggerRemote()
 	  tcp_client(StreamPeerTCP::create_ref()),
 	  packet_peer_stream(Ref<PacketPeerStream>(memnew(PacketPeerStream))),
 	  last_perf_time(0),
-	  performance(ProjectSettings::get_singleton()->get_singleton_object("Performance")),
+	  performance(Engine::get_singleton()->get_singleton_object("Performance")),
 	  requested_quit(false),
 	  mutex(Mutex::create()),
 	  max_cps(GLOBAL_GET("network/limits/debugger_stdout/max_chars_per_second")),
diff --git a/core/translation.cpp b/core/translation.cpp
index 058db956e5..7e4d4feb89 100644
--- a/core/translation.cpp
+++ b/core/translation.cpp
@@ -966,7 +966,7 @@ Vector<String> TranslationServer::get_all_locale_names() {
 	const char **ptr = locale_names;
 
 	while (*ptr) {
-		locales.push_back(*ptr);
+		locales.push_back(String::utf8(*ptr));
 		ptr++;
 	}
 
@@ -1168,6 +1168,6 @@ TranslationServer::TranslationServer()
 
 	for (int i = 0; locale_list[i]; ++i) {
 
-		locale_name_map.insert(locale_list[i], locale_names[i]);
+		locale_name_map.insert(locale_list[i], String::utf8(locale_names[i]));
 	}
 }
diff --git a/core/ustring.cpp b/core/ustring.cpp
index 415494ddc8..7c3a784c5b 100644
--- a/core/ustring.cpp
+++ b/core/ustring.cpp
@@ -564,7 +564,7 @@ void String::erase(int p_pos, int p_chars) {
 
 String String::capitalize() const {
 
-	String aux = this->replace("_", " ").to_lower();
+	String aux = this->camelcase_to_underscore(true).replace("_", " ").strip_edges();
 	String cap;
 	for (int i = 0; i < aux.get_slice_count(" "); i++) {
 
diff --git a/core/variant_call.cpp b/core/variant_call.cpp
index 1a29b92810..05f0478003 100644
--- a/core/variant_call.cpp
+++ b/core/variant_call.cpp
@@ -1458,7 +1458,7 @@ void register_variant_methods() {
 	ADDFUNC0R(STRING, STRING, String, get_basename, varray());
 	ADDFUNC1R(STRING, STRING, String, plus_file, STRING, "file", varray());
 	ADDFUNC1R(STRING, INT, String, ord_at, INT, "at", varray());
-	ADDFUNC0(STRING, STRING, String, dedent, varray());
+	ADDFUNC0R(STRING, STRING, String, dedent, varray());
 	ADDFUNC2(STRING, NIL, String, erase, INT, "position", INT, "chars", varray());
 	ADDFUNC0R(STRING, INT, String, hash, varray());
 	ADDFUNC0R(STRING, STRING, String, md5_text, varray());