Style: Replaces uses of 0/NULL by nullptr (C++11)

Using clang-tidy's `modernize-use-nullptr`.
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html

.clang-tidy

@@ -0,0 +1,44 @@
+---
+Checks:          'clang-diagnostic-*,clang-analyzer-*,-*,modernize-use-nullptr'
+WarningsAsErrors: ''
+HeaderFilterRegex: '.*'
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+CheckOptions:
+CheckOptions:
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           '0'
+  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value:           '1'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-bool-literals.IgnoreMacros
+    value:           '0'
+  - key:             modernize-use-default-member-init.IgnoreMacros
+    value:           '0'
+  - key:             modernize-use-default-member-init.UseAssignment
+    value:           '1'
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             readability-braces-around-statements.ShortStatementLines
+    value:           '0'
+...
+

core/array.cpp

@@ -65,7 +65,7 @@ void Array::_unref() const {
 	if (_p->refcount.unref()) {
 		memdelete(_p);
 	}
-	_p = NULL;
+	_p = nullptr;
 }
 
 Variant &Array::operator[](int p_idx) {
@@ -419,7 +419,7 @@ const void *Array::id() const {
 }
 
 Array::Array(const Array &p_from) {
-	_p = NULL;
+	_p = nullptr;
 	_ref(p_from);
 }
 

core/bind/core_bind.cpp

@@ -62,7 +62,7 @@ static const unsigned int MONTH_DAYS_TABLE[2][12] = {
 	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 };
 
-_ResourceLoader *_ResourceLoader::singleton = NULL;
+_ResourceLoader *_ResourceLoader::singleton = nullptr;
 
 Ref<ResourceInteractiveLoader> _ResourceLoader::load_interactive(const String &p_path, const String &p_type_hint) {
 	return ResourceLoader::load_interactive(p_path, p_type_hint);
@@ -152,7 +152,7 @@ PoolVector<String> _ResourceSaver::get_recognized_extensions(const RES &p_resour
 	return ret;
 }
 
-_ResourceSaver *_ResourceSaver::singleton = NULL;
+_ResourceSaver *_ResourceSaver::singleton = nullptr;
 
 void _ResourceSaver::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("save", "path", "resource", "flags"), &_ResourceSaver::save, DEFVAL(0));
@@ -1147,7 +1147,7 @@ void _OS::set_current_tablet_driver(const String &p_driver) {
 	OS::get_singleton()->set_current_tablet_driver(p_driver);
 }
 
-_OS *_OS::singleton = NULL;
+_OS *_OS::singleton = nullptr;
 
 void _OS::_bind_methods() {
 	//ClassDB::bind_method(D_METHOD("get_mouse_position"),&_OS::get_mouse_position);
@@ -1462,7 +1462,7 @@ _OS::_OS() {
 
 ///////////////////// GEOMETRY
 
-_Geometry *_Geometry::singleton = NULL;
+_Geometry *_Geometry::singleton = nullptr;
 
 _Geometry *_Geometry::get_singleton() {
 	return singleton;
@@ -1869,10 +1869,10 @@ void _File::flush() {
 void _File::close() {
 	if (f)
 		memdelete(f);
-	f = NULL;
+	f = nullptr;
 }
 bool _File::is_open() const {
-	return f != NULL;
+	return f != nullptr;
 }
 String _File::get_path() const {
 	ERR_FAIL_COND_V_MSG(!f, "", "File must be opened before use.");
@@ -2101,7 +2101,7 @@ bool _File::file_exists(const String &p_name) const {
 void _File::store_var(const Variant &p_var, bool p_full_objects) {
 	ERR_FAIL_COND_MSG(!f, "File must be opened before use.");
 	int len;
-	Error err = encode_variant(p_var, NULL, len, p_full_objects);
+	Error err = encode_variant(p_var, nullptr, len, p_full_objects);
 	ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
 
 	PoolVector<uint8_t> buff;
@@ -2125,7 +2125,7 @@ Variant _File::get_var(bool p_allow_objects) const {
 	PoolVector<uint8_t>::Read r = buff.read();
 
 	Variant v;
-	Error err = decode_variant(v, &r[0], len, NULL, p_allow_objects);
+	Error err = decode_variant(v, &r[0], len, nullptr, p_allow_objects);
 	ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to encode Variant.");
 
 	return v;
@@ -2202,7 +2202,7 @@ void _File::_bind_methods() {
 }
 
 _File::_File() {
-	f = NULL;
+	f = nullptr;
 	eswap = false;
 }
 
@@ -2384,7 +2384,7 @@ _Directory::~_Directory() {
 		memdelete(d);
 }
 
-_Marshalls *_Marshalls::singleton = NULL;
+_Marshalls *_Marshalls::singleton = nullptr;
 
 _Marshalls *_Marshalls::get_singleton() {
 	return singleton;
@@ -2392,7 +2392,7 @@ _Marshalls *_Marshalls::get_singleton() {
 
 String _Marshalls::variant_to_base64(const Variant &p_var, bool p_full_objects) {
 	int len;
-	Error err = encode_variant(p_var, NULL, len, p_full_objects);
+	Error err = encode_variant(p_var, nullptr, len, p_full_objects);
 	ERR_FAIL_COND_V_MSG(err != OK, "", "Error when trying to encode Variant.");
 
 	PoolVector<uint8_t> buff;
@@ -2420,7 +2420,7 @@ Variant _Marshalls::base64_to_variant(const String &p_str, bool p_allow_objects)
 	ERR_FAIL_COND_V(CryptoCore::b64_decode(&w[0], buf.size(), &len, (unsigned char *)cstr.get_data(), strlen) != OK, Variant());
 
 	Variant v;
-	Error err = decode_variant(v, &w[0], len, NULL, p_allow_objects);
+	Error err = decode_variant(v, &w[0], len, nullptr, p_allow_objects);
 	ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to decode Variant.");
 
 	return v;
@@ -2589,7 +2589,7 @@ Variant _Thread::wait_to_finish() {
 	thread.wait_to_finish();
 	Variant r = ret;
 	target_method = StringName();
-	target_instance = NULL;
+	target_instance = nullptr;
 	userdata = Variant();
 	active.clear();
 
@@ -2607,7 +2607,7 @@ void _Thread::_bind_methods() {
 	BIND_ENUM_CONSTANT(PRIORITY_HIGH);
 }
 _Thread::_Thread() {
-	target_instance = NULL;
+	target_instance = nullptr;
 }
 
 _Thread::~_Thread() {
@@ -2951,7 +2951,7 @@ void _Engine::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "physics_jitter_fix"), "set_physics_jitter_fix", "get_physics_jitter_fix");
 }
 
-_Engine *_Engine::singleton = NULL;
+_Engine *_Engine::singleton = nullptr;
 
 _Engine::_Engine() {
 	singleton = this;
@@ -3027,7 +3027,7 @@ Ref<JSONParseResult> _JSON::parse(const String &p_json) {
 	return result;
 }
 
-_JSON *_JSON::singleton = NULL;
+_JSON *_JSON::singleton = nullptr;
 
 _JSON::_JSON() {
 	singleton = this;

core/bind/core_bind.h

@@ -644,7 +644,7 @@ public:
 	String base64_to_utf8(const String &p_str);
 
 	_Marshalls() { singleton = this; }
-	~_Marshalls() { singleton = NULL; }
+	~_Marshalls() { singleton = nullptr; }
 };
 
 class _Mutex : public Reference {

core/class_db.cpp

@@ -244,8 +244,8 @@ HashMap<StringName, StringName> ClassDB::compat_classes;
 
 ClassDB::ClassInfo::ClassInfo() {
 	api = API_NONE;
-	creation_func = NULL;
-	inherits_ptr = NULL;
+	creation_func = nullptr;
+	inherits_ptr = nullptr;
 	disabled = false;
 	exposed = false;
 }
@@ -274,7 +274,7 @@ bool ClassDB::is_parent_class(const StringName &p_class, const StringName &p_inh
 void ClassDB::get_class_list(List<StringName> *p_classes) {
 	OBJTYPE_RLOCK;
 
-	const StringName *k = NULL;
+	const StringName *k = nullptr;
 
 	while ((k = classes.next(k))) {
 		p_classes->push_back(*k);
@@ -286,7 +286,7 @@ void ClassDB::get_class_list(List<StringName> *p_classes) {
 void ClassDB::get_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes) {
 	OBJTYPE_RLOCK;
 
-	const StringName *k = NULL;
+	const StringName *k = nullptr;
 
 	while ((k = classes.next(k))) {
 		if (*k != p_class && _is_parent_class(*k, p_class))
@@ -297,7 +297,7 @@ void ClassDB::get_inheriters_from_class(const StringName &p_class, List<StringNa
 void ClassDB::get_direct_inheriters_from_class(const StringName &p_class, List<StringName> *p_classes) {
 	OBJTYPE_RLOCK;
 
-	const StringName *k = NULL;
+	const StringName *k = nullptr;
 
 	while ((k = classes.next(k))) {
 		if (*k != p_class && _get_parent_class(*k) == p_class)
@@ -343,7 +343,7 @@ uint64_t ClassDB::get_api_hash(APIType p_api) {
 
 	List<StringName> names;
 
-	const StringName *k = NULL;
+	const StringName *k = nullptr;
 
 	while ((k = classes.next(k))) {
 		names.push_back(*k);
@@ -363,7 +363,7 @@ uint64_t ClassDB::get_api_hash(APIType p_api) {
 
 			List<StringName> snames;
 
-			k = NULL;
+			k = nullptr;
 
 			while ((k = t->method_map.next(k))) {
 				String name = k->operator String();
@@ -408,7 +408,7 @@ uint64_t ClassDB::get_api_hash(APIType p_api) {
 
 			List<StringName> snames;
 
-			k = NULL;
+			k = nullptr;
 
 			while ((k = t->constant_map.next(k))) {
 				snames.push_back(*k);
@@ -426,7 +426,7 @@ uint64_t ClassDB::get_api_hash(APIType p_api) {
 
 			List<StringName> snames;
 
-			k = NULL;
+			k = nullptr;
 
 			while ((k = t->signal_map.next(k))) {
 				snames.push_back(*k);
@@ -447,7 +447,7 @@ uint64_t ClassDB::get_api_hash(APIType p_api) {
 
 			List<StringName> snames;
 
-			k = NULL;
+			k = nullptr;
 
 			while ((k = t->property_setget.next(k))) {
 				snames.push_back(*k);
@@ -501,14 +501,14 @@ Object *ClassDB::instance(const StringName &p_class) {
 				ti = classes.getptr(compat_classes[p_class]);
 			}
 		}
-		ERR_FAIL_COND_V_MSG(!ti, NULL, "Cannot get class '" + String(p_class) + "'.");
-		ERR_FAIL_COND_V_MSG(ti->disabled, NULL, "Class '" + String(p_class) + "' is disabled.");
-		ERR_FAIL_COND_V(!ti->creation_func, NULL);
+		ERR_FAIL_COND_V_MSG(!ti, nullptr, "Cannot get class '" + String(p_class) + "'.");
+		ERR_FAIL_COND_V_MSG(ti->disabled, nullptr, "Class '" + String(p_class) + "' is disabled.");
+		ERR_FAIL_COND_V(!ti->creation_func, nullptr);
 	}
 #ifdef TOOLS_ENABLED
 	if (ti->api == API_EDITOR && !Engine::get_singleton()->is_editor_hint()) {
 		ERR_PRINTS("Class '" + String(p_class) + "' can only be instantiated by editor.");
-		return NULL;
+		return nullptr;
 	}
 #endif
 	return ti->creation_func();
@@ -523,7 +523,7 @@ bool ClassDB::can_instance(const StringName &p_class) {
 		return false;
 	}
 #endif
-	return (!ti->disabled && ti->creation_func != NULL);
+	return (!ti->disabled && ti->creation_func != nullptr);
 }
 
 void ClassDB::_add_class2(const StringName &p_class, const StringName &p_inherits) {
@@ -544,7 +544,7 @@ void ClassDB::_add_class2(const StringName &p_class, const StringName &p_inherit
 		ti.inherits_ptr = &classes[ti.inherits];
 
 	} else {
-		ti.inherits_ptr = NULL;
+		ti.inherits_ptr = nullptr;
 	}
 }
 
@@ -625,7 +625,7 @@ MethodBind *ClassDB::get_method(StringName p_class, StringName p_name) {
 			return *method;
 		type = type->inherits_ptr;
 	}
-	return NULL;
+	return nullptr;
 }
 
 void ClassDB::bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int p_constant) {
@@ -715,7 +715,7 @@ StringName ClassDB::get_integer_constant_enum(const StringName &p_class, const S
 	ClassInfo *type = classes.getptr(p_class);
 
 	while (type) {
-		const StringName *k = NULL;
+		const StringName *k = nullptr;
 		while ((k = type->enum_map.next(k))) {
 			List<StringName> &constants_list = type->enum_map.get(*k);
 			const List<StringName>::Element *found = constants_list.find(p_name);
@@ -738,7 +738,7 @@ void ClassDB::get_enum_list(const StringName &p_class, List<StringName> *p_enums
 	ClassInfo *type = classes.getptr(p_class);
 
 	while (type) {
-		const StringName *k = NULL;
+		const StringName *k = nullptr;
 		while ((k = type->enum_map.next(k))) {
 			p_enums->push_back(*k);
 		}
@@ -799,7 +799,7 @@ void ClassDB::get_signal_list(StringName p_class, List<MethodInfo> *p_signals, b
 	ClassInfo *check = type;
 
 	while (check) {
-		const StringName *S = NULL;
+		const StringName *S = nullptr;
 		while ((S = check->signal_map.next(S))) {
 			p_signals->push_back(check->signal_map[*S]);
 		}
@@ -856,7 +856,7 @@ void ClassDB::add_property(StringName p_class, const PropertyInfo &p_pinfo, cons
 
 	ERR_FAIL_COND(!type);
 
-	MethodBind *mb_set = NULL;
+	MethodBind *mb_set = nullptr;
 	if (p_setter) {
 		mb_set = get_method(p_class, p_setter);
 #ifdef DEBUG_METHODS_ENABLED
@@ -868,7 +868,7 @@ void ClassDB::add_property(StringName p_class, const PropertyInfo &p_pinfo, cons
 #endif
 	}
 
-	MethodBind *mb_get = NULL;
+	MethodBind *mb_get = nullptr;
 	if (p_getter) {
 		mb_get = get_method(p_class, p_getter);
 #ifdef DEBUG_METHODS_ENABLED
@@ -1000,9 +1000,9 @@ bool ClassDB::get_property(Object *p_object, const StringName &p_property, Varia
 			} else {
 				Variant::CallError ce;
 				if (psg->_getptr) {
-					r_value = psg->_getptr->call(p_object, NULL, 0, ce);
+					r_value = psg->_getptr->call(p_object, nullptr, 0, ce);
 				} else {
-					r_value = p_object->call(psg->getter, NULL, 0, ce);
+					r_value = p_object->call(psg->getter, nullptr, 0, ce);
 				}
 			}
 			return true;
@@ -1137,33 +1137,33 @@ MethodBind *ClassDB::bind_methodfi(uint32_t p_flags, MethodBind *p_bind, const c
 #endif
 
 	OBJTYPE_WLOCK;
-	ERR_FAIL_COND_V(!p_bind, NULL);
+	ERR_FAIL_COND_V(!p_bind, nullptr);
 	p_bind->set_name(mdname);
 
 	String instance_type = p_bind->get_instance_class();
 
 #ifdef DEBUG_ENABLED
 
-	ERR_FAIL_COND_V_MSG(has_method(instance_type, mdname), NULL, "Class " + String(instance_type) + " already has a method " + String(mdname) + ".");
+	ERR_FAIL_COND_V_MSG(has_method(instance_type, mdname), nullptr, "Class " + String(instance_type) + " already has a method " + String(mdname) + ".");
 #endif
 
 	ClassInfo *type = classes.getptr(instance_type);
 	if (!type) {
 		memdelete(p_bind);
-		ERR_FAIL_V_MSG(NULL, "Couldn't bind method '" + mdname + "' for instance '" + instance_type + "'.");
+		ERR_FAIL_V_MSG(nullptr, "Couldn't bind method '" + mdname + "' for instance '" + instance_type + "'.");
 	}
 
 	if (type->method_map.has(mdname)) {
 		memdelete(p_bind);
 		// overloading not supported
-		ERR_FAIL_V_MSG(NULL, "Method already bound '" + instance_type + "::" + mdname + "'.");
+		ERR_FAIL_V_MSG(nullptr, "Method already bound '" + instance_type + "::" + mdname + "'.");
 	}
 
 #ifdef DEBUG_METHODS_ENABLED
 
 	if (method_name.args.size() > p_bind->get_argument_count()) {
 		memdelete(p_bind);
-		ERR_FAIL_V_MSG(NULL, "Method definition provides more arguments than the method actually has '" + instance_type + "::" + mdname + "'.");
+		ERR_FAIL_V_MSG(nullptr, "Method definition provides more arguments than the method actually has '" + instance_type + "::" + mdname + "'.");
 	}
 
 	p_bind->set_argument_names(method_name.args);
@@ -1265,7 +1265,7 @@ void ClassDB::add_resource_base_extension(const StringName &p_extension, const S
 }
 
 void ClassDB::get_resource_base_extensions(List<String> *p_extensions) {
-	const StringName *K = NULL;
+	const StringName *K = nullptr;
 
 	while ((K = resource_base_extensions.next(K))) {
 		p_extensions->push_back(*K);
@@ -1273,7 +1273,7 @@ void ClassDB::get_resource_base_extensions(List<String> *p_extensions) {
 }
 
 void ClassDB::get_extensions_for_type(const StringName &p_class, List<String> *p_extensions) {
-	const StringName *K = NULL;
+	const StringName *K = nullptr;
 
 	while ((K = resource_base_extensions.next(K))) {
 		StringName cmp = resource_base_extensions[*K];
@@ -1291,7 +1291,7 @@ Variant ClassDB::class_get_default_property_value(const StringName &p_class, con
 			default_values[p_class] = HashMap<StringName, Variant>();
 		}
 
-		Object *c = NULL;
+		Object *c = nullptr;
 		bool cleanup_c = false;
 
 		if (Engine::get_singleton()->has_singleton(p_class)) {
@@ -1323,18 +1323,18 @@ Variant ClassDB::class_get_default_property_value(const StringName &p_class, con
 	}
 
 	if (!default_values.has(p_class)) {
-		if (r_valid != NULL)
+		if (r_valid != nullptr)
 			*r_valid = false;
 		return Variant();
 	}
 
 	if (!default_values[p_class].has(p_property)) {
-		if (r_valid != NULL)
+		if (r_valid != nullptr)
 			*r_valid = false;
 		return Variant();
 	}
 
-	if (r_valid != NULL)
+	if (r_valid != nullptr)
 		*r_valid = true;
 	return default_values[p_class][p_property];
 }
@@ -1349,12 +1349,12 @@ void ClassDB::cleanup_defaults() {
 void ClassDB::cleanup() {
 	//OBJTYPE_LOCK; hah not here
 
-	const StringName *k = NULL;
+	const StringName *k = nullptr;
 
 	while ((k = classes.next(k))) {
 		ClassInfo &ti = classes[*k];
 
-		const StringName *m = NULL;
+		const StringName *m = nullptr;
 		while ((m = ti.method_map.next(m))) {
 			memdelete(ti.method_map[*m]);
 		}

core/class_db.h

@@ -227,7 +227,7 @@ public:
 	static MethodBind *bind_method(N p_method_name, M p_method) {
 		MethodBind *bind = create_method_bind(p_method);
 
-		return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, NULL, 0); //use static function, much smaller binary usage
+		return bind_methodfi(METHOD_FLAGS_DEFAULT, bind, p_method_name, nullptr, 0); //use static function, much smaller binary usage
 	}
 
 	template <class N, class M>
@@ -299,7 +299,7 @@ public:
 		GLOBAL_LOCK_FUNCTION;
 
 		MethodBind *bind = create_vararg_method_bind(p_method, p_info, p_return_nil_is_variant);
-		ERR_FAIL_COND_V(!bind, NULL);
+		ERR_FAIL_COND_V(!bind, nullptr);
 
 		bind->set_name(p_name);
 		bind->set_default_arguments(p_default_args);
@@ -309,13 +309,13 @@ public:
 		ClassInfo *type = classes.getptr(instance_type);
 		if (!type) {
 			memdelete(bind);
-			ERR_FAIL_COND_V(!type, NULL);
+			ERR_FAIL_COND_V(!type, nullptr);
 		}
 
 		if (type->method_map.has(p_name)) {
 			memdelete(bind);
 			// overloading not supported
-			ERR_FAIL_V_MSG(NULL, "Method already bound: " + instance_type + "::" + p_name + ".");
+			ERR_FAIL_V_MSG(nullptr, "Method already bound: " + instance_type + "::" + p_name + ".");
 		}
 		type->method_map[p_name] = bind;
 #ifdef DEBUG_METHODS_ENABLED
@@ -335,12 +335,12 @@ public:
 	static void add_property_group(StringName p_class, const String &p_name, const String &p_prefix = "");
 	static void add_property(StringName p_class, const PropertyInfo &p_pinfo, const StringName &p_setter, const StringName &p_getter, int p_index = -1);
 	static void set_property_default_value(StringName p_class, const StringName &p_name, const Variant &p_default);
-	static void get_property_list(StringName p_class, List<PropertyInfo> *p_list, bool p_no_inheritance = false, const Object *p_validator = NULL);
-	static bool set_property(Object *p_object, const StringName &p_property, const Variant &p_value, bool *r_valid = NULL);
+	static void get_property_list(StringName p_class, List<PropertyInfo> *p_list, bool p_no_inheritance = false, const Object *p_validator = nullptr);
+	static bool set_property(Object *p_object, const StringName &p_property, const Variant &p_value, bool *r_valid = nullptr);
 	static bool get_property(Object *p_object, const StringName &p_property, Variant &r_value);
 	static bool has_property(const StringName &p_class, const StringName &p_property, bool p_no_inheritance = false);
-	static int get_property_index(const StringName &p_class, const StringName &p_property, bool *r_is_valid = NULL);
-	static Variant::Type get_property_type(const StringName &p_class, const StringName &p_property, bool *r_is_valid = NULL);
+	static int get_property_index(const StringName &p_class, const StringName &p_property, bool *r_is_valid = nullptr);
+	static Variant::Type get_property_type(const StringName &p_class, const StringName &p_property, bool *r_is_valid = nullptr);
 	static StringName get_property_setter(StringName p_class, const StringName &p_property);
 	static StringName get_property_getter(StringName p_class, const StringName &p_property);
 
@@ -355,13 +355,13 @@ public:
 
 	static void bind_integer_constant(const StringName &p_class, const StringName &p_enum, const StringName &p_name, int p_constant);
 	static void get_integer_constant_list(const StringName &p_class, List<String> *p_constants, bool p_no_inheritance = false);
-	static int get_integer_constant(const StringName &p_class, const StringName &p_name, bool *p_success = NULL);
+	static int get_integer_constant(const StringName &p_class, const StringName &p_name, bool *p_success = nullptr);
 
 	static StringName get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance = false);
 	static void get_enum_list(const StringName &p_class, List<StringName> *p_enums, bool p_no_inheritance = false);
 	static void get_enum_constants(const StringName &p_class, const StringName &p_enum, List<StringName> *p_constants, bool p_no_inheritance = false);
 
-	static Variant class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid = NULL);
+	static Variant class_get_default_property_value(const StringName &p_class, const StringName &p_property, bool *r_valid = nullptr);
 
 	static StringName get_category(const StringName &p_node);
 

core/command_queue_mt.cpp

@@ -110,7 +110,7 @@ CommandQueueMT::CommandQueueMT(bool p_sync) {
 	if (p_sync) {
 		sync = memnew(Semaphore);
 	} else {
-		sync = NULL;
+		sync = nullptr;
 	}
 }
 

core/command_queue_mt.h

@@ -329,7 +329,7 @@ class CommandQueueMT {
 		uint32_t alloc_size = ((sizeof(T) + 8 - 1) & ~(8 - 1)) + 8;
 
 		// Assert that the buffer is big enough to hold at least two messages.
-		ERR_FAIL_COND_V(alloc_size * 2 + sizeof(uint32_t) > command_mem_size, NULL);
+		ERR_FAIL_COND_V(alloc_size * 2 + sizeof(uint32_t) > command_mem_size, nullptr);
 
 	tryagain:
 		uint32_t write_ptr = write_ptr_and_epoch >> 1;
@@ -341,7 +341,7 @@ class CommandQueueMT {
 				if (dealloc_one()) {
 					goto tryagain;
 				}
-				return NULL;
+				return nullptr;
 			}
 		} else {
 			// ahead of dealloc_ptr, check that there is room
@@ -355,11 +355,11 @@ class CommandQueueMT {
 					if (dealloc_one()) {
 						goto tryagain;
 					}
-					return NULL;
+					return nullptr;
 				}
 
 				// if this happens, it's a bug
-				ERR_FAIL_COND_V((command_mem_size - write_ptr) < 8, NULL);
+				ERR_FAIL_COND_V((command_mem_size - write_ptr) < 8, nullptr);
 				// zero means, wrap to beginning
 
 				uint32_t *p = (uint32_t *)&command_mem[write_ptr];
@@ -392,7 +392,7 @@ class CommandQueueMT {
 		lock();
 		T *ret;
 
-		while ((ret = allocate<T>()) == NULL) {
+		while ((ret = allocate<T>()) == nullptr) {
 			unlock();
 			// sleep a little until fetch happened and some room is made
 			wait_for_flush();

core/core_string_names.cpp

@@ -30,7 +30,7 @@
 
 #include "core_string_names.h"
 
-CoreStringNames *CoreStringNames::singleton = NULL;
+CoreStringNames *CoreStringNames::singleton = nullptr;
 
 CoreStringNames::CoreStringNames() :
 		_free(StaticCString::create("free")),

core/core_string_names.h

@@ -40,7 +40,7 @@ class CoreStringNames {
 	static void create() { singleton = memnew(CoreStringNames); }
 	static void free() {
 		memdelete(singleton);
-		singleton = NULL;
+		singleton = nullptr;
 	}
 
 	CoreStringNames();

core/cowdata.h

@@ -64,21 +64,21 @@ private:
 
 	_FORCE_INLINE_ SafeNumeric<uint32_t> *_get_refcount() const {
 		if (!_ptr)
-			return NULL;
+			return nullptr;
 
 		return reinterpret_cast<SafeNumeric<uint32_t> *>(_ptr) - 2;
 	}
 
 	_FORCE_INLINE_ uint32_t *_get_size() const {
 		if (!_ptr)
-			return NULL;
+			return nullptr;
 
 		return reinterpret_cast<uint32_t *>(_ptr) - 1;
 	}
 
 	_FORCE_INLINE_ T *_get_data() const {
 		if (!_ptr)
-			return NULL;
+			return nullptr;
 		return reinterpret_cast<T *>(_ptr);
 	}
 
@@ -133,7 +133,7 @@ public:
 	}
 
 	_FORCE_INLINE_ void clear() { resize(0); }
-	_FORCE_INLINE_ bool empty() const { return _ptr == 0; }
+	_FORCE_INLINE_ bool empty() const { return _ptr == nullptr; }
 
 	_FORCE_INLINE_ void set(int p_index, const T &p_elem) {
 		CRASH_BAD_INDEX(p_index, size());
@@ -257,7 +257,7 @@ Error CowData<T>::resize(int p_size) {
 	if (p_size == 0) {
 		// wants to clean up
 		_unref(_ptr);
-		_ptr = NULL;
+		_ptr = nullptr;
 		return OK;
 	}
 
@@ -352,7 +352,7 @@ void CowData<T>::_ref(const CowData &p_from) {
 		return; // self assign, do nothing.
 
 	_unref(_ptr);
-	_ptr = NULL;
+	_ptr = nullptr;
 
 	if (!p_from._ptr)
 		return; //nothing to do
@@ -364,7 +364,7 @@ void CowData<T>::_ref(const CowData &p_from) {
 
 template <class T>
 CowData<T>::CowData() {
-	_ptr = NULL;
+	_ptr = nullptr;
 }
 
 template <class T>

core/crypto/crypto.cpp

@@ -36,11 +36,11 @@
 
 /// Resources
 
-CryptoKey *(*CryptoKey::_create)() = NULL;
+CryptoKey *(*CryptoKey::_create)() = nullptr;
 CryptoKey *CryptoKey::create() {
 	if (_create)
 		return _create();
-	return NULL;
+	return nullptr;
 }
 
 void CryptoKey::_bind_methods() {
@@ -51,11 +51,11 @@ void CryptoKey::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("load_from_string", "string_key", "public_only"), &CryptoKey::load_from_string, DEFVAL(false));
 }
 
-X509Certificate *(*X509Certificate::_create)() = NULL;
+X509Certificate *(*X509Certificate::_create)() = nullptr;
 X509Certificate *X509Certificate::create() {
 	if (_create)
 		return _create();
-	return NULL;
+	return nullptr;
 }
 
 void X509Certificate::_bind_methods() {
@@ -65,12 +65,12 @@ void X509Certificate::_bind_methods() {
 
 /// Crypto
 
-void (*Crypto::_load_default_certificates)(String p_path) = NULL;
-Crypto *(*Crypto::_create)() = NULL;
+void (*Crypto::_load_default_certificates)(String p_path) = nullptr;
+Crypto *(*Crypto::_create)() = nullptr;
 Crypto *Crypto::create() {
 	if (_create)
 		return _create();
-	ERR_FAIL_V_MSG(NULL, "Crypto is not available when the mbedtls module is disabled.");
+	ERR_FAIL_V_MSG(nullptr, "Crypto is not available when the mbedtls module is disabled.");
 }
 
 void Crypto::load_default_certificates(String p_path) {
@@ -111,7 +111,7 @@ RES ResourceFormatLoaderCrypto::load(const String &p_path, const String &p_origi
 			key->load(p_path, true);
 		return key;
 	}
-	return NULL;
+	return nullptr;
 }
 
 void ResourceFormatLoaderCrypto::get_recognized_extensions(List<String> *p_extensions) const {

core/crypto/crypto.h

@@ -94,7 +94,7 @@ public:
 
 class ResourceFormatLoaderCrypto : public ResourceFormatLoader {
 public:
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;

core/crypto/hashing_context.cpp

@@ -33,9 +33,9 @@
 #include "core/crypto/crypto_core.h"
 
 Error HashingContext::start(HashType p_type) {
-	ERR_FAIL_COND_V(ctx != NULL, ERR_ALREADY_IN_USE);
+	ERR_FAIL_COND_V(ctx != nullptr, ERR_ALREADY_IN_USE);
 	_create_ctx(p_type);
-	ERR_FAIL_COND_V(ctx == NULL, ERR_UNAVAILABLE);
+	ERR_FAIL_COND_V(ctx == nullptr, ERR_UNAVAILABLE);
 	switch (type) {
 		case HASH_MD5:
 			return ((CryptoCore::MD5Context *)ctx)->start();
@@ -48,7 +48,7 @@ Error HashingContext::start(HashType p_type) {
 }
 
 Error HashingContext::update(PoolByteArray p_chunk) {
-	ERR_FAIL_COND_V(ctx == NULL, ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(ctx == nullptr, ERR_UNCONFIGURED);
 	size_t len = p_chunk.size();
 	ERR_FAIL_COND_V(len == 0, FAILED);
 	PoolByteArray::Read r = p_chunk.read();
@@ -64,7 +64,7 @@ Error HashingContext::update(PoolByteArray p_chunk) {
 }
 
 PoolByteArray HashingContext::finish() {
-	ERR_FAIL_COND_V(ctx == NULL, PoolByteArray());
+	ERR_FAIL_COND_V(ctx == nullptr, PoolByteArray());
 	PoolByteArray out;
 	Error err = FAILED;
 	switch (type) {
@@ -99,7 +99,7 @@ void HashingContext::_create_ctx(HashType p_type) {
 			ctx = memnew(CryptoCore::SHA256Context);
 			break;
 		default:
-			ctx = NULL;
+			ctx = nullptr;
 	}
 }
 
@@ -115,7 +115,7 @@ void HashingContext::_delete_ctx() {
 			memdelete((CryptoCore::SHA256Context *)ctx);
 			break;
 	}
-	ctx = NULL;
+	ctx = nullptr;
 }
 
 void HashingContext::_bind_methods() {
@@ -128,10 +128,10 @@ void HashingContext::_bind_methods() {
 }
 
 HashingContext::HashingContext() {
-	ctx = NULL;
+	ctx = nullptr;
 }
 
 HashingContext::~HashingContext() {
-	if (ctx != NULL)
+	if (ctx != nullptr)
 		_delete_ctx();
 }

core/dictionary.cpp

@@ -83,7 +83,7 @@ const Variant *Dictionary::getptr(const Variant &p_key) const {
 	OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::ConstElement E = ((const OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator> *)&_p->variant_map)->find(p_key);
 
 	if (!E)
-		return NULL;
+		return nullptr;
 	return &E.get();
 }
 
@@ -91,7 +91,7 @@ Variant *Dictionary::getptr(const Variant &p_key) {
 	OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.find(p_key);
 
 	if (!E)
-		return NULL;
+		return nullptr;
 	return &E.get();
 }
 
@@ -168,7 +168,7 @@ void Dictionary::_unref() const {
 	if (_p->refcount.unref()) {
 		memdelete(_p);
 	}
-	_p = NULL;
+	_p = nullptr;
 }
 uint32_t Dictionary::hash() const {
 	uint32_t h = hash_djb2_one_32(Variant::DICTIONARY);
@@ -214,17 +214,17 @@ Array Dictionary::values() const {
 }
 
 const Variant *Dictionary::next(const Variant *p_key) const {
-	if (p_key == NULL) {
+	if (p_key == nullptr) {
 		// caller wants to get the first element
 		if (_p->variant_map.front())
 			return &_p->variant_map.front().key();
-		return NULL;
+		return nullptr;
 	}
 	OrderedHashMap<Variant, Variant, VariantHasher, VariantComparator>::Element E = _p->variant_map.find(*p_key);
 
 	if (E && E.next())
 		return &E.next().key();
-	return NULL;
+	return nullptr;
 }
 
 Dictionary Dictionary::duplicate(bool p_deep) const {
@@ -246,7 +246,7 @@ const void *Dictionary::id() const {
 }
 
 Dictionary::Dictionary(const Dictionary &p_from) {
-	_p = NULL;
+	_p = nullptr;
 	_ref(p_from);
 }
 

core/dictionary.h

@@ -74,7 +74,7 @@ public:
 	uint32_t hash() const;
 	void operator=(const Dictionary &p_dictionary);
 
-	const Variant *next(const Variant *p_key = NULL) const;
+	const Variant *next(const Variant *p_key = nullptr) const;
 
 	Array keys() const;
 	Array values() const;

core/engine.cpp

@@ -106,7 +106,7 @@ Dictionary Engine::get_version_info() const {
 
 static Array array_from_info(const char *const *info_list) {
 	Array arr;
-	for (int i = 0; info_list[i] != NULL; i++) {
+	for (int i = 0; info_list[i] != nullptr; i++) {
 		arr.push_back(info_list[i]);
 	}
 	return arr;
@@ -185,7 +185,7 @@ void Engine::add_singleton(const Singleton &p_singleton) {
 
 Object *Engine::get_singleton_object(const String &p_name) const {
 	const Map<StringName, Object *>::Element *E = singleton_ptrs.find(p_name);
-	ERR_FAIL_COND_V_MSG(!E, NULL, "Failed to retrieve non-existent singleton '" + p_name + "'.");
+	ERR_FAIL_COND_V_MSG(!E, nullptr, "Failed to retrieve non-existent singleton '" + p_name + "'.");
 	return E->get();
 };
 
@@ -198,7 +198,7 @@ void Engine::get_singletons(List<Singleton> *p_singletons) {
 		p_singletons->push_back(E->get());
 }
 
-Engine *Engine::singleton = NULL;
+Engine *Engine::singleton = nullptr;
 
 Engine *Engine::get_singleton() {
 	return singleton;

core/engine.h

@@ -41,7 +41,7 @@ public:
 	struct Singleton {
 		StringName name;
 		Object *ptr;
-		Singleton(const StringName &p_name = StringName(), Object *p_ptr = NULL);
+		Singleton(const StringName &p_name = StringName(), Object *p_ptr = nullptr);
 	};
 
 private:

core/error_macros.cpp

@@ -34,7 +34,7 @@
 #include "core/ustring.h"
 #include "os/os.h"
 
-static ErrorHandlerList *error_handler_list = NULL;
+static ErrorHandlerList *error_handler_list = nullptr;
 
 void add_error_handler(ErrorHandlerList *p_handler) {
 	_global_lock();
@@ -46,7 +46,7 @@ void add_error_handler(ErrorHandlerList *p_handler) {
 void remove_error_handler(ErrorHandlerList *p_handler) {
 	_global_lock();
 
-	ErrorHandlerList *prev = NULL;
+	ErrorHandlerList *prev = nullptr;
 	ErrorHandlerList *l = error_handler_list;
 
 	while (l) {

core/error_macros.h

@@ -67,9 +67,9 @@ struct ErrorHandlerList {
 	ErrorHandlerList *next;
 
 	ErrorHandlerList() {
-		errfunc = 0;
-		next = 0;
-		userdata = 0;
+		errfunc = nullptr;
+		next = nullptr;
+		userdata = nullptr;
 	}
 };
 

core/hash_map.h

@@ -75,7 +75,7 @@ public:
 
 		uint32_t hash;
 		Element *next;
-		Element() { next = 0; }
+		Element() { next = nullptr; }
 		Pair pair;
 
 	public:
@@ -105,14 +105,14 @@ private:
 		hash_table_power = MIN_HASH_TABLE_POWER;
 		elements = 0;
 		for (int i = 0; i < (1 << MIN_HASH_TABLE_POWER); i++)
-			hash_table[i] = 0;
+			hash_table[i] = nullptr;
 	}
 
 	void erase_hash_table() {
 		ERR_FAIL_COND_MSG(elements, "Cannot erase hash table if there are still elements inside.");
 
 		memdelete_arr(hash_table);
-		hash_table = 0;
+		hash_table = nullptr;
 		hash_table_power = 0;
 		elements = 0;
 	}
@@ -147,7 +147,7 @@ private:
 		ERR_FAIL_COND_MSG(!new_hash_table, "Out of memory.");
 
 		for (int i = 0; i < (1 << new_hash_table_power); i++) {
-			new_hash_table[i] = 0;
+			new_hash_table[i] = nullptr;
 		}
 
 		if (hash_table) {
@@ -184,13 +184,13 @@ private:
 			e = e->next;
 		}
 
-		return NULL;
+		return nullptr;
 	}
 
 	Element *create_element(const TKey &p_key) {
 		/* if element doesn't exist, create it */
 		Element *e = memnew(Element);
-		ERR_FAIL_COND_V_MSG(!e, NULL, "Out of memory.");
+		ERR_FAIL_COND_V_MSG(!e, nullptr, "Out of memory.");
 		uint32_t hash = Hasher::hash(p_key);
 		uint32_t index = hash & ((1 << hash_table_power) - 1);
 		e->next = hash_table[index];
@@ -218,7 +218,7 @@ private:
 		elements = p_t.elements;
 
 		for (int i = 0; i < (1 << p_t.hash_table_power); i++) {
-			hash_table[i] = NULL;
+			hash_table[i] = nullptr;
 
 			const Element *e = p_t.hash_table[i];
 
@@ -242,7 +242,7 @@ public:
 	}
 
 	Element *set(const Pair &p_pair) {
-		Element *e = NULL;
+		Element *e = nullptr;
 		if (!hash_table)
 			make_hash_table(); // if no table, make one
 		else
@@ -253,7 +253,7 @@ public:
 		if (!e) {
 			e = create_element(p_pair.key);
 			if (!e)
-				return NULL;
+				return nullptr;
 			check_hash_table(); // perform mantenience routine
 		}
 
@@ -262,7 +262,7 @@ public:
 	}
 
 	bool has(const TKey &p_key) const {
-		return getptr(p_key) != NULL;
+		return getptr(p_key) != nullptr;
 	}
 
 	/**
@@ -290,26 +290,26 @@ public:
 
 	_FORCE_INLINE_ TData *getptr(const TKey &p_key) {
 		if (unlikely(!hash_table))
-			return NULL;
+			return nullptr;
 
 		Element *e = const_cast<Element *>(get_element(p_key));
 
 		if (e)
 			return &e->pair.data;
 
-		return NULL;
+		return nullptr;
 	}
 
 	_FORCE_INLINE_ const TData *getptr(const TKey &p_key) const {
 		if (unlikely(!hash_table))
-			return NULL;
+			return nullptr;
 
 		const Element *e = const_cast<Element *>(get_element(p_key));
 
 		if (e)
 			return &e->pair.data;
 
-		return NULL;
+		return nullptr;
 	}
 
 	/**
@@ -320,7 +320,7 @@ public:
 	template <class C>
 	_FORCE_INLINE_ TData *custom_getptr(C p_custom_key, uint32_t p_custom_hash) {
 		if (unlikely(!hash_table))
-			return NULL;
+			return nullptr;
 
 		uint32_t hash = p_custom_hash;
 		uint32_t index = hash & ((1 << hash_table_power) - 1);
@@ -337,7 +337,7 @@ public:
 			e = e->next;
 		}
 
-		return NULL;
+		return nullptr;
 	}
 
 	template <class C>
@@ -375,7 +375,7 @@ public:
 		uint32_t index = hash & ((1 << hash_table_power) - 1);
 
 		Element *e = hash_table[index];
-		Element *p = NULL;
+		Element *p = nullptr;
 		while (e) {
 			/* checking hash first avoids comparing key, which may take longer */
 			if (e->hash == hash && Comparator::compare(e->pair.key, p_key)) {
@@ -409,7 +409,7 @@ public:
 	}
 	inline TData &operator[](const TKey &p_key) { //assignment
 
-		Element *e = NULL;
+		Element *e = nullptr;
 		if (!hash_table)
 			make_hash_table(); // if no table, make one
 		else
@@ -442,7 +442,7 @@ public:
 	*/
 	const TKey *next(const TKey *p_key) const {
 		if (unlikely(!hash_table))
-			return NULL;
+			return nullptr;
 
 		if (!p_key) { /* get the first key */
 
@@ -455,7 +455,7 @@ public:
 		} else { /* get the next key */
 
 			const Element *e = get_element(*p_key);
-			ERR_FAIL_COND_V_MSG(!e, NULL, "Invalid key supplied.");
+			ERR_FAIL_COND_V_MSG(!e, nullptr, "Invalid key supplied.");
 			if (e->next) {
 				/* if there is a "next" in the list, return that */
 				return &e->next->pair.key;
@@ -473,7 +473,7 @@ public:
 			/* nothing found, was at end */
 		}
 
-		return NULL; /* nothing found */
+		return nullptr; /* nothing found */
 	}
 
 	inline unsigned int size() const {
@@ -498,7 +498,7 @@ public:
 			memdelete_arr(hash_table);
 		}
 
-		hash_table = 0;
+		hash_table = nullptr;
 		hash_table_power = 0;
 		elements = 0;
 	}
@@ -508,7 +508,7 @@ public:
 	}
 
 	HashMap() {
-		hash_table = NULL;
+		hash_table = nullptr;
 		elements = 0;
 		hash_table_power = 0;
 	}
@@ -539,7 +539,7 @@ public:
 	}
 
 	HashMap(const HashMap &p_table) {
-		hash_table = NULL;
+		hash_table = nullptr;
 		elements = 0;
 		hash_table_power = 0;
 

core/image.cpp

@@ -82,10 +82,10 @@ const char *Image::format_names[Image::FORMAT_MAX] = {
 
 };
 
-SavePNGFunc Image::save_png_func = NULL;
-SaveEXRFunc Image::save_exr_func = NULL;
+SavePNGFunc Image::save_png_func = nullptr;
+SaveEXRFunc Image::save_exr_func = nullptr;
 
-SavePNGBufferFunc Image::save_png_buffer_func = NULL;
+SavePNGBufferFunc Image::save_png_buffer_func = nullptr;
 
 void Image::_put_pixelb(int p_x, int p_y, uint32_t p_pixelsize, uint8_t *p_data, const uint8_t *p_pixel) {
 	uint32_t ofs = (p_y * width + p_x) * p_pixelsize;
@@ -2005,14 +2005,14 @@ Error Image::load(const String &p_path) {
 }
 
 Error Image::save_png(const String &p_path) const {
-	if (save_png_func == NULL)
+	if (save_png_func == nullptr)
 		return ERR_UNAVAILABLE;
 
 	return save_png_func(p_path, Ref<Image>((Image *)this));
 }
 
 PoolVector<uint8_t> Image::save_png_to_buffer() const {
-	if (save_png_buffer_func == NULL) {
+	if (save_png_buffer_func == nullptr) {
 		return PoolVector<uint8_t>();
 	}
 
@@ -2020,7 +2020,7 @@ PoolVector<uint8_t> Image::save_png_to_buffer() const {
 }
 
 Error Image::save_exr(const String &p_path, bool p_grayscale) const {
-	if (save_exr_func == NULL)
+	if (save_exr_func == nullptr)
 		return ERR_UNAVAILABLE;
 
 	return save_exr_func(p_path, Ref<Image>((Image *)this), p_grayscale);
@@ -2402,28 +2402,28 @@ void Image::fill(const Color &c) {
 	unlock();
 }
 
-ImageMemLoadFunc Image::_png_mem_loader_func = NULL;
-ImageMemLoadFunc Image::_jpg_mem_loader_func = NULL;
-ImageMemLoadFunc Image::_webp_mem_loader_func = NULL;
-ImageMemLoadFunc Image::_tga_mem_loader_func = NULL;
-ImageMemLoadFunc Image::_bmp_mem_loader_func = NULL;
-
-void (*Image::_image_compress_bc_func)(Image *, float, Image::CompressSource) = NULL;
-void (*Image::_image_compress_bptc_func)(Image *, float, Image::CompressSource) = NULL;
-void (*Image::_image_compress_pvrtc2_func)(Image *) = NULL;
-void (*Image::_image_compress_pvrtc4_func)(Image *) = NULL;
-void (*Image::_image_compress_etc1_func)(Image *, float) = NULL;
-void (*Image::_image_compress_etc2_func)(Image *, float, Image::CompressSource) = NULL;
-void (*Image::_image_decompress_pvrtc)(Image *) = NULL;
-void (*Image::_image_decompress_bc)(Image *) = NULL;
-void (*Image::_image_decompress_bptc)(Image *) = NULL;
-void (*Image::_image_decompress_etc1)(Image *) = NULL;
-void (*Image::_image_decompress_etc2)(Image *) = NULL;
-
-PoolVector<uint8_t> (*Image::lossy_packer)(const Ref<Image> &, float) = NULL;
-Ref<Image> (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = NULL;
-PoolVector<uint8_t> (*Image::lossless_packer)(const Ref<Image> &) = NULL;
-Ref<Image> (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = NULL;
+ImageMemLoadFunc Image::_png_mem_loader_func = nullptr;
+ImageMemLoadFunc Image::_jpg_mem_loader_func = nullptr;
+ImageMemLoadFunc Image::_webp_mem_loader_func = nullptr;
+ImageMemLoadFunc Image::_tga_mem_loader_func = nullptr;
+ImageMemLoadFunc Image::_bmp_mem_loader_func = nullptr;
+
+void (*Image::_image_compress_bc_func)(Image *, float, Image::CompressSource) = nullptr;
+void (*Image::_image_compress_bptc_func)(Image *, float, Image::CompressSource) = nullptr;
+void (*Image::_image_compress_pvrtc2_func)(Image *) = nullptr;
+void (*Image::_image_compress_pvrtc4_func)(Image *) = nullptr;
+void (*Image::_image_compress_etc1_func)(Image *, float) = nullptr;
+void (*Image::_image_compress_etc2_func)(Image *, float, Image::CompressSource) = nullptr;
+void (*Image::_image_decompress_pvrtc)(Image *) = nullptr;
+void (*Image::_image_decompress_bc)(Image *) = nullptr;
+void (*Image::_image_decompress_bptc)(Image *) = nullptr;
+void (*Image::_image_decompress_etc1)(Image *) = nullptr;
+void (*Image::_image_decompress_etc2)(Image *) = nullptr;
+
+PoolVector<uint8_t> (*Image::lossy_packer)(const Ref<Image> &, float) = nullptr;
+Ref<Image> (*Image::lossy_unpacker)(const PoolVector<uint8_t> &) = nullptr;
+PoolVector<uint8_t> (*Image::lossless_packer)(const Ref<Image> &) = nullptr;
+Ref<Image> (*Image::lossless_unpacker)(const PoolVector<uint8_t> &) = nullptr;
 
 void Image::_set_data(const Dictionary &p_data) {
 	ERR_FAIL_COND(!p_data.has("width"));

core/input_map.cpp

@@ -34,7 +34,7 @@
 #include "core/os/keyboard.h"
 #include "core/project_settings.h"
 
-InputMap *InputMap::singleton = NULL;
+InputMap *InputMap::singleton = nullptr;
 
 int InputMap::ALL_DEVICES = -1;
 
@@ -124,7 +124,7 @@ List<StringName> InputMap::get_actions() const {
 }
 
 List<Ref<InputEvent>>::Element *InputMap::_find_event(Action &p_action, const Ref<InputEvent> &p_event, bool *p_pressed, float *p_strength) const {
-	ERR_FAIL_COND_V(!p_event.is_valid(), NULL);
+	ERR_FAIL_COND_V(!p_event.is_valid(), nullptr);
 
 	for (List<Ref<InputEvent>>::Element *E = p_action.inputs.front(); E; E = E->next()) {
 		const Ref<InputEvent> e = E->get();
@@ -140,7 +140,7 @@ List<Ref<InputEvent>>::Element *InputMap::_find_event(Action &p_action, const Re
 		}
 	}
 
-	return NULL;
+	return nullptr;
 }
 
 bool InputMap::has_action(const StringName &p_action) const {
@@ -166,7 +166,7 @@ void InputMap::action_add_event(const StringName &p_action, const Ref<InputEvent
 bool InputMap::action_has_event(const StringName &p_action, const Ref<InputEvent> &p_event) {
 	ERR_FAIL_COND_V_MSG(!input_map.has(p_action), false, _suggest_actions(p_action));
 
-	return (_find_event(input_map[p_action], p_event) != NULL);
+	return (_find_event(input_map[p_action], p_event) != nullptr);
 }
 
 void InputMap::action_erase_event(const StringName &p_action, const Ref<InputEvent> &p_event) {
@@ -202,7 +202,7 @@ Array InputMap::_get_action_list(const StringName &p_action) {
 const List<Ref<InputEvent>> *InputMap::get_action_list(const StringName &p_action) {
 	const Map<StringName, Action>::Element *E = input_map.find(p_action);
 	if (!E)
-		return NULL;
+		return nullptr;
 
 	return &E->get().inputs;
 }
@@ -217,20 +217,20 @@ bool InputMap::event_get_action_status(const Ref<InputEvent> &p_event, const Str
 
 	Ref<InputEventAction> input_event_action = p_event;
 	if (input_event_action.is_valid()) {
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = input_event_action->is_pressed();
-		if (p_strength != NULL)
-			*p_strength = (p_pressed != NULL && *p_pressed) ? input_event_action->get_strength() : 0.0f;
+		if (p_strength != nullptr)
+			*p_strength = (p_pressed != nullptr && *p_pressed) ? input_event_action->get_strength() : 0.0f;
 		return input_event_action->get_action() == p_action;
 	}
 
 	bool pressed;
 	float strength;
 	List<Ref<InputEvent>>::Element *event = _find_event(E->get(), p_event, &pressed, &strength);
-	if (event != NULL) {
-		if (p_pressed != NULL)
+	if (event != nullptr) {
+		if (p_pressed != nullptr)
 			*p_pressed = pressed;
-		if (p_strength != NULL)
+		if (p_strength != nullptr)
 			*p_strength = strength;
 		return true;
 	} else {

core/input_map.h

@@ -54,7 +54,7 @@ private:
 
 	mutable Map<StringName, Action> input_map;
 
-	List<Ref<InputEvent>>::Element *_find_event(Action &p_action, const Ref<InputEvent> &p_event, bool *p_pressed = NULL, float *p_strength = NULL) const;
+	List<Ref<InputEvent>>::Element *_find_event(Action &p_action, const Ref<InputEvent> &p_event, bool *p_pressed = nullptr, float *p_strength = nullptr) const;
 
 	Array _get_action_list(const StringName &p_action);
 	Array _get_actions();
@@ -79,7 +79,7 @@ public:
 
 	const List<Ref<InputEvent>> *get_action_list(const StringName &p_action);
 	bool event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action) const;
-	bool event_get_action_status(const Ref<InputEvent> &p_event, const StringName &p_action, bool *p_pressed = NULL, float *p_strength = NULL) const;
+	bool event_get_action_status(const Ref<InputEvent> &p_event, const StringName &p_action, bool *p_pressed = nullptr, float *p_strength = nullptr) const;
 
 	const Map<StringName, Action> &get_action_map() const;
 	void load_from_globals();

core/io/config_file.cpp

@@ -264,7 +264,7 @@ Error ConfigFile::_parse(const String &p_path, VariantParser::Stream *p_stream)
 		next_tag.fields.clear();
 		next_tag.name = String();
 
-		Error err = VariantParser::parse_tag_assign_eof(p_stream, lines, error_text, next_tag, assign, value, NULL, true);
+		Error err = VariantParser::parse_tag_assign_eof(p_stream, lines, error_text, next_tag, assign, value, nullptr, true);
 		if (err == ERR_FILE_EOF) {
 			return OK;
 		} else if (err != OK) {

core/io/dtls_server.cpp

@@ -32,14 +32,14 @@
 #include "core/os/file_access.h"
 #include "core/project_settings.h"
 
-DTLSServer *(*DTLSServer::_create)() = NULL;
+DTLSServer *(*DTLSServer::_create)() = nullptr;
 bool DTLSServer::available = false;
 
 DTLSServer *DTLSServer::create() {
 	if (_create) {
 		return _create();
 	}
-	return NULL;
+	return nullptr;
 }
 
 bool DTLSServer::is_available() {

core/io/file_access_compressed.cpp

@@ -62,7 +62,7 @@ Error FileAccessCompressed::open_after_magic(FileAccess *p_base) {
 	cmode = (Compression::Mode)f->get_32();
 	block_size = f->get_32();
 	if (block_size == 0) {
-		f = NULL; // Let the caller to handle the FileAccess object if failed to open as compressed file.
+		f = nullptr; // Let the caller to handle the FileAccess object if failed to open as compressed file.
 		ERR_FAIL_V_MSG(ERR_FILE_CORRUPT, "Can't open compressed file '" + p_base->get_path() + "' with block size 0, it is corrupted.");
 	}
 	read_total = f->get_32();
@@ -105,7 +105,7 @@ Error FileAccessCompressed::_open(const String &p_path, int p_mode_flags) {
 	if (err != OK) {
 		//not openable
 
-		f = NULL;
+		f = nullptr;
 		return err;
 	}
 
@@ -125,7 +125,7 @@ Error FileAccessCompressed::_open(const String &p_path, int p_mode_flags) {
 		rmagic[4] = 0;
 		if (magic != rmagic || open_after_magic(f) != OK) {
 			memdelete(f);
-			f = NULL;
+			f = nullptr;
 			return ERR_FILE_UNRECOGNIZED;
 		}
 	}
@@ -178,11 +178,11 @@ void FileAccessCompressed::close() {
 	}
 
 	memdelete(f);
-	f = NULL;
+	f = nullptr;
 }
 
 bool FileAccessCompressed::is_open() const {
-	return f != NULL;
+	return f != nullptr;
 }
 
 void FileAccessCompressed::seek(size_t p_position) {
@@ -364,20 +364,20 @@ Error FileAccessCompressed::_set_unix_permissions(const String &p_file, uint32_t
 FileAccessCompressed::FileAccessCompressed() :
 		cmode(Compression::MODE_ZSTD),
 		writing(false),
-		write_ptr(0),
+		write_ptr(nullptr),
 		write_buffer_size(0),
 		write_max(0),
 		block_size(0),
 		read_eof(false),
 		at_end(false),
-		read_ptr(NULL),
+		read_ptr(nullptr),
 		read_block(0),
 		read_block_count(0),
 		read_block_size(0),
 		read_pos(0),
 		read_total(0),
 		magic("GCMP"),
-		f(NULL) {
+		f(nullptr) {
 }
 
 FileAccessCompressed::~FileAccessCompressed() {

core/io/file_access_encrypted.cpp

@@ -39,7 +39,7 @@
 #define COMP_MAGIC 0x43454447
 
 Error FileAccessEncrypted::open_and_parse(FileAccess *p_base, const Vector<uint8_t> &p_key, Mode p_mode) {
-	ERR_FAIL_COND_V_MSG(file != NULL, ERR_ALREADY_IN_USE, "Can't open file while another file from path '" + file->get_path_absolute() + "' is open.");
+	ERR_FAIL_COND_V_MSG(file != nullptr, ERR_ALREADY_IN_USE, "Can't open file while another file from path '" + file->get_path_absolute() + "' is open.");
 	ERR_FAIL_COND_V(p_key.size() != 32, ERR_INVALID_PARAMETER);
 
 	pos = 0;
@@ -148,19 +148,19 @@ void FileAccessEncrypted::close() {
 		file->store_buffer(compressed.ptr(), compressed.size());
 		file->close();
 		memdelete(file);
-		file = NULL;
+		file = nullptr;
 		data.clear();
 
 	} else {
 		file->close();
 		memdelete(file);
 		data.clear();
-		file = NULL;
+		file = nullptr;
 	}
 }
 
 bool FileAccessEncrypted::is_open() const {
-	return file != NULL;
+	return file != nullptr;
 }
 
 String FileAccessEncrypted::get_path() const {
@@ -288,7 +288,7 @@ Error FileAccessEncrypted::_set_unix_permissions(const String &p_file, uint32_t
 }
 
 FileAccessEncrypted::FileAccessEncrypted() {
-	file = NULL;
+	file = nullptr;
 	pos = 0;
 	eofed = false;
 	mode = MODE_MAX;

core/io/file_access_memory.cpp

@@ -34,7 +34,7 @@
 #include "core/os/dir_access.h"
 #include "core/project_settings.h"
 
-static Map<String, Vector<uint8_t>> *files = NULL;
+static Map<String, Vector<uint8_t>> *files = nullptr;
 
 void FileAccessMemory::register_file(String p_name, Vector<uint8_t> p_data) {
 	if (!files) {
@@ -66,7 +66,7 @@ bool FileAccessMemory::file_exists(const String &p_name) {
 	String name = fix_path(p_name);
 	//name = DirAccess::normalize_path(name);
 
-	return files && (files->find(name) != NULL);
+	return files && (files->find(name) != nullptr);
 }
 
 Error FileAccessMemory::open_custom(const uint8_t *p_data, int p_len) {
@@ -93,11 +93,11 @@ Error FileAccessMemory::_open(const String &p_path, int p_mode_flags) {
 }
 
 void FileAccessMemory::close() {
-	data = NULL;
+	data = nullptr;
 }
 
 bool FileAccessMemory::is_open() const {
-	return data != NULL;
+	return data != nullptr;
 }
 
 void FileAccessMemory::seek(size_t p_position) {
@@ -178,5 +178,5 @@ void FileAccessMemory::store_buffer(const uint8_t *p_src, int p_length) {
 }
 
 FileAccessMemory::FileAccessMemory() {
-	data = NULL;
+	data = nullptr;
 }

core/io/file_access_network.cpp

@@ -105,7 +105,7 @@ void FileAccessNetworkClient::_thread_func() {
 		int response = get_32();
 		DEBUG_PRINT("GET RESPONSE: " + itos(response));
 
-		FileAccessNetwork *fa = NULL;
+		FileAccessNetwork *fa = nullptr;
 
 		if (response != FileAccessNetwork::RESPONSE_DATA) {
 			if (!accesses.has(id)) {
@@ -203,7 +203,7 @@ Error FileAccessNetworkClient::connect(const String &p_host, int p_port, const S
 	return OK;
 }
 
-FileAccessNetworkClient *FileAccessNetworkClient::singleton = NULL;
+FileAccessNetworkClient *FileAccessNetworkClient::singleton = nullptr;
 
 FileAccessNetworkClient::FileAccessNetworkClient() {
 	quit = false;
@@ -271,7 +271,7 @@ Error FileAccessNetwork::_open(const String &p_path, int p_mode_flags) {
 	pos = 0;
 	eof_flag = false;
 	last_page = -1;
-	last_page_buff = NULL;
+	last_page_buff = nullptr;
 
 	//buffers.clear();
 	nc->unlock_mutex();

core/io/file_access_pack.cpp

@@ -91,17 +91,17 @@ void PackedData::add_path(const String &pkg_path, const String &path, uint64_t o
 }
 
 void PackedData::add_pack_source(PackSource *p_source) {
-	if (p_source != NULL) {
+	if (p_source != nullptr) {
 		sources.push_back(p_source);
 	}
 };
 
-PackedData *PackedData::singleton = NULL;
+PackedData *PackedData::singleton = nullptr;
 
 PackedData::PackedData() {
 	singleton = this;
 	root = memnew(PackedDir);
-	root->parent = NULL;
+	root->parent = nullptr;
 	disabled = false;
 
 	add_pack_source(memnew(PackedSourcePCK));
@@ -420,7 +420,7 @@ PackedData::PackedDir *DirAccessPack::_find_dir(String p_dir) {
 			pd = pd->subdirs[p];
 
 		} else {
-			return NULL;
+			return nullptr;
 		}
 	}
 
@@ -462,7 +462,7 @@ bool DirAccessPack::file_exists(String p_file) {
 bool DirAccessPack::dir_exists(String p_dir) {
 	p_dir = fix_path(p_dir);
 
-	return _find_dir(p_dir) != NULL;
+	return _find_dir(p_dir) != nullptr;
 }
 
 Error DirAccessPack::make_dir(String p_dir) {

core/io/file_access_pack.h

@@ -183,9 +183,9 @@ FileAccess *PackedData::try_open_path(const String &p_path) {
 	PathMD5 pmd5(p_path.md5_buffer());
 	Map<PathMD5, PackedFile>::Element *E = files.find(pmd5);
 	if (!E)
-		return NULL; //not found
+		return nullptr; //not found
 	if (E->get().offset == 0)
-		return NULL; //was erased
+		return nullptr; //was erased
 
 	return E->get().src->get_file(p_path, &E->get());
 }
@@ -246,7 +246,7 @@ DirAccess *PackedData::try_open_directory(const String &p_path) {
 	DirAccess *da = memnew(DirAccessPack());
 	if (da->change_dir(p_path) != OK) {
 		memdelete(da);
-		da = NULL;
+		da = nullptr;
 	}
 	return da;
 }

core/io/file_access_zip.cpp

@@ -34,19 +34,19 @@
 
 #include "core/os/file_access.h"
 
-ZipArchive *ZipArchive::instance = NULL;
+ZipArchive *ZipArchive::instance = nullptr;
 
 extern "C" {
 
 static void *godot_open(void *data, const char *p_fname, int mode) {
 	if (mode & ZLIB_FILEFUNC_MODE_WRITE) {
-		return NULL;
+		return nullptr;
 	}
 
 	FileAccess *f = (FileAccess *)data;
 	f->open(p_fname, FileAccess::READ);
 
-	return f->is_open() ? data : NULL;
+	return f->is_open() ? data : nullptr;
 }
 
 static uLong godot_read(void *data, void *fdata, void *buf, uLong size) {
@@ -113,11 +113,11 @@ void ZipArchive::close_handle(unzFile p_file) const {
 }
 
 unzFile ZipArchive::get_file_handle(String p_file) const {
-	ERR_FAIL_COND_V_MSG(!file_exists(p_file), NULL, "File '" + p_file + " doesn't exist.");
+	ERR_FAIL_COND_V_MSG(!file_exists(p_file), nullptr, "File '" + p_file + " doesn't exist.");
 	File file = files[p_file];
 
 	FileAccess *f = FileAccess::open(packages[file.package].filename, FileAccess::READ);
-	ERR_FAIL_COND_V_MSG(!f, NULL, "Cannot open file '" + packages[file.package].filename + "'.");
+	ERR_FAIL_COND_V_MSG(!f, nullptr, "Cannot open file '" + packages[file.package].filename + "'.");
 
 	zlib_filefunc_def io;
 	memset(&io, 0, sizeof(io));
@@ -136,11 +136,11 @@ unzFile ZipArchive::get_file_handle(String p_file) const {
 	io.free_mem = godot_free;
 
 	unzFile pkg = unzOpen2(packages[file.package].filename.utf8().get_data(), &io);
-	ERR_FAIL_COND_V(!pkg, NULL);
+	ERR_FAIL_COND_V(!pkg, nullptr);
 	int unz_err = unzGoToFilePos(pkg, &file.file_pos);
 	if (unz_err != UNZ_OK || unzOpenCurrentFile(pkg) != UNZ_OK) {
 		unzClose(pkg);
-		ERR_FAIL_V(NULL);
+		ERR_FAIL_V(nullptr);
 	}
 
 	return pkg;
@@ -186,7 +186,7 @@ bool ZipArchive::try_open_pack(const String &p_path, bool p_replace_files, size_
 		char filename_inzip[256];
 
 		unz_file_info64 file_info;
-		err = unzGetCurrentFileInfo64(zfile, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		err = unzGetCurrentFileInfo64(zfile, &file_info, filename_inzip, sizeof(filename_inzip), nullptr, 0, nullptr, 0);
 		ERR_CONTINUE(err != UNZ_OK);
 
 		File f;
@@ -217,7 +217,7 @@ FileAccess *ZipArchive::get_file(const String &p_path, PackedData::PackedFile *p
 }
 
 ZipArchive *ZipArchive::get_singleton() {
-	if (instance == NULL) {
+	if (instance == nullptr) {
 		instance = memnew(ZipArchive);
 	}
 
@@ -248,7 +248,7 @@ Error FileAccessZip::_open(const String &p_path, int p_mode_flags) {
 	zfile = arch->get_file_handle(p_path);
 	ERR_FAIL_COND_V(!zfile, FAILED);
 
-	int err = unzGetCurrentFileInfo64(zfile, &file_info, NULL, 0, NULL, 0, NULL, 0);
+	int err = unzGetCurrentFileInfo64(zfile, &file_info, nullptr, 0, nullptr, 0, nullptr, 0);
 	ERR_FAIL_COND_V(err != UNZ_OK, FAILED);
 
 	return OK;
@@ -261,11 +261,11 @@ void FileAccessZip::close() {
 	ZipArchive *arch = ZipArchive::get_singleton();
 	ERR_FAIL_COND(!arch);
 	arch->close_handle(zfile);
-	zfile = NULL;
+	zfile = nullptr;
 }
 
 bool FileAccessZip::is_open() const {
-	return zfile != NULL;
+	return zfile != nullptr;
 }
 
 void FileAccessZip::seek(size_t p_position) {
@@ -338,7 +338,7 @@ bool FileAccessZip::file_exists(const String &p_name) {
 }
 
 FileAccessZip::FileAccessZip(const String &p_path, const PackedData::PackedFile &p_file) :
-		zfile(NULL) {
+		zfile(nullptr) {
 	_open(p_path, FileAccess::READ);
 }
 

core/io/image_loader.cpp

@@ -92,7 +92,7 @@ ImageFormatLoader *ImageLoader::recognize(const String &p_extension) {
 			return loader[i];
 	}
 
-	return NULL;
+	return nullptr;
 }
 
 Vector<ImageFormatLoader *> ImageLoader::loader;

core/io/image_loader.h

@@ -58,7 +58,7 @@ class ImageLoader {
 
 protected:
 public:
-	static Error load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom = NULL, bool p_force_linear = false, float p_scale = 1.0);
+	static Error load_image(String p_file, Ref<Image> p_image, FileAccess *p_custom = nullptr, bool p_force_linear = false, float p_scale = 1.0);
 	static void get_recognized_extensions(List<String> *p_extensions);
 	static ImageFormatLoader *recognize(const String &p_extension);
 
@@ -72,7 +72,7 @@ public:
 
 class ResourceFormatLoaderImage : public ResourceFormatLoader {
 public:
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;

core/io/ip.cpp

@@ -277,17 +277,17 @@ void IP::_bind_methods() {
 	BIND_ENUM_CONSTANT(TYPE_ANY);
 }
 
-IP *IP::singleton = NULL;
+IP *IP::singleton = nullptr;
 
 IP *IP::get_singleton() {
 	return singleton;
 }
 
-IP *(*IP::_create)() = NULL;
+IP *(*IP::_create)() = nullptr;
 
 IP *IP::create() {
-	ERR_FAIL_COND_V_MSG(singleton, NULL, "IP singleton already exist.");
-	ERR_FAIL_COND_V(!_create, NULL);
+	ERR_FAIL_COND_V_MSG(singleton, nullptr, "IP singleton already exist.");
+	ERR_FAIL_COND_V(!_create, nullptr);
 	return _create();
 }
 

core/io/logger.cpp

@@ -125,7 +125,7 @@ Logger::~Logger() {}
 void RotatedFileLogger::close_file() {
 	if (file) {
 		memdelete(file);
-		file = NULL;
+		file = nullptr;
 	}
 }
 
@@ -199,7 +199,7 @@ void RotatedFileLogger::rotate_file() {
 RotatedFileLogger::RotatedFileLogger(const String &p_base_path, int p_max_files) :
 		base_path(p_base_path.simplify_path()),
 		max_files(p_max_files > 0 ? p_max_files : 1),
-		file(NULL) {
+		file(nullptr) {
 	rotate_file();
 }
 

core/io/marshalls.cpp

@@ -366,7 +366,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 					(*r_len) += 8;
 
 				if (val == 0) {
-					r_variant = (Object *)NULL;
+					r_variant = (Object *)nullptr;
 				} else {
 					Ref<EncodedObjectAsID> obj_as_id;
 					obj_as_id.instance();
@@ -384,7 +384,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 					return err;
 
 				if (str == String()) {
-					r_variant = (Object *)NULL;
+					r_variant = (Object *)nullptr;
 				} else {
 					Object *obj = ClassDB::instance(str);
 

core/io/marshalls.h

@@ -179,7 +179,7 @@ public:
 	EncodedObjectAsID();
 };
 
-Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int *r_len = NULL, bool p_allow_objects = false);
+Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int *r_len = nullptr, bool p_allow_objects = false);
 Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bool p_full_objects = false);
 
 #endif

core/io/multiplayer_api.cpp

@@ -167,7 +167,7 @@ Ref<NetworkedMultiplayerPeer> MultiplayerAPI::get_network_peer() const {
 }
 
 void MultiplayerAPI::_process_packet(int p_from, const uint8_t *p_packet, int p_packet_len) {
-	ERR_FAIL_COND_MSG(root_node == NULL, "Multiplayer root node was not initialized. If you are using custom multiplayer, remember to set the root node via MultiplayerAPI.set_root_node before using it.");
+	ERR_FAIL_COND_MSG(root_node == nullptr, "Multiplayer root node was not initialized. If you are using custom multiplayer, remember to set the root node via MultiplayerAPI.set_root_node before using it.");
 	ERR_FAIL_COND_MSG(p_packet_len < 1, "Invalid packet received. Size too small.");
 
 #ifdef DEBUG_ENABLED
@@ -195,7 +195,7 @@ void MultiplayerAPI::_process_packet(int p_from, const uint8_t *p_packet, int p_
 
 			Node *node = _process_get_node(p_from, p_packet, p_packet_len);
 
-			ERR_FAIL_COND_MSG(node == NULL, "Invalid packet received. Requested node was not found.");
+			ERR_FAIL_COND_MSG(node == nullptr, "Invalid packet received. Requested node was not found.");
 
 			// Detect cstring end.
 			int len_end = 5;
@@ -226,14 +226,14 @@ void MultiplayerAPI::_process_packet(int p_from, const uint8_t *p_packet, int p_
 
 Node *MultiplayerAPI::_process_get_node(int p_from, const uint8_t *p_packet, int p_packet_len) {
 	uint32_t target = decode_uint32(&p_packet[1]);
-	Node *node = NULL;
+	Node *node = nullptr;
 
 	if (target & 0x80000000) {
 		// Use full path (not cached yet).
 
 		int ofs = target & 0x7FFFFFFF;
 
-		ERR_FAIL_COND_V_MSG(ofs >= p_packet_len, NULL, "Invalid packet received. Size smaller than declared.");
+		ERR_FAIL_COND_V_MSG(ofs >= p_packet_len, nullptr, "Invalid packet received. Size smaller than declared.");
 
 		String paths;
 		paths.parse_utf8((const char *)&p_packet[ofs], p_packet_len - ofs);
@@ -249,10 +249,10 @@ Node *MultiplayerAPI::_process_get_node(int p_from, const uint8_t *p_packet, int
 		int id = target;
 
 		Map<int, PathGetCache>::Element *E = path_get_cache.find(p_from);
-		ERR_FAIL_COND_V_MSG(!E, NULL, "Invalid packet received. Requests invalid peer cache.");
+		ERR_FAIL_COND_V_MSG(!E, nullptr, "Invalid packet received. Requests invalid peer cache.");
 
 		Map<int, PathGetCache::NodeInfo>::Element *F = E->get().nodes.find(id);
-		ERR_FAIL_COND_V_MSG(!F, NULL, "Invalid packet received. Unabled to find requested cached node.");
+		ERR_FAIL_COND_V_MSG(!F, nullptr, "Invalid packet received. Unabled to find requested cached node.");
 
 		PathGetCache::NodeInfo *ni = &F->get();
 		// Do proper caching later.
@@ -340,7 +340,7 @@ void MultiplayerAPI::_process_rset(Node *p_node, const StringName &p_name, int p
 #endif
 
 	Variant value;
-	Error err = decode_variant(value, &p_packet[p_offset], p_packet_len - p_offset, NULL, allow_object_decoding || network_peer->is_object_decoding_allowed());
+	Error err = decode_variant(value, &p_packet[p_offset], p_packet_len - p_offset, nullptr, allow_object_decoding || network_peer->is_object_decoding_allowed());
 
 	ERR_FAIL_COND_MSG(err != OK, "Invalid packet received. Unable to decode RSET value.");
 
@@ -374,7 +374,7 @@ void MultiplayerAPI::_process_simplify_path(int p_from, const uint8_t *p_packet,
 
 	// Encode path to send ack.
 	CharString pname = String(path).utf8();
-	int len = encode_cstring(pname.get_data(), NULL);
+	int len = encode_cstring(pname.get_data(), nullptr);
 
 	Vector<uint8_t> packet;
 
@@ -432,7 +432,7 @@ bool MultiplayerAPI::_send_confirm_path(NodePath p_path, PathSentCache *psc, int
 	for (List<int>::Element *E = peers_to_add.front(); E; E = E->next()) {
 		// Encode function name.
 		CharString pname = String(p_path).utf8();
-		int len = encode_cstring(pname.get_data(), NULL);
+		int len = encode_cstring(pname.get_data(), nullptr);
 
 		Vector<uint8_t> packet;
 
@@ -498,14 +498,14 @@ void MultiplayerAPI::_send_rpc(Node *p_from, int p_to, bool p_unreliable, bool p
 
 	// Encode function name.
 	CharString name = String(p_name).utf8();
-	int len = encode_cstring(name.get_data(), NULL);
+	int len = encode_cstring(name.get_data(), nullptr);
 	MAKE_ROOM(ofs + len);
 	encode_cstring(name.get_data(), &(packet_cache.write[ofs]));
 	ofs += len;
 
 	if (p_set) {
 		// Set argument.
-		Error err = encode_variant(*p_arg[0], NULL, len, allow_object_decoding || network_peer->is_object_decoding_allowed());
+		Error err = encode_variant(*p_arg[0], nullptr, len, allow_object_decoding || network_peer->is_object_decoding_allowed());
 		ERR_FAIL_COND_MSG(err != OK, "Unable to encode RSET value. THIS IS LIKELY A BUG IN THE ENGINE!");
 		MAKE_ROOM(ofs + len);
 		encode_variant(*p_arg[0], &(packet_cache.write[ofs]), len, allow_object_decoding || network_peer->is_object_decoding_allowed());
@@ -517,7 +517,7 @@ void MultiplayerAPI::_send_rpc(Node *p_from, int p_to, bool p_unreliable, bool p
 		packet_cache.write[ofs] = p_argcount;
 		ofs += 1;
 		for (int i = 0; i < p_argcount; i++) {
-			Error err = encode_variant(*p_arg[i], NULL, len, allow_object_decoding || network_peer->is_object_decoding_allowed());
+			Error err = encode_variant(*p_arg[i], nullptr, len, allow_object_decoding || network_peer->is_object_decoding_allowed());
 			ERR_FAIL_COND_MSG(err != OK, "Unable to encode RPC argument. THIS IS LIKELY A BUG IN THE ENGINE!");
 			MAKE_ROOM(ofs + len);
 			encode_variant(*p_arg[i], &(packet_cache.write[ofs]), len, allow_object_decoding || network_peer->is_object_decoding_allowed());
@@ -548,7 +548,7 @@ void MultiplayerAPI::_send_rpc(Node *p_from, int p_to, bool p_unreliable, bool p
 
 		// Append path at the end, since we will need it for some packets.
 		CharString pname = String(from_path).utf8();
-		int path_len = encode_cstring(pname.get_data(), NULL);
+		int path_len = encode_cstring(pname.get_data(), nullptr);
 		MAKE_ROOM(ofs + path_len);
 		encode_cstring(pname.get_data(), &(packet_cache.write[ofs]));
 
@@ -961,7 +961,7 @@ void MultiplayerAPI::_bind_methods() {
 MultiplayerAPI::MultiplayerAPI() :
 		allow_object_decoding(false) {
 	rpc_sender_id = 0;
-	root_node = NULL;
+	root_node = nullptr;
 #ifdef DEBUG_ENABLED
 	profiling = false;
 #endif

core/io/net_socket.cpp

@@ -30,12 +30,12 @@
 
 #include "net_socket.h"
 
-NetSocket *(*NetSocket::_create)() = NULL;
+NetSocket *(*NetSocket::_create)() = nullptr;
 
 NetSocket *NetSocket::create() {
 	if (_create)
 		return _create();
 
 	ERR_PRINT("Unable to create network socket, platform not supported");
-	return NULL;
+	return nullptr;
 }

core/io/packet_peer.cpp

@@ -94,12 +94,12 @@ Error PacketPeer::get_var(Variant &r_variant, bool p_allow_objects) {
 	if (err)
 		return err;
 
-	return decode_variant(r_variant, buffer, buffer_size, NULL, p_allow_objects || allow_object_decoding);
+	return decode_variant(r_variant, buffer, buffer_size, nullptr, p_allow_objects || allow_object_decoding);
 }
 
 Error PacketPeer::put_var(const Variant &p_packet, bool p_full_objects) {
 	int len;
-	Error err = encode_variant(p_packet, NULL, len, p_full_objects || allow_object_decoding); // compute len first
+	Error err = encode_variant(p_packet, nullptr, len, p_full_objects || allow_object_decoding); // compute len first
 	if (err)
 		return err;
 

core/io/packet_peer_dtls.cpp

@@ -32,14 +32,14 @@
 #include "core/os/file_access.h"
 #include "core/project_settings.h"
 
-PacketPeerDTLS *(*PacketPeerDTLS::_create)() = NULL;
+PacketPeerDTLS *(*PacketPeerDTLS::_create)() = nullptr;
 bool PacketPeerDTLS::available = false;
 
 PacketPeerDTLS *PacketPeerDTLS::create() {
 	if (_create) {
 		return _create();
 	}
-	return NULL;
+	return nullptr;
 }
 
 bool PacketPeerDTLS::is_available() {

core/io/pck_packer.cpp

@@ -58,7 +58,7 @@ void PCKPacker::_bind_methods() {
 };
 
 Error PCKPacker::pck_start(const String &p_file, int p_alignment) {
-	if (file != NULL) {
+	if (file != nullptr) {
 		memdelete(file);
 	}
 
@@ -170,12 +170,12 @@ Error PCKPacker::flush(bool p_verbose) {
 };
 
 PCKPacker::PCKPacker() {
-	file = NULL;
+	file = nullptr;
 };
 
 PCKPacker::~PCKPacker() {
-	if (file != NULL) {
+	if (file != nullptr) {
 		memdelete(file);
 	};
-	file = NULL;
+	file = nullptr;
 };

core/io/resource_format_binary.cpp

@@ -906,7 +906,7 @@ String ResourceInteractiveLoaderBinary::recognize(FileAccess *p_f) {
 
 ResourceInteractiveLoaderBinary::ResourceInteractiveLoaderBinary() :
 		translation_remapped(false),
-		f(NULL),
+		f(nullptr),
 		error(OK),
 		stage(0) {
 }
@@ -983,7 +983,7 @@ Error ResourceFormatLoaderBinary::rename_dependencies(const String &p_path, cons
 	FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
 	ERR_FAIL_COND_V_MSG(!f, ERR_CANT_OPEN, "Cannot open file '" + p_path + "'.");
 
-	FileAccess *fw = NULL; //=FileAccess::open(p_path+".depren");
+	FileAccess *fw = nullptr; //=FileAccess::open(p_path+".depren");
 
 	String local_path = p_path.get_base_dir();
 
@@ -1845,7 +1845,7 @@ void ResourceFormatSaverBinary::get_recognized_extensions(const RES &p_resource,
 		p_extensions->push_back("res");
 }
 
-ResourceFormatSaverBinary *ResourceFormatSaverBinary::singleton = NULL;
+ResourceFormatSaverBinary *ResourceFormatSaverBinary::singleton = nullptr;
 
 ResourceFormatSaverBinary::ResourceFormatSaverBinary() {
 	singleton = this;

core/io/resource_format_binary.h

@@ -100,7 +100,7 @@ public:
 
 class ResourceFormatLoaderBinary : public ResourceFormatLoader {
 public:
-	virtual Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;

core/io/resource_importer.cpp

@@ -67,7 +67,7 @@ Error ResourceFormatImporter::_get_path_and_type(const String &p_path, PathAndTy
 		next_tag.fields.clear();
 		next_tag.name = String();
 
-		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, NULL, true);
+		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, nullptr, true);
 		if (err == ERR_FILE_EOF) {
 			memdelete(f);
 			return OK;
@@ -256,7 +256,7 @@ void ResourceFormatImporter::get_internal_resource_path_list(const String &p_pat
 		next_tag.fields.clear();
 		next_tag.name = String();
 
-		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, NULL, true);
+		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, nullptr, true);
 		if (err == ERR_FILE_EOF) {
 			memdelete(f);
 			return;
@@ -408,7 +408,7 @@ String ResourceFormatImporter::get_import_settings_hash() const {
 	return hash.md5_text();
 }
 
-ResourceFormatImporter *ResourceFormatImporter::singleton = NULL;
+ResourceFormatImporter *ResourceFormatImporter::singleton = nullptr;
 
 ResourceFormatImporter::ResourceFormatImporter() {
 	singleton = this;

core/io/resource_importer.h

@@ -44,7 +44,7 @@ class ResourceFormatImporter : public ResourceFormatLoader {
 		Variant metadata;
 	};
 
-	Error _get_path_and_type(const String &p_path, PathAndType &r_path_and_type, bool *r_valid = NULL) const;
+	Error _get_path_and_type(const String &p_path, PathAndType &r_path_and_type, bool *r_valid = nullptr) const;
 
 	static ResourceFormatImporter *singleton;
 
@@ -57,7 +57,7 @@ class ResourceFormatImporter : public ResourceFormatLoader {
 
 public:
 	static ResourceFormatImporter *get_singleton() { return singleton; }
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
 	virtual bool recognize_path(const String &p_path, const String &p_for_type = String()) const;
@@ -122,7 +122,7 @@ public:
 	virtual bool get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const = 0;
 	virtual String get_option_group_file() const { return String(); }
 
-	virtual Error import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files = NULL, Variant *r_metadata = NULL) = 0;
+	virtual Error import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files = nullptr, Variant *r_metadata = nullptr) = 0;
 
 	virtual Error import_group_file(const String &p_group_file, const Map<String, Map<StringName, Variant>> &p_source_file_options, const Map<String, String> &p_base_paths) { return ERR_UNAVAILABLE; }
 	virtual bool are_import_settings_valid(const String &p_path) const { return true; }

core/io/resource_loader.cpp

@@ -745,7 +745,7 @@ String ResourceLoader::_path_remap(const String &p_path, bool *r_translation_rem
 				next_tag.fields.clear();
 				next_tag.name = String();
 
-				err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, NULL, true);
+				err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, nullptr, true);
 				if (err == ERR_FILE_EOF) {
 					break;
 				} else if (err != OK) {
@@ -848,7 +848,7 @@ void ResourceLoader::set_load_callback(ResourceLoadedCallback p_callback) {
 	_loaded_callback = p_callback;
 }
 
-ResourceLoadedCallback ResourceLoader::_loaded_callback = NULL;
+ResourceLoadedCallback ResourceLoader::_loaded_callback = nullptr;
 
 Ref<ResourceFormatLoader> ResourceLoader::_find_custom_resource_format_loader(String path) {
 	for (int i = 0; i < loader_count; ++i) {
@@ -874,7 +874,7 @@ bool ResourceLoader::add_custom_resource_format_loader(String script_path) {
 
 	Object *obj = ClassDB::instance(ibt);
 
-	ERR_FAIL_COND_V_MSG(obj == NULL, false, "Cannot instance script as custom resource loader, expected 'ResourceFormatLoader' inheritance, got: " + String(ibt) + ".");
+	ERR_FAIL_COND_V_MSG(obj == nullptr, false, "Cannot instance script as custom resource loader, expected 'ResourceFormatLoader' inheritance, got: " + String(ibt) + ".");
 
 	Ref<ResourceFormatLoader> crl = Object::cast_to<ResourceFormatLoader>(obj);
 	crl->set_script(s.get_ref_ptr());
@@ -926,7 +926,7 @@ HashMap<ResourceLoader::LoadingMapKey, int, ResourceLoader::LoadingMapKeyHasher>
 
 void ResourceLoader::finalize() {
 #ifndef NO_THREADS
-	const LoadingMapKey *K = NULL;
+	const LoadingMapKey *K = nullptr;
 	while ((K = loading_map.next(K))) {
 		ERR_PRINTS("Exited while resource is being loaded: " + K->path);
 	}
@@ -934,11 +934,11 @@ void ResourceLoader::finalize() {
 #endif
 }
 
-ResourceLoadErrorNotify ResourceLoader::err_notify = NULL;
-void *ResourceLoader::err_notify_ud = NULL;
+ResourceLoadErrorNotify ResourceLoader::err_notify = nullptr;
+void *ResourceLoader::err_notify_ud = nullptr;
 
-DependencyErrorNotify ResourceLoader::dep_err_notify = NULL;
-void *ResourceLoader::dep_err_notify_ud = NULL;
+DependencyErrorNotify ResourceLoader::dep_err_notify = nullptr;
+void *ResourceLoader::dep_err_notify_ud = nullptr;
 
 bool ResourceLoader::abort_on_missing_resource = true;
 bool ResourceLoader::timestamp_on_load = false;
@@ -947,4 +947,4 @@ SelfList<Resource>::List ResourceLoader::remapped_list;
 HashMap<String, Vector<String>> ResourceLoader::translation_remaps;
 HashMap<String, String> ResourceLoader::path_remaps;
 
-ResourceLoaderImport ResourceLoader::import = NULL;
+ResourceLoaderImport ResourceLoader::import = nullptr;

core/io/resource_loader.h

@@ -63,8 +63,8 @@ protected:
 	static void _bind_methods();
 
 public:
-	virtual Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual bool exists(const String &p_path) const;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
@@ -104,7 +104,7 @@ class ResourceLoader {
 	static HashMap<String, Vector<String>> translation_remaps;
 	static HashMap<String, String> path_remaps;
 
-	static String _path_remap(const String &p_path, bool *r_translation_remapped = NULL);
+	static String _path_remap(const String &p_path, bool *r_translation_remapped = nullptr);
 	friend class Resource;
 
 	static SelfList<Resource>::List remapped_list;
@@ -138,8 +138,8 @@ class ResourceLoader {
 	static void _remove_from_loading_map_and_thread(const String &p_path, Thread::ID p_thread);
 
 public:
-	static Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_type_hint = "", bool p_no_cache = false, Error *r_error = NULL);
-	static RES load(const String &p_path, const String &p_type_hint = "", bool p_no_cache = false, Error *r_error = NULL);
+	static Ref<ResourceInteractiveLoader> load_interactive(const String &p_path, const String &p_type_hint = "", bool p_no_cache = false, Error *r_error = nullptr);
+	static RES load(const String &p_path, const String &p_type_hint = "", bool p_no_cache = false, Error *r_error = nullptr);
 	static bool exists(const String &p_path, const String &p_type_hint = "");
 
 	static void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions);

core/io/resource_saver.cpp

@@ -38,7 +38,7 @@ Ref<ResourceFormatSaver> ResourceSaver::saver[MAX_SAVERS];
 
 int ResourceSaver::saver_count = 0;
 bool ResourceSaver::timestamp_on_save = false;
-ResourceSavedCallback ResourceSaver::save_callback = 0;
+ResourceSavedCallback ResourceSaver::save_callback = nullptr;
 
 Error ResourceFormatSaver::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
 	if (get_script_instance() && get_script_instance()->has_method("save")) {
@@ -204,7 +204,7 @@ bool ResourceSaver::add_custom_resource_format_saver(String script_path) {
 
 	Object *obj = ClassDB::instance(ibt);
 
-	ERR_FAIL_COND_V_MSG(obj == NULL, false, "Cannot instance script as custom resource saver, expected 'ResourceFormatSaver' inheritance, got: " + String(ibt) + ".");
+	ERR_FAIL_COND_V_MSG(obj == nullptr, false, "Cannot instance script as custom resource saver, expected 'ResourceFormatSaver' inheritance, got: " + String(ibt) + ".");
 
 	Ref<ResourceFormatSaver> crl = Object::cast_to<ResourceFormatSaver>(obj);
 	crl->set_script(s.get_ref_ptr());

core/io/stream_peer.cpp

@@ -204,7 +204,7 @@ void StreamPeer::put_utf8_string(const String &p_string) {
 void StreamPeer::put_var(const Variant &p_variant, bool p_full_objects) {
 	int len = 0;
 	Vector<uint8_t> buf;
-	encode_variant(p_variant, NULL, len, p_full_objects);
+	encode_variant(p_variant, nullptr, len, p_full_objects);
 	buf.resize(len);
 	put_32(len);
 	encode_variant(p_variant, buf.ptrw(), len, p_full_objects);
@@ -335,7 +335,7 @@ Variant StreamPeer::get_var(bool p_allow_objects) {
 	ERR_FAIL_COND_V(err != OK, Variant());
 
 	Variant ret;
-	err = decode_variant(ret, var.ptr(), len, NULL, p_allow_objects);
+	err = decode_variant(ret, var.ptr(), len, nullptr, p_allow_objects);
 	ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to decode Variant.");
 
 	return ret;

core/io/stream_peer_ssl.cpp

@@ -32,12 +32,12 @@
 
 #include "core/engine.h"
 
-StreamPeerSSL *(*StreamPeerSSL::_create)() = NULL;
+StreamPeerSSL *(*StreamPeerSSL::_create)() = nullptr;
 
 StreamPeerSSL *StreamPeerSSL::create() {
 	if (_create)
 		return _create();
-	return NULL;
+	return nullptr;
 }
 
 bool StreamPeerSSL::available = false;

core/io/translation_loader_po.h

@@ -38,7 +38,7 @@
 class TranslationLoaderPO : public ResourceFormatLoader {
 public:
 	static RES load_translation(FileAccess *f, Error *r_error);
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;

core/io/xml_parser.cpp

@@ -163,7 +163,7 @@ bool XMLParser::_parse_cdata() {
 		return true;
 
 	char *cDataBegin = P;
-	char *cDataEnd = 0;
+	char *cDataEnd = nullptr;
 
 	// find end of CDATA
 	while (*P && !cDataEnd) {
@@ -507,9 +507,9 @@ void XMLParser::skip_section() {
 void XMLParser::close() {
 	if (data)
 		memdelete_arr(data);
-	data = NULL;
+	data = nullptr;
 	length = 0;
-	P = NULL;
+	P = nullptr;
 	node_empty = false;
 	node_type = NODE_NONE;
 	node_offset = 0;
@@ -520,7 +520,7 @@ int XMLParser::get_current_line() const {
 }
 
 XMLParser::XMLParser() {
-	data = NULL;
+	data = nullptr;
 	close();
 	special_characters.push_back("&");
 	special_characters.push_back("<lt;");

core/io/zip_io.cpp

@@ -43,7 +43,7 @@ void *zipio_open(void *data, const char *p_fname, int mode) {
 	}
 
 	if (!f)
-		return NULL;
+		return nullptr;
 
 	return data;
 }
@@ -88,7 +88,7 @@ int zipio_close(voidpf opaque, voidpf stream) {
 	if (f) {
 		f->close();
 		memdelete(f);
-		f = NULL;
+		f = nullptr;
 	}
 	return 0;
 }

core/list.h

@@ -133,9 +133,9 @@ public:
 		}
 
 		_FORCE_INLINE_ Element() {
-			next_ptr = 0;
-			prev_ptr = 0;
-			data = NULL;
+			next_ptr = nullptr;
+			prev_ptr = nullptr;
+			data = nullptr;
 		};
 	};
 
@@ -176,28 +176,28 @@ public:
 	* return a const iterator to the beginning of the list.
 	*/
 	_FORCE_INLINE_ const Element *front() const {
-		return _data ? _data->first : 0;
+		return _data ? _data->first : nullptr;
 	};
 
 	/**
 	* return an iterator to the beginning of the list.
 	*/
 	_FORCE_INLINE_ Element *front() {
-		return _data ? _data->first : 0;
+		return _data ? _data->first : nullptr;
 	};
 
 	/**
  	* return a const iterator to the last member of the list.
 	*/
 	_FORCE_INLINE_ const Element *back() const {
-		return _data ? _data->last : 0;
+		return _data ? _data->last : nullptr;
 	};
 
 	/**
  	* return an iterator to the last member of the list.
 	*/
 	_FORCE_INLINE_ Element *back() {
-		return _data ? _data->last : 0;
+		return _data ? _data->last : nullptr;
 	};
 
 	/**
@@ -206,8 +206,8 @@ public:
 	Element *push_back(const T &value) {
 		if (!_data) {
 			_data = memnew_allocator(_Data, A);
-			_data->first = NULL;
-			_data->last = NULL;
+			_data->first = nullptr;
+			_data->last = nullptr;
 			_data->size_cache = 0;
 		}
 
@@ -215,7 +215,7 @@ public:
 		n->value = (T &)value;
 
 		n->prev_ptr = _data->last;
-		n->next_ptr = 0;
+		n->next_ptr = nullptr;
 		n->data = _data;
 
 		if (_data->last) {
@@ -243,14 +243,14 @@ public:
 	Element *push_front(const T &value) {
 		if (!_data) {
 			_data = memnew_allocator(_Data, A);
-			_data->first = NULL;
-			_data->last = NULL;
+			_data->first = nullptr;
+			_data->last = nullptr;
 			_data->size_cache = 0;
 		}
 
 		Element *n = memnew_allocator(Element, A);
 		n->value = (T &)value;
-		n->prev_ptr = 0;
+		n->prev_ptr = nullptr;
 		n->next_ptr = _data->first;
 		n->data = _data;
 
@@ -337,7 +337,7 @@ public:
 			it = it->next();
 		};
 
-		return NULL;
+		return nullptr;
 	};
 
 	/**
@@ -349,7 +349,7 @@ public:
 
 			if (_data->size_cache == 0) {
 				memdelete_allocator<_Data, A>(_data);
-				_data = NULL;
+				_data = nullptr;
 			}
 
 			return ret;
@@ -487,7 +487,7 @@ public:
 
 		_data->last->next_ptr = p_I;
 		p_I->prev_ptr = _data->last;
-		p_I->next_ptr = NULL;
+		p_I->next_ptr = nullptr;
 		_data->last = p_I;
 	}
 
@@ -521,7 +521,7 @@ public:
 
 		_data->first->prev_ptr = p_I;
 		p_I->next_ptr = _data->first;
-		p_I->prev_ptr = NULL;
+		p_I->prev_ptr = nullptr;
 		_data->first = p_I;
 	}
 
@@ -636,12 +636,12 @@ public:
 		sort.sort(aux_buffer, s);
 
 		_data->first = aux_buffer[0];
-		aux_buffer[0]->prev_ptr = NULL;
+		aux_buffer[0]->prev_ptr = nullptr;
 		aux_buffer[0]->next_ptr = aux_buffer[1];
 
 		_data->last = aux_buffer[s - 1];
 		aux_buffer[s - 1]->prev_ptr = aux_buffer[s - 2];
-		aux_buffer[s - 1]->next_ptr = NULL;
+		aux_buffer[s - 1]->next_ptr = nullptr;
 
 		for (int i = 1; i < s - 1; i++) {
 			aux_buffer[i]->prev_ptr = aux_buffer[i - 1];
@@ -659,7 +659,7 @@ public:
 	 * copy constructor for the list
 	 */
 	List(const List &p_list) {
-		_data = NULL;
+		_data = nullptr;
 		const Element *it = p_list.front();
 		while (it) {
 			push_back(it->get());
@@ -668,7 +668,7 @@ public:
 	}
 
 	List() {
-		_data = NULL;
+		_data = nullptr;
 	};
 	~List() {
 		clear();

core/map.h

@@ -89,11 +89,11 @@ public:
 		};
 		Element() {
 			color = RED;
-			right = NULL;
-			left = NULL;
-			parent = NULL;
-			_next = NULL;
-			_prev = NULL;
+			right = nullptr;
+			left = nullptr;
+			parent = nullptr;
+			_next = nullptr;
+			_prev = nullptr;
 		};
 	};
 
@@ -111,7 +111,7 @@ private:
 #else
 			_nil = (Element *)&_GlobalNilClass::_nil;
 #endif
-			_root = NULL;
+			_root = nullptr;
 			size_cache = 0;
 		}
 
@@ -124,7 +124,7 @@ private:
 		void _free_root() {
 			if (_root) {
 				memdelete_allocator<Element, A>(_root);
-				_root = NULL;
+				_root = nullptr;
 			}
 		}
 
@@ -189,7 +189,7 @@ private:
 			}
 
 			if (node->parent == _data._root)
-				return NULL; // No successor, as p_node = last node
+				return nullptr; // No successor, as p_node = last node
 			return node->parent;
 		}
 	}
@@ -209,7 +209,7 @@ private:
 			}
 
 			if (node == _data._root)
-				return NULL; // No predecessor, as p_node = first node
+				return nullptr; // No predecessor, as p_node = first node
 			return node->parent;
 		}
 	}
@@ -227,12 +227,12 @@ private:
 				return node; // found
 		}
 
-		return NULL;
+		return nullptr;
 	}
 
 	Element *_find_closest(const K &p_key) const {
 		Element *node = _data._root->left;
-		Element *prev = NULL;
+		Element *prev = nullptr;
 		C less;
 
 		while (node != _data._nil) {
@@ -246,8 +246,8 @@ private:
 				return node; // found
 		}
 
-		if (prev == NULL)
-			return NULL; // tree empty
+		if (prev == nullptr)
+			return nullptr; // tree empty
 
 		if (less(p_key, prev->_key))
 			prev = prev->_prev;
@@ -488,7 +488,7 @@ private:
 public:
 	const Element *find(const K &p_key) const {
 		if (!_data._root)
-			return NULL;
+			return nullptr;
 
 		const Element *res = _find(p_key);
 		return res;
@@ -496,7 +496,7 @@ public:
 
 	Element *find(const K &p_key) {
 		if (!_data._root)
-			return NULL;
+			return nullptr;
 
 		Element *res = _find(p_key);
 		return res;
@@ -512,14 +512,14 @@ public:
 
 	Element *find_closest(const K &p_key) {
 		if (!_data._root)
-			return NULL;
+			return nullptr;
 
 		Element *res = _find_closest(p_key);
 		return res;
 	}
 
 	bool has(const K &p_key) const {
-		return find(p_key) != NULL;
+		return find(p_key) != nullptr;
 	}
 
 	Element *insert(const K &p_key, const V &p_value) {
@@ -571,11 +571,11 @@ public:
 
 	Element *front() const {
 		if (!_data._root)
-			return NULL;
+			return nullptr;
 
 		Element *e = _data._root->left;
 		if (e == _data._nil)
-			return NULL;
+			return nullptr;
 
 		while (e->left != _data._nil)
 			e = e->left;
@@ -585,11 +585,11 @@ public:
 
 	Element *back() const {
 		if (!_data._root)
-			return NULL;
+			return nullptr;
 
 		Element *e = _data._root->left;
 		if (e == _data._nil)
-			return NULL;
+			return nullptr;
 
 		while (e->right != _data._nil)
 			e = e->right;

core/math/a_star.cpp

@@ -64,7 +64,7 @@ void AStar::add_point(int p_id, const Vector3 &p_pos, real_t p_weight_scale) {
 		pt->id = p_id;
 		pt->pos = p_pos;
 		pt->weight_scale = p_weight_scale;
-		pt->prev_point = NULL;
+		pt->prev_point = nullptr;
 		pt->open_pass = 0;
 		pt->closed_pass = 0;
 		pt->enabled = true;
@@ -158,7 +158,7 @@ void AStar::connect_points(int p_id, int p_with_id, bool bidirectional) {
 		s.direction = Segment::BIDIRECTIONAL;
 
 	Set<Segment>::Element *element = segments.find(s);
-	if (element != NULL) {
+	if (element != nullptr) {
 		s.direction |= element->get().direction;
 		if (s.direction == Segment::BIDIRECTIONAL) {
 			// Both are neighbours of each other now
@@ -184,7 +184,7 @@ void AStar::disconnect_points(int p_id, int p_with_id, bool bidirectional) {
 	int remove_direction = bidirectional ? (int)Segment::BIDIRECTIONAL : s.direction;
 
 	Set<Segment>::Element *element = segments.find(s);
-	if (element != NULL) {
+	if (element != nullptr) {
 		// s is the new segment
 		// Erase the directions to be removed
 		s.direction = (element->get().direction & ~remove_direction);
@@ -241,7 +241,7 @@ bool AStar::are_points_connected(int p_id, int p_with_id, bool bidirectional) co
 	Segment s(p_id, p_with_id);
 	const Set<Segment>::Element *element = segments.find(s);
 
-	return element != NULL &&
+	return element != nullptr &&
 		   (bidirectional || (element->get().direction & s.direction) == s.direction);
 }
 

core/math/aabb.h

@@ -70,8 +70,8 @@ public:
 	AABB merge(const AABB &p_with) const;
 	void merge_with(const AABB &p_aabb); ///merge with another AABB
 	AABB intersection(const AABB &p_aabb) const; ///get box where two intersect, empty if no intersection occurs
-	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
-	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip = NULL, Vector3 *r_normal = NULL) const;
+	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip = nullptr, Vector3 *r_normal = nullptr) const;
+	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip = nullptr, Vector3 *r_normal = nullptr) const;
 	_FORCE_INLINE_ bool smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_dir, real_t t0, real_t t1) const;
 
 	_FORCE_INLINE_ bool intersects_convex_shape(const Plane *p_planes, int p_plane_count, const Vector3 *p_points, int p_point_count) const;

core/math/expression.cpp

@@ -685,7 +685,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			PoolByteArray barr;
 			bool full_objects = *p_inputs[1];
 			int len;
-			Error err = encode_variant(*p_inputs[0], NULL, len, full_objects);
+			Error err = encode_variant(*p_inputs[0], nullptr, len, full_objects);
 			if (err) {
 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
 				r_error.argument = 0;
@@ -715,7 +715,7 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			Variant ret;
 			{
 				PoolByteArray::Read r = varr.read();
-				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL, allow_objects);
+				Error err = decode_variant(ret, r.ptr(), varr.size(), nullptr, allow_objects);
 				if (err != OK) {
 					r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
 					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
@@ -1206,12 +1206,12 @@ Expression::ENode *Expression::_parse_expression() {
 
 	while (true) {
 		//keep appending stuff to expression
-		ENode *expr = NULL;
+		ENode *expr = nullptr;
 
 		Token tk;
 		_get_token(tk);
 		if (error_set)
-			return NULL;
+			return nullptr;
 
 		switch (tk.type) {
 			case TK_CURLY_BRACKET_OPEN: {
@@ -1228,18 +1228,18 @@ Expression::ENode *Expression::_parse_expression() {
 					//parse an expression
 					ENode *subexpr = _parse_expression();
 					if (!subexpr)
-						return NULL;
+						return nullptr;
 					dn->dict.push_back(subexpr);
 
 					_get_token(tk);
 					if (tk.type != TK_COLON) {
 						_set_error("Expected ':'");
-						return NULL;
+						return nullptr;
 					}
 
 					subexpr = _parse_expression();
 					if (!subexpr)
-						return NULL;
+						return nullptr;
 
 					dn->dict.push_back(subexpr);
 
@@ -1271,7 +1271,7 @@ Expression::ENode *Expression::_parse_expression() {
 					//parse an expression
 					ENode *subexpr = _parse_expression();
 					if (!subexpr)
-						return NULL;
+						return nullptr;
 					an->array.push_back(subexpr);
 
 					cofs = str_ofs;
@@ -1291,11 +1291,11 @@ Expression::ENode *Expression::_parse_expression() {
 				//a suexpression
 				ENode *e = _parse_expression();
 				if (error_set)
-					return NULL;
+					return nullptr;
 				_get_token(tk);
 				if (tk.type != TK_PARENTHESIS_CLOSE) {
 					_set_error("Expected ')'");
-					return NULL;
+					return nullptr;
 				}
 
 				expr = e;
@@ -1323,7 +1323,7 @@ Expression::ENode *Expression::_parse_expression() {
 						//parse an expression
 						ENode *subexpr = _parse_expression();
 						if (!subexpr)
-							return NULL;
+							return nullptr;
 
 						func_call->arguments.push_back(subexpr);
 
@@ -1385,7 +1385,7 @@ Expression::ENode *Expression::_parse_expression() {
 				_get_token(tk);
 				if (tk.type != TK_PARENTHESIS_OPEN) {
 					_set_error("Expected '('");
-					return NULL;
+					return nullptr;
 				}
 
 				ConstructorNode *constructor = alloc_node<ConstructorNode>();
@@ -1401,7 +1401,7 @@ Expression::ENode *Expression::_parse_expression() {
 					//parse an expression
 					ENode *subexpr = _parse_expression();
 					if (!subexpr)
-						return NULL;
+						return nullptr;
 
 					constructor->arguments.push_back(subexpr);
 
@@ -1425,7 +1425,7 @@ Expression::ENode *Expression::_parse_expression() {
 				_get_token(tk);
 				if (tk.type != TK_PARENTHESIS_OPEN) {
 					_set_error("Expected '('");
-					return NULL;
+					return nullptr;
 				}
 
 				BuiltinFuncNode *bifunc = alloc_node<BuiltinFuncNode>();
@@ -1441,7 +1441,7 @@ Expression::ENode *Expression::_parse_expression() {
 					//parse an expression
 					ENode *subexpr = _parse_expression();
 					if (!subexpr)
-						return NULL;
+						return nullptr;
 
 					bifunc->arguments.push_back(subexpr);
 
@@ -1481,7 +1481,7 @@ Expression::ENode *Expression::_parse_expression() {
 
 			default: {
 				_set_error("Expected expression.");
-				return NULL;
+				return nullptr;
 			} break;
 		}
 
@@ -1491,7 +1491,7 @@ Expression::ENode *Expression::_parse_expression() {
 			int cofs2 = str_ofs;
 			_get_token(tk);
 			if (error_set)
-				return NULL;
+				return nullptr;
 
 			bool done = false;
 
@@ -1504,14 +1504,14 @@ Expression::ENode *Expression::_parse_expression() {
 
 					ENode *what = _parse_expression();
 					if (!what)
-						return NULL;
+						return nullptr;
 
 					index->index = what;
 
 					_get_token(tk);
 					if (tk.type != TK_BRACKET_CLOSE) {
 						_set_error("Expected ']' at end of index.");
-						return NULL;
+						return nullptr;
 					}
 					expr = index;
 
@@ -1521,7 +1521,7 @@ Expression::ENode *Expression::_parse_expression() {
 					_get_token(tk);
 					if (tk.type != TK_IDENTIFIER) {
 						_set_error("Expected identifier after '.'");
-						return NULL;
+						return nullptr;
 					}
 
 					StringName identifier = tk.value;
@@ -1544,7 +1544,7 @@ Expression::ENode *Expression::_parse_expression() {
 							//parse an expression
 							ENode *subexpr = _parse_expression();
 							if (!subexpr)
-								return NULL;
+								return nullptr;
 
 							func_call->arguments.push_back(subexpr);
 
@@ -1594,7 +1594,7 @@ Expression::ENode *Expression::_parse_expression() {
 		int cofs = str_ofs;
 		_get_token(tk);
 		if (error_set)
-			return NULL;
+			return nullptr;
 
 		Variant::Operator op = Variant::OP_MAX;
 
@@ -1777,7 +1777,7 @@ Expression::ENode *Expression::_parse_expression() {
 
 				default: {
 					_set_error("Parser bug, invalid operator in expression: " + itos(expression[i].op));
-					return NULL;
+					return nullptr;
 				}
 			}
 
@@ -1793,7 +1793,7 @@ Expression::ENode *Expression::_parse_expression() {
 
 		if (next_op == -1) {
 			_set_error("Yet another parser bug....");
-			ERR_FAIL_V(NULL);
+			ERR_FAIL_V(nullptr);
 		}
 
 		// OK! create operator..
@@ -1804,7 +1804,7 @@ Expression::ENode *Expression::_parse_expression() {
 				if (expr_pos == expression.size()) {
 					//can happen..
 					_set_error("Unexpected end of expression...");
-					return NULL;
+					return nullptr;
 				}
 			}
 
@@ -1813,7 +1813,7 @@ Expression::ENode *Expression::_parse_expression() {
 				OperatorNode *op = alloc_node<OperatorNode>();
 				op->op = expression[i].op;
 				op->nodes[0] = expression[i + 1].node;
-				op->nodes[1] = NULL;
+				op->nodes[1] = nullptr;
 				expression.write[i].is_op = false;
 				expression.write[i].node = op;
 				expression.remove(i + 1);
@@ -1822,7 +1822,7 @@ Expression::ENode *Expression::_parse_expression() {
 		} else {
 			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				_set_error("Parser bug...");
-				ERR_FAIL_V(NULL);
+				ERR_FAIL_V(nullptr);
 			}
 
 			OperatorNode *op = alloc_node<OperatorNode>();
@@ -1830,7 +1830,7 @@ Expression::ENode *Expression::_parse_expression() {
 
 			if (expression[next_op - 1].is_op) {
 				_set_error("Parser bug...");
-				ERR_FAIL_V(NULL);
+				ERR_FAIL_V(nullptr);
 			}
 
 			if (expression[next_op + 1].is_op) {
@@ -1840,7 +1840,7 @@ Expression::ENode *Expression::_parse_expression() {
 				// due to how precedence works, unaries will always disappear first
 
 				_set_error("Unexpected two consecutive operators.");
-				return NULL;
+				return nullptr;
 			}
 
 			op->nodes[0] = expression[next_op - 1].node; //expression goes as left
@@ -1862,8 +1862,8 @@ bool Expression::_compile_expression() {
 
 	if (nodes) {
 		memdelete(nodes);
-		nodes = NULL;
-		root = NULL;
+		nodes = nullptr;
+		root = nullptr;
 	}
 
 	error_str = String();
@@ -1873,11 +1873,11 @@ bool Expression::_compile_expression() {
 	root = _parse_expression();
 
 	if (error_set) {
-		root = NULL;
+		root = nullptr;
 		if (nodes) {
 			memdelete(nodes);
 		}
-		nodes = NULL;
+		nodes = nullptr;
 		return true;
 	}
 
@@ -2100,8 +2100,8 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
 Error Expression::parse(const String &p_expression, const Vector<String> &p_input_names) {
 	if (nodes) {
 		memdelete(nodes);
-		nodes = NULL;
-		root = NULL;
+		nodes = nullptr;
+		root = nullptr;
 	}
 
 	error_str = String();
@@ -2113,11 +2113,11 @@ Error Expression::parse(const String &p_expression, const Vector<String> &p_inpu
 	root = _parse_expression();
 
 	if (error_set) {
-		root = NULL;
+		root = nullptr;
 		if (nodes) {
 			memdelete(nodes);
 		}
-		nodes = NULL;
+		nodes = nullptr;
 		return ERR_INVALID_PARAMETER;
 	}
 
@@ -2159,8 +2159,8 @@ Expression::Expression() :
 		output_type(Variant::NIL),
 		sequenced(false),
 		error_set(true),
-		root(NULL),
-		nodes(NULL),
+		root(nullptr),
+		nodes(nullptr),
 		execution_error(false) {
 }
 

core/math/expression.h

@@ -217,7 +217,7 @@ private:
 
 		Type type;
 
-		ENode() { next = NULL; }
+		ENode() { next = nullptr; }
 		virtual ~ENode() {
 			if (next) {
 				memdelete(next);
@@ -345,7 +345,7 @@ protected:
 
 public:
 	Error parse(const String &p_expression, const Vector<String> &p_input_names = Vector<String>());
-	Variant execute(Array p_inputs, Object *p_base = NULL, bool p_show_error = true);
+	Variant execute(Array p_inputs, Object *p_base = nullptr, bool p_show_error = true);
 	bool has_execute_failed() const;
 	String get_error_text() const;
 

core/math/face3.h

@@ -69,8 +69,8 @@ public:
 	Vector3 get_median_point() const;
 	Vector3 get_closest_point_to(const Vector3 &p_point) const;
 
-	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *p_intersection = 0) const;
-	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *p_intersection = 0) const;
+	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *p_intersection = nullptr) const;
+	bool intersects_segment(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *p_intersection = nullptr) const;
 
 	ClockDirection get_clock_dir() const; ///< todo, test if this is returning the proper clockwisity
 

core/math/geometry.h

@@ -189,7 +189,7 @@ public:
 		return dP.length(); // Return the closest distance.
 	}
 
-	static inline bool ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2, Vector3 *r_res = 0) {
+	static inline bool ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2, Vector3 *r_res = nullptr) {
 		Vector3 e1 = p_v1 - p_v0;
 		Vector3 e2 = p_v2 - p_v0;
 		Vector3 h = p_dir.cross(e2);
@@ -224,7 +224,7 @@ public:
 			return false;
 	}
 
-	static inline bool segment_intersects_triangle(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2, Vector3 *r_res = 0) {
+	static inline bool segment_intersects_triangle(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2, Vector3 *r_res = nullptr) {
 		Vector3 rel = p_to - p_from;
 		Vector3 e1 = p_v1 - p_v0;
 		Vector3 e2 = p_v2 - p_v0;
@@ -260,7 +260,7 @@ public:
 			return false;
 	}
 
-	static inline bool segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius, Vector3 *r_res = 0, Vector3 *r_norm = 0) {
+	static inline bool segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius, Vector3 *r_res = nullptr, Vector3 *r_norm = nullptr) {
 		Vector3 sphere_pos = p_sphere_pos - p_from;
 		Vector3 rel = (p_to - p_from);
 		real_t rel_l = rel.length();
@@ -295,7 +295,7 @@ public:
 		return true;
 	}
 
-	static inline bool segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, real_t p_height, real_t p_radius, Vector3 *r_res = 0, Vector3 *r_norm = 0, int p_cylinder_axis = 2) {
+	static inline bool segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, real_t p_height, real_t p_radius, Vector3 *r_res = nullptr, Vector3 *r_norm = nullptr, int p_cylinder_axis = 2) {
 		Vector3 rel = (p_to - p_from);
 		real_t rel_l = rel.length();
 		if (rel_l < CMP_EPSILON)
@@ -892,7 +892,7 @@ public:
 		for (int i = 0; i < c; i++) {
 			const Vector2 &v1 = p[i];
 			const Vector2 &v2 = p[(i + 1) % c];
-			if (segment_intersects_segment_2d(v1, v2, p_point, further_away, NULL)) {
+			if (segment_intersects_segment_2d(v1, v2, p_point, further_away, nullptr)) {
 				intersections++;
 			}
 		}
@@ -903,7 +903,7 @@ public:
 	static PoolVector<PoolVector<Face3>> separate_objects(PoolVector<Face3> p_array);
 
 	// Create a "wrap" that encloses the given geometry.
-	static PoolVector<Face3> wrap_geometry(PoolVector<Face3> p_array, real_t *p_error = NULL);
+	static PoolVector<Face3> wrap_geometry(PoolVector<Face3> p_array, real_t *p_error = nullptr);
 
 	struct MeshData {
 		struct Face {

core/math/octree_definition.inc

@@ -182,12 +182,12 @@ private:
 			children_count = 0;
 			parent_index = -1;
 			last_pass = 0;
-			parent = NULL;
+			parent = nullptr;
 #ifdef OCTREE_USE_CACHED_LISTS
 			dirty = true;
 #endif
 			for (int i = 0; i < 8; i++)
-				children[i] = NULL;
+				children[i] = nullptr;
 		}
 
 		~Octant() {
@@ -241,11 +241,11 @@ private:
 			_id = 0;
 			pairable = false;
 			subindex = 0;
-			userdata = 0;
-			octree = 0;
+			userdata = nullptr;
+			octree = nullptr;
 			pairable_mask = 0;
 			pairable_type = 0;
-			common_parent = NULL;
+			common_parent = nullptr;
 		}
 	};
 
@@ -370,17 +370,17 @@ private:
 
 	_FORCE_INLINE_ void _optimize() {
 		while (root && root->children_count < 2 && !root->elements.size() && !(use_pairs && root->pairable_elements.size())) {
-			Octant *new_root = NULL;
+			Octant *new_root = nullptr;
 			if (root->children_count == 1) {
 				for (int i = 0; i < 8; i++) {
 					if (root->children[i]) {
 						new_root = root->children[i];
-						root->children[i] = NULL;
+						root->children[i] = nullptr;
 						break;
 					}
 				}
 				ERR_FAIL_COND(!new_root);
-				new_root->parent = NULL;
+				new_root->parent = nullptr;
 				new_root->parent_index = -1;
 			}
 
@@ -392,7 +392,7 @@ private:
 
 	void _insert_element(Element *p_element, Octant *p_octant);
 	void _ensure_valid_root(const AABB &p_aabb);
-	bool _remove_element_pair_and_remove_empty_octants(Element *p_element, Octant *p_octant, Octant *p_limit = NULL);
+	bool _remove_element_pair_and_remove_empty_octants(Element *p_element, Octant *p_octant, Octant *p_limit = nullptr);
 	void _remove_element(Element *p_element);
 	void _pair_element(Element *p_element, Octant *p_octant);
 	void _unpair_element(Element *p_element, Octant *p_octant);
@@ -441,10 +441,10 @@ public:
 	int get_subindex(OctreeElementID p_id) const;
 
 	int cull_convex(const Vector<Plane> &p_convex, T **p_result_array, int p_result_max, uint32_t p_mask = 0xFFFFFFFF);
-	int cull_aabb(const AABB &p_aabb, T **p_result_array, int p_result_max, int *p_subindex_array = NULL, uint32_t p_mask = 0xFFFFFFFF);
-	int cull_segment(const Vector3 &p_from, const Vector3 &p_to, T **p_result_array, int p_result_max, int *p_subindex_array = NULL, uint32_t p_mask = 0xFFFFFFFF);
+	int cull_aabb(const AABB &p_aabb, T **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
+	int cull_segment(const Vector3 &p_from, const Vector3 &p_to, T **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
 
-	int cull_point(const Vector3 &p_point, T **p_result_array, int p_result_max, int *p_subindex_array = NULL, uint32_t p_mask = 0xFFFFFFFF);
+	int cull_point(const Vector3 &p_point, T **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
 
 	void set_pair_callback(PairCallback p_callback, void *p_userdata);
 	void set_unpair_callback(UnpairCallback p_callback, void *p_userdata);
@@ -476,7 +476,7 @@ public:
 
 OCTREE_FUNC(T *)::get(OctreeElementID p_id) const {
 	const typename ElementMap::Element *E = element_map.find(p_id);
-	ERR_FAIL_COND_V(!E, NULL);
+	ERR_FAIL_COND_V(!E, nullptr);
 	return E->get().userdata;
 }
 
@@ -527,7 +527,7 @@ OCTREE_FUNC(void)::_insert_element(Element *p_element, Octant *p_octant) {
 #endif
 		p_element->octant_owners.push_back(owner);
 
-		if (p_element->common_parent == NULL) {
+		if (p_element->common_parent == nullptr) {
 			p_element->common_parent = p_octant;
 			p_element->container_aabb = p_octant->aabb;
 		} else {
@@ -546,7 +546,7 @@ OCTREE_FUNC(void)::_insert_element(Element *p_element, Octant *p_octant) {
 	} else {
 		/* not big enough, send it to subitems */
 		int splits = 0;
-		bool candidate = p_element->common_parent == NULL;
+		bool candidate = p_element->common_parent == nullptr;
 
 		for (int i = 0; i < 8; i++) {
 			if (p_octant->children[i]) {
@@ -629,7 +629,7 @@ OCTREE_FUNC(void)::_ensure_valid_root(const AABB &p_aabb) {
 
 		root = memnew_allocator(Octant, AL);
 
-		root->parent = NULL;
+		root->parent = nullptr;
 		root->parent_index = -1;
 		root->aabb = base;
 
@@ -705,11 +705,11 @@ OCTREE_FUNC(bool)::_remove_element_pair_and_remove_empty_octants(Element *p_elem
 
 			if (p_octant == root) { // won't have a parent, just erase
 
-				root = NULL;
+				root = nullptr;
 			} else {
 				ERR_FAIL_INDEX_V(p_octant->parent_index, 8, octant_removed);
 
-				parent->children[p_octant->parent_index] = NULL;
+				parent->children[p_octant->parent_index] = nullptr;
 				parent->children_count--;
 			}
 
@@ -899,12 +899,12 @@ OCTREE_FUNC(void)::move(OctreeElementID p_id, const AABB &p_aabb) {
 	if (old_has_surf != new_has_surf) {
 		if (old_has_surf) {
 			_remove_element(&e); // removing
-			e.common_parent = NULL;
+			e.common_parent = nullptr;
 			e.aabb = AABB();
 			_optimize();
 		} else {
 			_ensure_valid_root(p_aabb); // inserting
-			e.common_parent = NULL;
+			e.common_parent = nullptr;
 			e.aabb = p_aabb;
 			_insert_element(&e, root);
 			if (use_pairs)
@@ -933,7 +933,7 @@ OCTREE_FUNC(void)::move(OctreeElementID p_id, const AABB &p_aabb) {
 	combined.merge_with(p_aabb);
 	_ensure_valid_root(combined);
 
-	ERR_FAIL_COND(e.octant_owners.front() == NULL);
+	ERR_FAIL_COND(e.octant_owners.front() == nullptr);
 
 	/* FIND COMMON PARENT */
 
@@ -951,7 +951,7 @@ OCTREE_FUNC(void)::move(OctreeElementID p_id, const AABB &p_aabb) {
 
 	//prepare for reinsert
 	e.octant_owners.clear();
-	e.common_parent = NULL;
+	e.common_parent = nullptr;
 	e.aabb = p_aabb;
 
 	_insert_element(&e, common_parent); // reinsert from this point
@@ -1018,7 +1018,7 @@ OCTREE_FUNC(void)::set_pairable(OctreeElementID p_id, bool p_pairable, uint32_t
 	e.pairable = p_pairable;
 	e.pairable_type = p_pairable_type;
 	e.pairable_mask = p_pairable_mask;
-	e.common_parent = NULL;
+	e.common_parent = nullptr;
 
 	if (!e.aabb.has_no_surface()) {
 		_ensure_valid_root(e.aabb);
@@ -1577,16 +1577,16 @@ OCTREE_FUNC_CONSTRUCTOR::OCTREE_CLASS_NAME(real_t p_unit_size) {
 	last_element_id = 1;
 	pass = 1;
 	unit_size = p_unit_size;
-	root = NULL;
+	root = nullptr;
 
 	octant_count = 0;
 	pair_count = 0;
 	octant_elements_limit = OCTREE_DEFAULT_OCTANT_LIMIT;
 
-	pair_callback = NULL;
-	unpair_callback = NULL;
-	pair_callback_userdata = NULL;
-	unpair_callback_userdata = NULL;
+	pair_callback = nullptr;
+	unpair_callback = nullptr;
+	pair_callback_userdata = nullptr;
+	unpair_callback_userdata = nullptr;
 }
 
 #ifdef TOOLS_ENABLED

core/math/plane.h

@@ -56,7 +56,7 @@ public:
 
 	/* intersections */
 
-	bool intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result = 0) const;
+	bool intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result = nullptr) const;
 	bool intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *p_intersection) const;
 	bool intersects_segment(const Vector3 &p_begin, const Vector3 &p_end, Vector3 *p_intersection) const;
 

core/math/quick_hull.cpp

@@ -370,7 +370,7 @@ Error QuickHull::build(const Vector<Vector3> &p_points, Geometry::MeshData &r_me
 			ERR_CONTINUE(!F);
 			List<Geometry::MeshData::Face>::Element *O = F->get().left == E ? F->get().right : F->get().left;
 			ERR_CONTINUE(O == E);
-			ERR_CONTINUE(O == NULL);
+			ERR_CONTINUE(O == nullptr);
 
 			if (O->get().plane.is_equal_approx(f.plane)) {
 				//merge and delete edge and contiguous face, while repointing edges (uuugh!)
@@ -410,10 +410,10 @@ Error QuickHull::build(const Vector<Vector3> &p_points, Geometry::MeshData &r_me
 				// remove all edge connections to this face
 				for (Map<Edge, RetFaceConnect>::Element *G = ret_edges.front(); G; G = G->next()) {
 					if (G->get().left == O)
-						G->get().left = NULL;
+						G->get().left = nullptr;
 
 					if (G->get().right == O)
-						G->get().right = NULL;
+						G->get().right = nullptr;
 				}
 
 				ret_edges.erase(F); //remove the edge

core/math/quick_hull.h

@@ -72,15 +72,15 @@ private:
 	struct FaceConnect {
 		List<Face>::Element *left, *right;
 		FaceConnect() {
-			left = NULL;
-			right = NULL;
+			left = nullptr;
+			right = nullptr;
 		}
 	};
 	struct RetFaceConnect {
 		List<Geometry::MeshData::Face>::Element *left, *right;
 		RetFaceConnect() {
-			left = NULL;
-			right = NULL;
+			left = nullptr;
+			right = nullptr;
 		}
 	};
 

core/math/rect2.h

@@ -103,7 +103,7 @@ struct Rect2 {
 
 	bool intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const;
 
-	bool intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_pos = NULL, Point2 *r_normal = NULL) const;
+	bool intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_pos = nullptr, Point2 *r_normal = nullptr) const;
 
 	inline bool encloses(const Rect2 &p_rect) const {
 		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&

core/message_queue.cpp

@@ -33,7 +33,7 @@
 #include "core/project_settings.h"
 #include "core/script_language.h"
 
-MessageQueue *MessageQueue::singleton = NULL;
+MessageQueue *MessageQueue::singleton = nullptr;
 
 MessageQueue *MessageQueue::get_singleton() {
 	return singleton;
@@ -163,7 +163,7 @@ void MessageQueue::statistics() {
 
 		Object *target = ObjectDB::get_instance(message->instance_id);
 
-		if (target != NULL) {
+		if (target != nullptr) {
 			switch (message->type & FLAG_MASK) {
 				case TYPE_CALL: {
 					if (!call_count.has(message->target))
@@ -221,7 +221,7 @@ int MessageQueue::get_max_buffer_usage() const {
 }
 
 void MessageQueue::_call_function(Object *p_target, const StringName &p_func, const Variant *p_args, int p_argcount, bool p_show_error) {
-	const Variant **argptrs = NULL;
+	const Variant **argptrs = nullptr;
 	if (p_argcount) {
 		argptrs = (const Variant **)alloca(sizeof(Variant *) * p_argcount);
 		for (int i = 0; i < p_argcount; i++) {
@@ -265,7 +265,7 @@ void MessageQueue::flush() {
 
 		Object *target = ObjectDB::get_instance(message->instance_id);
 
-		if (target != NULL) {
+		if (target != nullptr) {
 			switch (message->type & FLAG_MASK) {
 				case TYPE_CALL: {
 					Variant *args = (Variant *)(message + 1);
@@ -311,7 +311,7 @@ bool MessageQueue::is_flushing() const {
 }
 
 MessageQueue::MessageQueue() {
-	ERR_FAIL_COND_MSG(singleton != NULL, "A MessageQueue singleton already exists.");
+	ERR_FAIL_COND_MSG(singleton != nullptr, "A MessageQueue singleton already exists.");
 	singleton = this;
 	flushing = false;
 
@@ -341,6 +341,6 @@ MessageQueue::~MessageQueue() {
 			read_pos += sizeof(Variant) * message->args;
 	}
 
-	singleton = NULL;
+	singleton = nullptr;
 	memdelete_arr(buffer);
 }

core/method_bind.cpp

@@ -101,7 +101,7 @@ MethodBind::MethodBind() {
 	argument_count = 0;
 	default_argument_count = 0;
 #ifdef DEBUG_METHODS_ENABLED
-	argument_types = NULL;
+	argument_types = nullptr;
 #endif
 	_const = false;
 	_returns = false;

core/method_bind.h

@@ -367,7 +367,7 @@ public:
 	virtual bool is_vararg() const { return true; }
 
 	MethodBindVarArg() {
-		call_method = NULL;
+		call_method = nullptr;
 		_set_returns(true);
 	}
 };

core/node_path.cpp

@@ -90,7 +90,7 @@ void NodePath::unref() {
 	if (data && data->refcount.unref()) {
 		memdelete(data);
 	}
-	data = NULL;
+	data = nullptr;
 }
 
 bool NodePath::operator==(const NodePath &p_path) const {
@@ -170,7 +170,7 @@ NodePath::operator String() const {
 }
 
 NodePath::NodePath(const NodePath &p_path) {
-	data = NULL;
+	data = nullptr;
 
 	if (p_path.data && p_path.data->refcount.ref()) {
 		data = p_path.data;
@@ -260,7 +260,7 @@ NodePath NodePath::get_as_property_path() const {
 }
 
 NodePath::NodePath(const Vector<StringName> &p_path, bool p_absolute) {
-	data = NULL;
+	data = nullptr;
 
 	if (p_path.size() == 0)
 		return;
@@ -274,7 +274,7 @@ NodePath::NodePath(const Vector<StringName> &p_path, bool p_absolute) {
 }
 
 NodePath::NodePath(const Vector<StringName> &p_path, const Vector<StringName> &p_subpath, bool p_absolute) {
-	data = NULL;
+	data = nullptr;
 
 	if (p_path.size() == 0 && p_subpath.size() == 0)
 		return;
@@ -318,7 +318,7 @@ NodePath NodePath::simplified() const {
 }
 
 NodePath::NodePath(const String &p_path) {
-	data = NULL;
+	data = nullptr;
 
 	if (p_path.length() == 0)
 		return;
@@ -401,7 +401,7 @@ bool NodePath::is_empty() const {
 	return !data;
 }
 NodePath::NodePath() {
-	data = NULL;
+	data = nullptr;
 }
 
 NodePath::~NodePath() {

core/oa_hash_map.h

@@ -305,8 +305,8 @@ public:
 		Iterator it;
 		it.valid = false;
 		it.pos = p_iter.pos;
-		it.key = NULL;
-		it.value = NULL;
+		it.key = nullptr;
+		it.value = nullptr;
 
 		for (uint32_t i = it.pos; i < capacity; i++) {
 			it.pos = i + 1;

core/object.cpp

@@ -371,7 +371,7 @@ bool Object::_predelete() {
 	_predelete_ok = 1;
 	notification(NOTIFICATION_PREDELETE, true);
 	if (_predelete_ok) {
-		_class_ptr = NULL; //must restore so destructors can access class ptr correctly
+		_class_ptr = nullptr; //must restore so destructors can access class ptr correctly
 	}
 	return _predelete_ok;
 }
@@ -763,7 +763,7 @@ bool Object::has_method(const StringName &p_method) const {
 
 	MethodBind *method = ClassDB::get_method(get_class_name(), p_method);
 
-	return method != NULL;
+	return method != nullptr;
 }
 
 Variant Object::getvar(const Variant &p_key, bool *r_valid) const {
@@ -777,7 +777,7 @@ void Object::setvar(const Variant &p_key, const Variant &p_value, bool *r_valid)
 }
 
 Variant Object::callv(const StringName &p_method, const Array &p_args) {
-	const Variant **argptrs = NULL;
+	const Variant **argptrs = nullptr;
 
 	if (p_args.size() > 0) {
 		argptrs = (const Variant **)alloca(sizeof(Variant *) * p_args.size());
@@ -955,7 +955,7 @@ void Object::set_script_and_instance(const RefPtr &p_script, ScriptInstance *p_i
 	//this function is not meant to be used in any of these ways
 	ERR_FAIL_COND(p_script.is_null());
 	ERR_FAIL_COND(!p_instance);
-	ERR_FAIL_COND(script_instance != NULL || !script.is_null());
+	ERR_FAIL_COND(script_instance != nullptr || !script.is_null());
 
 	script = p_script;
 	script_instance = p_instance;
@@ -967,7 +967,7 @@ void Object::set_script(const RefPtr &p_script) {
 
 	if (script_instance) {
 		memdelete(script_instance);
-		script_instance = NULL;
+		script_instance = nullptr;
 	}
 
 	script = p_script;
@@ -1103,7 +1103,7 @@ Variant Object::_emit_signal(const Variant **p_args, int p_argcount, Variant::Ca
 
 	StringName signal = *p_args[0];
 
-	const Variant **args = NULL;
+	const Variant **args = nullptr;
 
 	int argc = p_argcount - 1;
 	if (argc) {
@@ -1334,7 +1334,7 @@ void Object::get_signal_list(List<MethodInfo> *p_signals) const {
 
 	ClassDB::get_signal_list(get_class_name(), p_signals);
 	//find maybe usersignals?
-	const StringName *S = NULL;
+	const StringName *S = nullptr;
 
 	while ((S = signal_map.next(S))) {
 		if (signal_map[*S].user.name != "") {
@@ -1345,7 +1345,7 @@ void Object::get_signal_list(List<MethodInfo> *p_signals) const {
 }
 
 void Object::get_all_signal_connections(List<Connection> *p_connections) const {
-	const StringName *S = NULL;
+	const StringName *S = nullptr;
 
 	while ((S = signal_map.next(S))) {
 		const Signal *s = &signal_map[*S];
@@ -1367,7 +1367,7 @@ void Object::get_signal_connection_list(const StringName &p_signal, List<Connect
 
 int Object::get_persistent_signal_connection_count() const {
 	int count = 0;
-	const StringName *S = NULL;
+	const StringName *S = nullptr;
 
 	while ((S = signal_map.next(S))) {
 		const Signal *s = &signal_map[*S];
@@ -1771,7 +1771,7 @@ Variant::Type Object::get_static_property_type_indexed(const Vector<StringName>
 	}
 
 	Variant::CallError ce;
-	Variant check = Variant::construct(t, NULL, 0, ce);
+	Variant check = Variant::construct(t, nullptr, 0, ce);
 
 	for (int i = 1; i < p_path.size(); i++) {
 		if (check.get_type() == Variant::OBJECT || check.get_type() == Variant::DICTIONARY || check.get_type() == Variant::ARRAY) {
@@ -1817,7 +1817,7 @@ uint32_t Object::get_edited_version() const {
 
 void *Object::get_script_instance_binding(int p_script_language_index) {
 #ifdef DEBUG_ENABLED
-	ERR_FAIL_INDEX_V(p_script_language_index, MAX_SCRIPT_INSTANCE_BINDINGS, NULL);
+	ERR_FAIL_INDEX_V(p_script_language_index, MAX_SCRIPT_INSTANCE_BINDINGS, nullptr);
 #endif
 
 	//it's up to the script language to make this thread safe, if the function is called twice due to threads being out of syncro
@@ -1837,18 +1837,18 @@ void *Object::get_script_instance_binding(int p_script_language_index) {
 }
 
 bool Object::has_script_instance_binding(int p_script_language_index) {
-	return _script_instance_bindings[p_script_language_index] != NULL;
+	return _script_instance_bindings[p_script_language_index] != nullptr;
 }
 
 void Object::set_script_instance_binding(int p_script_language_index, void *p_data) {
 #ifdef DEBUG_ENABLED
-	CRASH_COND(_script_instance_bindings[p_script_language_index] != NULL);
+	CRASH_COND(_script_instance_bindings[p_script_language_index] != nullptr);
 #endif
 	_script_instance_bindings[p_script_language_index] = p_data;
 }
 
 Object::Object() {
-	_class_ptr = NULL;
+	_class_ptr = nullptr;
 	_block_signals = false;
 	_predelete_ok = 0;
 	_instance_id = 0;
@@ -1857,7 +1857,7 @@ Object::Object() {
 	_is_queued_for_deletion = false;
 	_emitting = false;
 	memset(_script_instance_bindings, 0, sizeof(void *) * MAX_SCRIPT_INSTANCE_BINDINGS);
-	script_instance = NULL;
+	script_instance = nullptr;
 #ifdef DEBUG_ENABLED
 	_rc.store(nullptr, std::memory_order_release);
 #endif
@@ -1884,16 +1884,16 @@ Object::~Object() {
 
 	if (script_instance)
 		memdelete(script_instance);
-	script_instance = NULL;
+	script_instance = nullptr;
 
-	const StringName *S = NULL;
+	const StringName *S = nullptr;
 
 	if (_emitting) {
 		//@todo this may need to actually reach the debugger prioritarily somehow because it may crash before
 		ERR_PRINTS("Object " + to_string() + " was freed or unreferenced while a signal is being emitted from it. Try connecting to the signal using 'CONNECT_DEFERRED' flag, or use queue_free() to free the object (if this object is a Node) to avoid this error and potential crashes.");
 	}
 
-	while ((S = signal_map.next(NULL))) {
+	while ((S = signal_map.next(nullptr))) {
 		Signal *s = &signal_map[*S];
 
 		//brute force disconnect for performance
@@ -1964,14 +1964,14 @@ Object *ObjectDB::get_instance(ObjectID p_instance_id) {
 	rw_lock.read_unlock();
 
 	if (!obj)
-		return NULL;
+		return nullptr;
 	return *obj;
 }
 
 void ObjectDB::debug_objects(DebugFunc p_func) {
 	rw_lock.read_lock();
 
-	const ObjectID *K = NULL;
+	const ObjectID *K = nullptr;
 	while ((K = instances.next(K))) {
 		p_func(instances[*K]);
 	}
@@ -2004,13 +2004,13 @@ void ObjectDB::cleanup() {
 			MethodBind *resource_get_path = ClassDB::get_method("Resource", "get_path");
 			Variant::CallError call_error;
 
-			const ObjectID *K = NULL;
+			const ObjectID *K = nullptr;
 			while ((K = instances.next(K))) {
 				String extra_info;
 				if (instances[*K]->is_class("Node"))
-					extra_info = " - Node name: " + String(node_get_name->call(instances[*K], NULL, 0, call_error));
+					extra_info = " - Node name: " + String(node_get_name->call(instances[*K], nullptr, 0, call_error));
 				if (instances[*K]->is_class("Resource"))
-					extra_info = " - Resource path: " + String(resource_get_path->call(instances[*K], NULL, 0, call_error));
+					extra_info = " - Resource path: " + String(resource_get_path->call(instances[*K], nullptr, 0, call_error));
 				print_line("Leaked instance: " + String(instances[*K]->get_class()) + ":" + itos(*K) + extra_info);
 			}
 			print_line("Hint: Leaked instances typically happen when nodes are removed from the scene tree (with `remove_child()`) but not freed (with `free()` or `queue_free()`).");

core/object.h

@@ -423,8 +423,8 @@ public:
 
 		operator Variant() const;
 		Connection() {
-			source = NULL;
-			target = NULL;
+			source = nullptr;
+			target = nullptr;
 			flags = 0;
 		}
 		Connection(const Variant &p_variant);
@@ -659,10 +659,10 @@ public:
 	//void set(const String& p_name, const Variant& p_value);
 	//Variant get(const String& p_name) const;
 
-	void set(const StringName &p_name, const Variant &p_value, bool *r_valid = NULL);
-	Variant get(const StringName &p_name, bool *r_valid = NULL) const;
-	void set_indexed(const Vector<StringName> &p_names, const Variant &p_value, bool *r_valid = NULL);
-	Variant get_indexed(const Vector<StringName> &p_names, bool *r_valid = NULL) const;
+	void set(const StringName &p_name, const Variant &p_value, bool *r_valid = nullptr);
+	Variant get(const StringName &p_name, bool *r_valid = nullptr) const;
+	void set_indexed(const Vector<StringName> &p_names, const Variant &p_value, bool *r_valid = nullptr);
+	Variant get_indexed(const Vector<StringName> &p_names, bool *r_valid = nullptr) const;
 
 	void get_property_list(List<PropertyInfo> *p_list, bool p_reversed = false) const;
 
@@ -679,8 +679,8 @@ public:
 	virtual String to_string();
 
 	//used mainly by script, get and set all INCLUDING string
-	virtual Variant getvar(const Variant &p_key, bool *r_valid = NULL) const;
-	virtual void setvar(const Variant &p_key, const Variant &p_value, bool *r_valid = NULL);
+	virtual Variant getvar(const Variant &p_key, bool *r_valid = nullptr) const;
+	virtual void setvar(const Variant &p_key, const Variant &p_value, bool *r_valid = nullptr);
 
 	/* SCRIPT */
 
@@ -726,8 +726,8 @@ public:
 	void set_block_signals(bool p_block);
 	bool is_blocking_signals() const;
 
-	Variant::Type get_static_property_type(const StringName &p_property, bool *r_valid = NULL) const;
-	Variant::Type get_static_property_type_indexed(const Vector<StringName> &p_path, bool *r_valid = NULL) const;
+	Variant::Type get_static_property_type(const StringName &p_property, bool *r_valid = nullptr) const;
+	Variant::Type get_static_property_type_indexed(const Vector<StringName> &p_path, bool *r_valid = nullptr) const;
 
 	virtual void get_translatable_strings(List<String> *p_strings) const;
 

core/ordered_hash_map.h

@@ -70,9 +70,9 @@ public:
 
 	public:
 		_FORCE_INLINE_ Element() :
-				list_element(NULL),
-				prev_element(NULL),
-				next_element(NULL) {
+				list_element(nullptr),
+				prev_element(nullptr),
+				next_element(nullptr) {
 		}
 
 		Element next() const {
@@ -104,7 +104,7 @@ public:
 		}
 
 		operator bool() const {
-			return (list_element != NULL);
+			return (list_element != nullptr);
 		}
 
 		const K &key() const {
@@ -157,7 +157,7 @@ public:
 		}
 
 		ConstElement next() const {
-			return ConstElement(list_element ? list_element->next() : NULL);
+			return ConstElement(list_element ? list_element->next() : nullptr);
 		}
 
 		ConstElement prev() const {
@@ -172,7 +172,7 @@ public:
 		}
 
 		operator bool() const {
-			return (list_element != NULL);
+			return (list_element != nullptr);
 		}
 
 		const K &key() const {
@@ -196,7 +196,7 @@ public:
 		if (list_element) {
 			return ConstElement(*list_element);
 		}
-		return ConstElement(NULL);
+		return ConstElement(nullptr);
 	}
 
 	Element find(const K &p_key) {
@@ -204,7 +204,7 @@ public:
 		if (list_element) {
 			return Element(*list_element);
 		}
-		return Element(NULL);
+		return Element(nullptr);
 	}
 
 	Element insert(const K &p_key, const V &p_value) {
@@ -223,7 +223,7 @@ public:
 	void erase(Element &p_element) {
 		map.erase(p_element.key());
 		list.erase(p_element.list_element);
-		p_element.list_element = NULL;
+		p_element.list_element = nullptr;
 	}
 
 	bool erase(const K &p_key) {

core/os/dir_access.cpp

@@ -212,10 +212,10 @@ String DirAccess::fix_path(String p_path) const {
 	return p_path;
 }
 
-DirAccess::CreateFunc DirAccess::create_func[ACCESS_MAX] = { 0, 0, 0 };
+DirAccess::CreateFunc DirAccess::create_func[ACCESS_MAX] = { nullptr, nullptr, nullptr };
 
 DirAccess *DirAccess::create_for_path(const String &p_path) {
-	DirAccess *da = NULL;
+	DirAccess *da = nullptr;
 	if (p_path.begins_with("res://")) {
 		da = create(ACCESS_RESOURCES);
 	} else if (p_path.begins_with("user://")) {
@@ -230,20 +230,20 @@ DirAccess *DirAccess::create_for_path(const String &p_path) {
 DirAccess *DirAccess::open(const String &p_path, Error *r_error) {
 	DirAccess *da = create_for_path(p_path);
 
-	ERR_FAIL_COND_V_MSG(!da, NULL, "Cannot create DirAccess for path '" + p_path + "'.");
+	ERR_FAIL_COND_V_MSG(!da, nullptr, "Cannot create DirAccess for path '" + p_path + "'.");
 	Error err = da->change_dir(p_path);
 	if (r_error)
 		*r_error = err;
 	if (err != OK) {
 		memdelete(da);
-		return NULL;
+		return nullptr;
 	}
 
 	return da;
 }
 
 DirAccess *DirAccess::create(AccessType p_access) {
-	DirAccess *da = create_func[p_access] ? create_func[p_access]() : NULL;
+	DirAccess *da = create_func[p_access] ? create_func[p_access]() : nullptr;
 	if (da) {
 		da->_access_type = p_access;
 	}

core/os/dir_access.h

@@ -127,7 +127,7 @@ public:
 		create_func[p_access] = _create_builtin<T>;
 	}
 
-	static DirAccess *open(const String &p_path, Error *r_error = NULL);
+	static DirAccess *open(const String &p_path, Error *r_error = nullptr);
 
 	DirAccess();
 	virtual ~DirAccess();
@@ -138,7 +138,7 @@ struct DirAccessRef {
 		return f;
 	}
 
-	operator bool() const { return f != NULL; }
+	operator bool() const { return f != nullptr; }
 	DirAccess *f;
 	DirAccessRef(DirAccess *fa) { f = fa; }
 	~DirAccessRef() {

core/os/file_access.cpp

@@ -36,14 +36,14 @@
 #include "core/os/os.h"
 #include "core/project_settings.h"
 
-FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { 0, 0 };
+FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { nullptr, nullptr };
 
-FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = NULL;
+FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = nullptr;
 
 bool FileAccess::backup_save = false;
 
 FileAccess *FileAccess::create(AccessType p_access) {
-	ERR_FAIL_INDEX_V(p_access, ACCESS_MAX, 0);
+	ERR_FAIL_INDEX_V(p_access, ACCESS_MAX, nullptr);
 
 	FileAccess *ret = create_func[p_access]();
 	ret->_set_access_type(p_access);
@@ -66,7 +66,7 @@ void FileAccess::_set_access_type(AccessType p_access) {
 };
 
 FileAccess *FileAccess::create_for_path(const String &p_path) {
-	FileAccess *ret = NULL;
+	FileAccess *ret = nullptr;
 	if (p_path.begins_with("res://")) {
 		ret = create(ACCESS_RESOURCES);
 	} else if (p_path.begins_with("user://")) {
@@ -86,7 +86,7 @@ Error FileAccess::reopen(const String &p_path, int p_mode_flags) {
 FileAccess *FileAccess::open(const String &p_path, int p_mode_flags, Error *r_error) {
 	//try packed data first
 
-	FileAccess *ret = NULL;
+	FileAccess *ret = nullptr;
 	if (!(p_mode_flags & WRITE) && PackedData::get_singleton() && !PackedData::get_singleton()->is_disabled()) {
 		ret = PackedData::get_singleton()->try_open_path(p_path);
 		if (ret) {
@@ -103,7 +103,7 @@ FileAccess *FileAccess::open(const String &p_path, int p_mode_flags, Error *r_er
 		*r_error = err;
 	if (err != OK) {
 		memdelete(ret);
-		ret = NULL;
+		ret = nullptr;
 	}
 
 	return ret;

core/os/file_access.h

@@ -151,7 +151,7 @@ public:
 
 	static FileAccess *create(AccessType p_access); /// Create a file access (for the current platform) this is the only portable way of accessing files.
 	static FileAccess *create_for_path(const String &p_path);
-	static FileAccess *open(const String &p_path, int p_mode_flags, Error *r_error = NULL); /// Create a file access (for the current platform) this is the only portable way of accessing files.
+	static FileAccess *open(const String &p_path, int p_mode_flags, Error *r_error = nullptr); /// Create a file access (for the current platform) this is the only portable way of accessing files.
 	static CreateFunc get_create_func(AccessType p_access);
 	static bool exists(const String &p_name); ///< return true if a file exists
 	static uint64_t get_modified_time(const String &p_file);
@@ -165,8 +165,8 @@ public:
 	static String get_sha256(const String &p_file);
 	static String get_multiple_md5(const Vector<String> &p_file);
 
-	static Vector<uint8_t> get_file_as_array(const String &p_path, Error *r_error = NULL);
-	static String get_file_as_string(const String &p_path, Error *r_error = NULL);
+	static Vector<uint8_t> get_file_as_array(const String &p_path, Error *r_error = nullptr);
+	static String get_file_as_string(const String &p_path, Error *r_error = nullptr);
 
 	template <class T>
 	static void make_default(AccessType p_access) {
@@ -182,7 +182,7 @@ struct FileAccessRef {
 		return f;
 	}
 
-	operator bool() const { return f != NULL; }
+	operator bool() const { return f != nullptr; }
 	FileAccess *f;
 	operator FileAccess *() { return f; }
 	FileAccessRef(FileAccess *fa) { f = fa; }

core/os/input.cpp

@@ -38,7 +38,7 @@
 #include "editor/editor_settings.h"
 #endif
 
-Input *Input::singleton = NULL;
+Input *Input::singleton = nullptr;
 
 Input *Input::get_singleton() {
 	return singleton;

core/os/input_event.cpp

@@ -274,10 +274,10 @@ bool InputEventKey::action_match(const Ref<InputEvent> &p_event, bool *p_pressed
 
 	bool match = get_scancode() == key->get_scancode() && (!key->is_pressed() || (code & event_code) == code);
 	if (match) {
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = key->is_pressed();
-		if (p_strength != NULL)
-			*p_strength = (p_pressed != NULL && *p_pressed) ? 1.0f : 0.0f;
+		if (p_strength != nullptr)
+			*p_strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
 	}
 	return match;
 }
@@ -422,10 +422,10 @@ bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event, bool *p
 
 	bool match = mb->button_index == button_index;
 	if (match) {
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = mb->is_pressed();
-		if (p_strength != NULL)
-			*p_strength = (p_pressed != NULL && *p_pressed) ? 1.0f : 0.0f;
+		if (p_strength != nullptr)
+			*p_strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
 	}
 
 	return match;
@@ -669,9 +669,9 @@ bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event, bool *
 	if (match) {
 		bool same_direction = (((axis_value < 0) == (jm->axis_value < 0)) || jm->axis_value == 0);
 		bool pressed = same_direction ? Math::abs(jm->get_axis_value()) >= p_deadzone : false;
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = pressed;
-		if (p_strength != NULL) {
+		if (p_strength != nullptr) {
 			if (pressed) {
 				if (p_deadzone == 1.0f) {
 					*p_strength = 1.0f;
@@ -736,10 +736,10 @@ bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event, bool *
 
 	bool match = button_index == jb->button_index;
 	if (match) {
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = jb->is_pressed();
-		if (p_strength != NULL)
-			*p_strength = (p_pressed != NULL && *p_pressed) ? 1.0f : 0.0f;
+		if (p_strength != nullptr)
+			*p_strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
 	}
 
 	return match;
@@ -950,10 +950,10 @@ bool InputEventAction::action_match(const Ref<InputEvent> &p_event, bool *p_pres
 
 	bool match = action == act->action;
 	if (match) {
-		if (p_pressed != NULL)
+		if (p_pressed != nullptr)
 			*p_pressed = act->pressed;
-		if (p_strength != NULL)
-			*p_strength = (p_pressed != NULL && *p_pressed) ? 1.0f : 0.0f;
+		if (p_strength != nullptr)
+			*p_strength = (p_pressed != nullptr && *p_pressed) ? 1.0f : 0.0f;
 	}
 	return match;
 }

core/os/keyboard.cpp

@@ -288,7 +288,7 @@ static const _KeyCodeText _keycodes[] = {
 
 		{KEY_DIVISION                      ,"Division"},
 		{KEY_YDIAERESIS                    ,"Ydiaeresis"},
-		{0                                 ,0}
+		{0                                 ,nullptr}
 	/* clang-format on */
 };
 

core/os/memory.cpp

@@ -74,7 +74,7 @@ void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
 
 	void *mem = malloc(p_bytes + (prepad ? PAD_ALIGN : 0));
 
-	ERR_FAIL_COND_V(!mem, NULL);
+	ERR_FAIL_COND_V(!mem, nullptr);
 
 	alloc_count.increment();
 
@@ -95,7 +95,7 @@ void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
 }
 
 void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
-	if (p_memory == NULL) {
+	if (p_memory == nullptr) {
 		return alloc_static(p_bytes, p_pad_align);
 	}
 
@@ -122,12 +122,12 @@ void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
 
 		if (p_bytes == 0) {
 			free(mem);
-			return NULL;
+			return nullptr;
 		} else {
 			*s = p_bytes;
 
 			mem = (uint8_t *)realloc(mem, p_bytes + PAD_ALIGN);
-			ERR_FAIL_COND_V(!mem, NULL);
+			ERR_FAIL_COND_V(!mem, nullptr);
 
 			s = (uint64_t *)mem;
 
@@ -138,14 +138,14 @@ void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
 	} else {
 		mem = (uint8_t *)realloc(mem, p_bytes);
 
-		ERR_FAIL_COND_V(mem == NULL && p_bytes > 0, NULL);
+		ERR_FAIL_COND_V(mem == nullptr && p_bytes > 0, nullptr);
 
 		return mem;
 	}
 }
 
 void Memory::free_static(void *p_ptr, bool p_pad_align) {
-	ERR_FAIL_COND(p_ptr == NULL);
+	ERR_FAIL_COND(p_ptr == nullptr);
 
 	uint8_t *mem = (uint8_t *)p_ptr;
 

core/os/memory.h

@@ -137,13 +137,13 @@ void memdelete_allocator(T *p_class) {
 template <typename T>
 T *memnew_arr_template(size_t p_elements, const char *p_descr = "") {
 	if (p_elements == 0)
-		return 0;
+		return nullptr;
 	/** overloading operator new[] cannot be done , because it may not return the real allocated address (it may pad the 'element count' before the actual array). Because of that, it must be done by hand. This is the
 	same strategy used by std::vector, and the PoolVector class, so it should be safe.*/
 
 	size_t len = sizeof(T) * p_elements;
 	uint64_t *mem = (uint64_t *)Memory::alloc_static(len, true);
-	T *failptr = 0; //get rid of a warning
+	T *failptr = nullptr; //get rid of a warning
 	ERR_FAIL_COND_V(!mem, failptr);
 	*(mem - 1) = p_elements;
 

core/os/midi_driver.cpp

@@ -34,7 +34,7 @@
 #include "main/input_default.h"
 
 uint8_t MIDIDriver::last_received_message = 0x00;
-MIDIDriver *MIDIDriver::singleton = NULL;
+MIDIDriver *MIDIDriver::singleton = nullptr;
 MIDIDriver *MIDIDriver::get_singleton() {
 	return singleton;
 }

core/os/os.cpp

@@ -40,7 +40,7 @@
 
 #include <stdarg.h>
 
-OS *OS::singleton = NULL;
+OS *OS::singleton = nullptr;
 uint64_t OS::target_ticks = 0;
 
 OS *OS::get_singleton() {
@@ -191,7 +191,7 @@ void OS::dump_memory_to_file(const char *p_file) {
 	//Memory::dump_static_mem_to_file(p_file);
 }
 
-static FileAccess *_OSPRF = NULL;
+static FileAccess *_OSPRF = nullptr;
 
 static void _OS_printres(Object *p_obj) {
 	Resource *res = Object::cast_to<Resource>(p_obj);
@@ -235,7 +235,7 @@ void OS::print_all_resources(String p_to_file) {
 		Error err;
 		_OSPRF = FileAccess::open(p_to_file, FileAccess::WRITE, &err);
 		if (err != OK) {
-			_OSPRF = NULL;
+			_OSPRF = nullptr;
 			ERR_FAIL_MSG("Can't print all resources to file: " + String(p_to_file) + ".");
 		}
 	}
@@ -245,12 +245,12 @@ void OS::print_all_resources(String p_to_file) {
 	if (p_to_file != "") {
 		if (_OSPRF)
 			memdelete(_OSPRF);
-		_OSPRF = NULL;
+		_OSPRF = nullptr;
 	}
 }
 
 void OS::print_resources_in_use(bool p_short) {
-	ResourceCache::dump(NULL, p_short);
+	ResourceCache::dump(nullptr, p_short);
 }
 
 void OS::dump_resources_to_file(const char *p_file) {
@@ -534,7 +534,7 @@ String OS::get_joy_guid(int p_device) const {
 void OS::set_context(int p_context) {
 }
 
-OS::SwitchVSyncCallbackInThread OS::switch_vsync_function = NULL;
+OS::SwitchVSyncCallbackInThread OS::switch_vsync_function = nullptr;
 
 void OS::set_use_vsync(bool p_enable) {
 	_use_vsync = p_enable;
@@ -766,9 +766,9 @@ OS::OS() {
 	_allow_layered = false;
 	_stack_bottom = (void *)(&stack_bottom);
 
-	_logger = NULL;
+	_logger = nullptr;
 
-	has_server_feature_callback = NULL;
+	has_server_feature_callback = nullptr;
 
 	Vector<Logger *> loggers;
 	loggers.push_back(memnew(StdLogger));
@@ -777,5 +777,5 @@ OS::OS() {
 
 OS::~OS() {
 	memdelete(_logger);
-	singleton = NULL;
+	singleton = nullptr;
 }

core/os/os.h

@@ -249,7 +249,7 @@ public:
 		OPENGL_CONTEXT, // HGLRC, X11::GLXContext, NSOpenGLContext*, EGLContext* ...
 	};
 
-	virtual void *get_native_handle(int p_handle_type) { return NULL; };
+	virtual void *get_native_handle(int p_handle_type) { return nullptr; };
 
 	// Returns window area free of hardware controls and other obstacles.
 	// The application should use this to determine where to place UI elements.
@@ -286,7 +286,7 @@ public:
 	virtual int get_low_processor_usage_mode_sleep_usec() const;
 
 	virtual String get_executable_path() const;
-	virtual Error execute(const String &p_path, const List<String> &p_arguments, bool p_blocking = true, ProcessID *r_child_id = NULL, String *r_pipe = NULL, int *r_exitcode = NULL, bool read_stderr = false, Mutex *p_pipe_mutex = NULL) = 0;
+	virtual Error execute(const String &p_path, const List<String> &p_arguments, bool p_blocking = true, ProcessID *r_child_id = nullptr, String *r_pipe = nullptr, int *r_exitcode = nullptr, bool read_stderr = false, Mutex *p_pipe_mutex = nullptr) = 0;
 	virtual Error kill(const ProcessID &p_pid) = 0;
 	virtual int get_process_id() const;
 	virtual void vibrate_handheld(int p_duration_ms = 500);

core/packed_data_container.cpp

@@ -104,7 +104,7 @@ Variant PackedDataContainer::_get_at_ofs(uint32_t p_ofs, const uint8_t *p_buf, b
 		return pdcr;
 	} else {
 		Variant v;
-		Error rerr = decode_variant(v, p_buf + p_ofs, datalen - p_ofs, NULL, false);
+		Error rerr = decode_variant(v, p_buf + p_ofs, datalen - p_ofs, nullptr, false);
 
 		if (rerr != OK) {
 			err = true;
@@ -227,7 +227,7 @@ uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpd
 		case Variant::NODE_PATH: {
 			uint32_t pos = tmpdata.size();
 			int len;
-			encode_variant(p_data, NULL, len, false);
+			encode_variant(p_data, nullptr, len, false);
 			tmpdata.resize(tmpdata.size() + len);
 			encode_variant(p_data, &tmpdata.write[pos], len, false);
 			return pos;

core/packed_data_container.h

@@ -72,7 +72,7 @@ protected:
 	static void _bind_methods();
 
 public:
-	virtual Variant getvar(const Variant &p_key, bool *r_valid = NULL) const;
+	virtual Variant getvar(const Variant &p_key, bool *r_valid = nullptr) const;
 	Error pack(const Variant &p_data);
 
 	int size() const;
@@ -97,7 +97,7 @@ public:
 	bool _is_dictionary() const;
 
 	int size() const;
-	virtual Variant getvar(const Variant &p_key, bool *r_valid = NULL) const;
+	virtual Variant getvar(const Variant &p_key, bool *r_valid = nullptr) const;
 
 	PackedDataContainerRef();
 };

core/pool_allocator.cpp

@@ -234,9 +234,9 @@ PoolAllocator::ID PoolAllocator::alloc(int p_size) {
 PoolAllocator::Entry *PoolAllocator::get_entry(ID p_mem) {
 	unsigned int check = p_mem & CHECK_MASK;
 	int entry = p_mem >> CHECK_BITS;
-	ERR_FAIL_INDEX_V(entry, entry_max, NULL);
-	ERR_FAIL_COND_V(entry_array[entry].check != check, NULL);
-	ERR_FAIL_COND_V(entry_array[entry].len == 0, NULL);
+	ERR_FAIL_INDEX_V(entry, entry_max, nullptr);
+	ERR_FAIL_COND_V(entry_array[entry].check != check, nullptr);
+	ERR_FAIL_COND_V(entry_array[entry].len == 0, nullptr);
 
 	return &entry_array[entry];
 }
@@ -244,9 +244,9 @@ PoolAllocator::Entry *PoolAllocator::get_entry(ID p_mem) {
 const PoolAllocator::Entry *PoolAllocator::get_entry(ID p_mem) const {
 	unsigned int check = p_mem & CHECK_MASK;
 	int entry = p_mem >> CHECK_BITS;
-	ERR_FAIL_INDEX_V(entry, entry_max, NULL);
-	ERR_FAIL_COND_V(entry_array[entry].check != check, NULL);
-	ERR_FAIL_COND_V(entry_array[entry].len == 0, NULL);
+	ERR_FAIL_INDEX_V(entry, entry_max, nullptr);
+	ERR_FAIL_COND_V(entry_array[entry].check != check, nullptr);
+	ERR_FAIL_COND_V(entry_array[entry].len == 0, nullptr);
 
 	return &entry_array[entry];
 }
@@ -429,7 +429,7 @@ bool PoolAllocator::is_locked(ID p_mem) const {
 const void *PoolAllocator::get(ID p_mem) const {
 	if (!needs_locking) {
 		const Entry *e = get_entry(p_mem);
-		ERR_FAIL_COND_V(!e, NULL);
+		ERR_FAIL_COND_V(!e, nullptr);
 		return &pool[e->pos];
 	}
 
@@ -438,18 +438,18 @@ const void *PoolAllocator::get(ID p_mem) const {
 
 	if (!e) {
 		mt_unlock();
-		ERR_FAIL_COND_V(!e, NULL);
+		ERR_FAIL_COND_V(!e, nullptr);
 	}
 	if (e->lock == 0) {
 		mt_unlock();
 		ERR_PRINT("e->lock == 0");
-		return NULL;
+		return nullptr;
 	}
 
 	if ((int)e->pos >= pool_size) {
 		mt_unlock();
 		ERR_PRINT("e->pos<0 || e->pos>=pool_size");
-		return NULL;
+		return nullptr;
 	}
 	const void *ptr = &pool[e->pos];
 
@@ -461,7 +461,7 @@ const void *PoolAllocator::get(ID p_mem) const {
 void *PoolAllocator::get(ID p_mem) {
 	if (!needs_locking) {
 		Entry *e = get_entry(p_mem);
-		ERR_FAIL_COND_V(!e, NULL);
+		ERR_FAIL_COND_V(!e, nullptr);
 		return &pool[e->pos];
 	}
 
@@ -470,19 +470,19 @@ void *PoolAllocator::get(ID p_mem) {
 
 	if (!e) {
 		mt_unlock();
-		ERR_FAIL_COND_V(!e, NULL);
+		ERR_FAIL_COND_V(!e, nullptr);
 	}
 	if (e->lock == 0) {
 		//assert(0);
 		mt_unlock();
 		ERR_PRINT("e->lock == 0");
-		return NULL;
+		return nullptr;
 	}
 
 	if ((int)e->pos >= pool_size) {
 		mt_unlock();
 		ERR_PRINT("e->pos<0 || e->pos>=pool_size");
-		return NULL;
+		return nullptr;
 	}
 	void *ptr = &pool[e->pos];
 
@@ -558,7 +558,7 @@ PoolAllocator::PoolAllocator(void *p_mem, int p_size, int p_align, bool p_needs_
 	create_pool(p_mem, p_size, p_max_entries);
 	needs_locking = p_needs_locking;
 	align = p_align;
-	mem_ptr = NULL;
+	mem_ptr = nullptr;
 }
 
 PoolAllocator::PoolAllocator(int p_align, int p_size, bool p_needs_locking, int p_max_entries) {

core/pool_vector.cpp

@@ -32,12 +32,12 @@
 
 Mutex pool_vector_lock;
 
-PoolAllocator *MemoryPool::memory_pool = NULL;
-uint8_t *MemoryPool::pool_memory = NULL;
-size_t *MemoryPool::pool_size = NULL;
+PoolAllocator *MemoryPool::memory_pool = nullptr;
+uint8_t *MemoryPool::pool_memory = nullptr;
+size_t *MemoryPool::pool_size = nullptr;
 
-MemoryPool::Alloc *MemoryPool::allocs = NULL;
-MemoryPool::Alloc *MemoryPool::free_list = NULL;
+MemoryPool::Alloc *MemoryPool::allocs = nullptr;
+MemoryPool::Alloc *MemoryPool::free_list = nullptr;
 uint32_t MemoryPool::alloc_count = 0;
 uint32_t MemoryPool::allocs_used = 0;
 Mutex MemoryPool::alloc_mutex;

core/pool_vector.h

@@ -56,10 +56,10 @@ struct MemoryPool {
 
 		Alloc() :
 				lock(0),
-				mem(NULL),
+				mem(nullptr),
 				pool_id(POOL_ALLOCATOR_INVALID_ID),
 				size(0),
-				free_list(NULL) {
+				free_list(nullptr) {
 		}
 	};
 
@@ -165,7 +165,7 @@ class PoolVector {
 				//if some resize
 			} else {
 				memfree(old_alloc->mem);
-				old_alloc->mem = NULL;
+				old_alloc->mem = nullptr;
 				old_alloc->size = 0;
 
 				MemoryPool::alloc_mutex.lock();
@@ -197,7 +197,7 @@ class PoolVector {
 			return;
 
 		if (!alloc->refcount.unref()) {
-			alloc = NULL;
+			alloc = nullptr;
 			return;
 		}
 
@@ -229,7 +229,7 @@ class PoolVector {
 			//if some resize
 		} else {
 			memfree(alloc->mem);
-			alloc->mem = NULL;
+			alloc->mem = nullptr;
 			alloc->size = 0;
 
 			MemoryPool::alloc_mutex.lock();
@@ -239,7 +239,7 @@ class PoolVector {
 			MemoryPool::alloc_mutex.unlock();
 		}
 
-		alloc = NULL;
+		alloc = nullptr;
 	}
 
 public:
@@ -271,14 +271,14 @@ public:
 					}
 				}
 
-				mem = NULL;
-				alloc = NULL;
+				mem = nullptr;
+				alloc = nullptr;
 			}
 		}
 
 		Access() {
-			alloc = NULL;
-			mem = NULL;
+			alloc = nullptr;
+			mem = nullptr;
 		}
 
 	public:
@@ -442,9 +442,9 @@ public:
 	void invert();
 
 	void operator=(const PoolVector &p_pool_vector) { _reference(p_pool_vector); }
-	PoolVector() { alloc = NULL; }
+	PoolVector() { alloc = nullptr; }
 	PoolVector(const PoolVector &p_pool_vector) {
-		alloc = NULL;
+		alloc = nullptr;
 		_reference(p_pool_vector);
 	}
 	~PoolVector() { _unreference(); }
@@ -491,7 +491,7 @@ template <class T>
 Error PoolVector<T>::resize(int p_size) {
 	ERR_FAIL_COND_V_MSG(p_size < 0, ERR_INVALID_PARAMETER, "Size of PoolVector cannot be negative.");
 
-	if (alloc == NULL) {
+	if (alloc == nullptr) {
 		if (p_size == 0)
 			return OK; //nothing to do here
 
@@ -578,7 +578,7 @@ Error PoolVector<T>::resize(int p_size) {
 		} else {
 			if (new_size == 0) {
 				memfree(alloc->mem);
-				alloc->mem = NULL;
+				alloc->mem = nullptr;
 				alloc->size = 0;
 
 				MemoryPool::alloc_mutex.lock();

core/print_string.cpp

@@ -34,7 +34,7 @@
 
 #include <stdio.h>
 
-static PrintHandlerList *print_handler_list = NULL;
+static PrintHandlerList *print_handler_list = nullptr;
 bool _print_line_enabled = true;
 bool _print_error_enabled = true;
 
@@ -48,7 +48,7 @@ void add_print_handler(PrintHandlerList *p_handler) {
 void remove_print_handler(PrintHandlerList *p_handler) {
 	_global_lock();
 
-	PrintHandlerList *prev = NULL;
+	PrintHandlerList *prev = nullptr;
 	PrintHandlerList *l = print_handler_list;
 
 	while (l) {
@@ -65,7 +65,7 @@ void remove_print_handler(PrintHandlerList *p_handler) {
 	//OS::get_singleton()->print("print handler list is %p\n",print_handler_list);
 
 	_global_unlock();
-	ERR_FAIL_COND(l == NULL);
+	ERR_FAIL_COND(l == nullptr);
 }
 
 void print_line(String p_string) {

core/print_string.h

@@ -44,9 +44,9 @@ struct PrintHandlerList {
 	PrintHandlerList *next;
 
 	PrintHandlerList() {
-		printfunc = 0;
-		next = 0;
-		userdata = 0;
+		printfunc = nullptr;
+		next = nullptr;
+		userdata = nullptr;
 	}
 };
 

core/project_settings.cpp

@@ -43,7 +43,7 @@
 
 #include <zlib.h>
 
-ProjectSettings *ProjectSettings::singleton = NULL;
+ProjectSettings *ProjectSettings::singleton = nullptr;
 
 ProjectSettings *ProjectSettings::get_singleton() {
 	return singleton;
@@ -508,7 +508,7 @@ Error ProjectSettings::_load_settings_binary(const String &p_path) {
 		d.resize(vlen);
 		f->get_buffer(d.ptrw(), vlen);
 		Variant value;
-		err = decode_variant(value, d.ptr(), d.size(), NULL, true);
+		err = decode_variant(value, d.ptr(), d.size(), nullptr, true);
 		ERR_CONTINUE_MSG(err != OK, "Error decoding property: " + key + ".");
 		set(key, value);
 	}
@@ -545,7 +545,7 @@ Error ProjectSettings::_load_settings_text(const String &p_path) {
 		next_tag.fields.clear();
 		next_tag.name = String();
 
-		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, NULL, true);
+		err = VariantParser::parse_tag_assign_eof(&stream, lines, error_text, next_tag, assign, value, nullptr, true);
 		if (err == ERR_FILE_EOF) {
 			memdelete(f);
 			// If we're loading a project.godot from source code, we can operate some
@@ -654,7 +654,7 @@ Error ProjectSettings::_save_settings_binary(const String &p_file, const Map<Str
 		file->store_string(key);
 
 		int len;
-		err = encode_variant(p_custom_features, NULL, len, false);
+		err = encode_variant(p_custom_features, nullptr, len, false);
 		if (err != OK) {
 			memdelete(file);
 			ERR_FAIL_V(err);
@@ -690,7 +690,7 @@ Error ProjectSettings::_save_settings_binary(const String &p_file, const Map<Str
 			file->store_string(key);
 
 			int len;
-			err = encode_variant(value, NULL, len, true);
+			err = encode_variant(value, nullptr, len, true);
 			if (err != OK)
 				memdelete(file);
 			ERR_FAIL_COND_V_MSG(err != OK, ERR_INVALID_DATA, "Error when trying to encode Variant.");
@@ -1190,5 +1190,5 @@ ProjectSettings::ProjectSettings() {
 }
 
 ProjectSettings::~ProjectSettings() {
-	singleton = NULL;
+	singleton = nullptr;
 }

core/reference.h

@@ -145,7 +145,7 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
 	void operator=(const RefPtr &p_refptr) {
@@ -158,7 +158,7 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
 	void operator=(const Variant &p_variant) {
@@ -172,7 +172,7 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
 	template <class T_Other>
@@ -189,13 +189,13 @@ public:
 	}
 
 	Ref(const Ref &p_from) {
-		reference = NULL;
+		reference = nullptr;
 		ref(p_from);
 	}
 
 	template <class T_Other>
 	Ref(const Ref<T_Other> &p_from) {
-		reference = NULL;
+		reference = nullptr;
 		Reference *refb = const_cast<Reference *>(static_cast<const Reference *>(p_from.ptr()));
 		if (!refb) {
 			unref();
@@ -204,11 +204,11 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
 	Ref(T *p_reference) {
-		reference = NULL;
+		reference = nullptr;
 		if (p_reference)
 			ref_pointer(p_reference);
 	}
@@ -216,7 +216,7 @@ public:
 	Ref(const Variant &p_variant) {
 		RefPtr refptr = p_variant;
 		Ref<Reference> *irr = reinterpret_cast<Ref<Reference> *>(refptr.get_data());
-		reference = NULL;
+		reference = nullptr;
 		Reference *refb = irr->ptr();
 		if (!refb) {
 			unref();
@@ -225,12 +225,12 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
 	Ref(const RefPtr &p_refptr) {
 		Ref<Reference> *irr = reinterpret_cast<Ref<Reference> *>(p_refptr.get_data());
-		reference = NULL;
+		reference = nullptr;
 		Reference *refb = irr->ptr();
 		if (!refb) {
 			unref();
@@ -239,11 +239,11 @@ public:
 		Ref r;
 		r.reference = Object::cast_to<T>(refb);
 		ref(r);
-		r.reference = NULL;
+		r.reference = nullptr;
 	}
 
-	inline bool is_valid() const { return reference != NULL; }
-	inline bool is_null() const { return reference == NULL; }
+	inline bool is_valid() const { return reference != nullptr; }
+	inline bool is_null() const { return reference == nullptr; }
 
 	void unref() {
 		//TODO this should be moved to mutexes, since this engine does not really
@@ -253,7 +253,7 @@ public:
 		if (reference && reference->unreference()) {
 			memdelete(reference);
 		}
-		reference = NULL;
+		reference = nullptr;
 	}
 
 	void instance() {
@@ -261,7 +261,7 @@ public:
 	}
 
 	Ref() {
-		reference = NULL;
+		reference = nullptr;
 	}
 
 	~Ref() {

core/register_core_types.cpp

@@ -79,17 +79,17 @@ static Ref<TranslationLoaderPO> resource_format_po;
 static Ref<ResourceFormatSaverCrypto> resource_format_saver_crypto;
 static Ref<ResourceFormatLoaderCrypto> resource_format_loader_crypto;
 
-static _ResourceLoader *_resource_loader = NULL;
-static _ResourceSaver *_resource_saver = NULL;
-static _OS *_os = NULL;
-static _Engine *_engine = NULL;
-static _ClassDB *_classdb = NULL;
-static _Marshalls *_marshalls = NULL;
-static _JSON *_json = NULL;
+static _ResourceLoader *_resource_loader = nullptr;
+static _ResourceSaver *_resource_saver = nullptr;
+static _OS *_os = nullptr;
+static _Engine *_engine = nullptr;
+static _ClassDB *_classdb = nullptr;
+static _Marshalls *_marshalls = nullptr;
+static _JSON *_json = nullptr;
 
-static IP *ip = NULL;
+static IP *ip = nullptr;
 
-static _Geometry *_geometry = NULL;
+static _Geometry *_geometry = nullptr;
 
 extern Mutex _global_mutex;
 

core/resource.cpp

@@ -289,7 +289,7 @@ Node *Resource::get_local_scene() const {
 		return _get_local_scene_func();
 	}
 
-	return NULL;
+	return nullptr;
 }
 
 void Resource::setup_local_to_scene() {
@@ -297,7 +297,7 @@ void Resource::setup_local_to_scene() {
 		get_script_instance()->call("_setup_local_to_scene");
 }
 
-Node *(*Resource::_get_local_scene_func)() = NULL;
+Node *(*Resource::_get_local_scene_func)() = nullptr;
 
 void Resource::set_as_translation_remapped(bool p_remapped) {
 	if (remapped_list.in_list() == p_remapped)
@@ -377,7 +377,7 @@ Resource::Resource() :
 
 	subindex = 0;
 	local_to_scene = false;
-	local_scene = NULL;
+	local_scene = nullptr;
 }
 
 Resource::~Resource() {
@@ -434,7 +434,7 @@ Resource *ResourceCache::get(const String &p_path) {
 	lock.read_unlock();
 
 	if (!res) {
-		return NULL;
+		return nullptr;
 	}
 
 	return *res;
@@ -442,7 +442,7 @@ Resource *ResourceCache::get(const String &p_path) {
 
 void ResourceCache::get_cached_resources(List<Ref<Resource>> *p_resources) {
 	lock.read_lock();
-	const String *K = NULL;
+	const String *K = nullptr;
 	while ((K = resources.next(K))) {
 		Resource *r = resources[*K];
 		p_resources->push_back(Ref<Resource>(r));
@@ -464,13 +464,13 @@ void ResourceCache::dump(const char *p_file, bool p_short) {
 
 	Map<String, int> type_count;
 
-	FileAccess *f = NULL;
+	FileAccess *f = nullptr;
 	if (p_file) {
 		f = FileAccess::open(p_file, FileAccess::WRITE);
 		ERR_FAIL_COND_MSG(!f, "Cannot create file at path '" + String(p_file) + "'.");
 	}
 
-	const String *K = NULL;
+	const String *K = nullptr;
 	while ((K = resources.next(K))) {
 		Resource *r = resources[*K];