Port a bunch of Godot container templates to GDExtension.

include/godot_cpp/core/class_db.hpp

@@ -209,6 +209,9 @@ MethodBind *ClassDB::bind_vararg_method(uint32_t p_flags, const char *p_name, M
 
 	return bind;
 }
+
+#define GDREGISTER_CLASS(m_class) ClassDB::register_class<m_class>();
+
 } // namespace godot
 
 #endif // ! CLASS_DB_HPP

include/godot_cpp/core/math.hpp

@@ -62,6 +62,34 @@ namespace Math {
 #define Math_INF INFINITY
 #define Math_NAN NAN
 
+// Windows badly defines a lot of stuff we'll never use. Undefine it.
+#ifdef _WIN32
+#undef MIN // override standard definition
+#undef MAX // override standard definition
+#undef CLAMP // override standard definition
+#endif
+
+// Generic ABS function, for math uses please use Math::abs.
+#ifndef ABS
+#define ABS(m_v) (((m_v) < 0) ? (-(m_v)) : (m_v))
+#endif
+
+#ifndef SIGN
+#define SIGN(m_v) (((m_v) == 0) ? (0.0) : (((m_v) < 0) ? (-1.0) : (+1.0)))
+#endif
+
+#ifndef MIN
+#define MIN(m_a, m_b) (((m_a) < (m_b)) ? (m_a) : (m_b))
+#endif
+
+#ifndef MAX
+#define MAX(m_a, m_b) (((m_a) > (m_b)) ? (m_a) : (m_b))
+#endif
+
+#ifndef CLAMP
+#define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a))
+#endif
+
 // Functions reproduced as in Godot's source code `math_funcs.h`.
 // Some are overloads to automatically support changing real_t into either double or float in the way Godot does.
 
@@ -435,7 +463,7 @@ inline int fast_ftoi(float a) {
 	: "m" (a));*/
 
 #else
-	b = lrintf(a); //assuming everything but msvc 2012 or earlier has lrint
+	b = lrintf(a); // assuming everything but msvc 2012 or earlier has lrint
 #endif
 	return b;
 }

include/godot_cpp/core/memory.hpp

@@ -41,6 +41,7 @@
 #include <type_traits>
 
 void *operator new(size_t p_size, const char *p_description); ///< operator new that takes a description and uses MemoryStaticPool
+void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)); ///< operator new that takes a description and uses MemoryStaticPool
 void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description); ///< operator new that takes a description and uses a pointer to the preallocated memory
 
 _ALWAYS_INLINE_ void *operator new(size_t p_size, void *p_pointer, size_t check, const char *p_description) {
@@ -76,10 +77,27 @@ _ALWAYS_INLINE_ T *_post_initialize(T *p_obj) {
 	return p_obj;
 }
 
+#define memalloc(m_size) Memory::alloc_static(m_size)
+#define memrealloc(m_mem, m_size) Memory::realloc_static(m_mem, m_size)
+#define memfree(m_mem) Memory::free_static(m_mem)
+
 #define memnew(m_class) _post_initialize(new ("") m_class)
 
+#define memnew_allocator(m_class, m_allocator) _post_initialize(new (m_allocator::alloc) m_class)
 #define memnew_placement(m_placement, m_class) _post_initialize(new (m_placement, sizeof(m_class), "") m_class)
 
+// Generic comparator used in Map, List, etc.
+template <class T>
+struct Comparator {
+	_ALWAYS_INLINE_ bool operator()(const T &p_a, const T &p_b) const { return (p_a < p_b); }
+};
+
+class DefaultAllocator {
+public:
+	_ALWAYS_INLINE_ static void *alloc(size_t p_memory) { return Memory::alloc_static(p_memory); }
+	_ALWAYS_INLINE_ static void free(void *p_ptr) { Memory::free_static(p_ptr); }
+};
+
 template <class T>
 void memdelete(T *p_class, typename std::enable_if<!std::is_base_of_v<godot::Wrapped, T>>::type * = 0) {
 	if (!__has_trivial_destructor(T)) {
@@ -94,6 +112,15 @@ void memdelete(T *p_class) {
 	godot::internal::gdn_interface->object_destroy(p_class->_owner);
 }
 
+template <class T, class A>
+void memdelete_allocator(T *p_class) {
+	if (!__has_trivial_destructor(T)) {
+		p_class->~T();
+	}
+
+	A::free(p_class);
+}
+
 #define memnew_arr(m_class, m_count) memnew_arr_template<m_class>(m_count)
 
 template <typename T>
@@ -137,6 +164,19 @@ void memdelete_arr(T *p_class) {
 	Memory::free_static(ptr);
 }
 
+struct _GlobalNil {
+	int color = 1;
+	_GlobalNil *right;
+	_GlobalNil *left;
+	_GlobalNil *parent;
+
+	_GlobalNil();
+};
+
+struct _GlobalNilClass {
+	static _GlobalNil _nil;
+};
+
 } // namespace godot
 
 #endif // ! GODOT_CPP_MEMORY_HPP

include/godot_cpp/core/mutex_lock.hpp

@@ -0,0 +1,59 @@
+/*************************************************************************/
+/*  mutex_lock.hpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef MUTEX_LOCK_HPP
+#define MUTEX_LOCK_HPP
+
+#include <godot_cpp/classes/mutex.hpp>
+
+namespace godot {
+
+class MutexLock {
+	const Mutex &mutex;
+
+public:
+	_ALWAYS_INLINE_ explicit MutexLock(const Mutex &p_mutex) :
+			mutex(p_mutex) {
+		const_cast<Mutex *>(&mutex)->lock();
+	}
+
+	_ALWAYS_INLINE_ ~MutexLock() {
+		const_cast<Mutex *>(&mutex)->unlock();
+	}
+};
+
+#define _THREAD_SAFE_CLASS_ mutable Mutex _thread_safe_;
+#define _THREAD_SAFE_METHOD_ MutexLock _thread_safe_method_(_thread_safe_);
+#define _THREAD_SAFE_LOCK_ _thread_safe_.lock();
+#define _THREAD_SAFE_UNLOCK_ _thread_safe_.unlock();
+
+} // namespace godot
+
+#endif // ! MUTEX_LOCK_HPP