Use mingw-std-threads in MinGW builds

core/math/aabb.cpp

@@ -117,6 +117,11 @@ AABB AABB::intersection(const AABB &p_aabb) const {
 	return AABB(min, max - min);
 }
 
+#ifdef MINGW_ENABLED
+#undef near
+#undef far
+#endif
+
 bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip, Vector3 *r_normal) const {
 #ifdef MATH_CHECKS
 	if (unlikely(size.x < 0 || size.y < 0 || size.z < 0)) {

core/object/object.h

@@ -656,7 +656,7 @@ private:
 	friend class RefCounted;
 	bool type_is_reference = false;
 
-	std::mutex _instance_binding_mutex;
+	BinaryMutex _instance_binding_mutex;
 	struct InstanceBinding {
 		void *binding = nullptr;
 		void *token = nullptr;

core/os/condition_variable.h

@@ -31,7 +31,14 @@
 #ifndef CONDITION_VARIABLE_H
 #define CONDITION_VARIABLE_H
 
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.condition_variable.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <condition_variable>
+#define THREADING_NAMESPACE std
+#endif
 
 // An object one or multiple threads can wait on a be notified by some other.
 // Normally, you want to use a semaphore for such scenarios, but when the
@@ -40,12 +47,12 @@
 // own mutex to tie the wait-notify to some other behavior, you need to use this.
 
 class ConditionVariable {
-	mutable std::condition_variable condition;
+	mutable THREADING_NAMESPACE::condition_variable condition;
 
 public:
 	template <class BinaryMutexT>
 	_ALWAYS_INLINE_ void wait(const MutexLock<BinaryMutexT> &p_lock) const {
-		condition.wait(const_cast<std::unique_lock<std::mutex> &>(p_lock.lock));
+		condition.wait(const_cast<THREADING_NAMESPACE::unique_lock<THREADING_NAMESPACE::mutex> &>(p_lock.lock));
 	}
 
 	_ALWAYS_INLINE_ void notify_one() const {

core/os/mutex.cpp

@@ -40,7 +40,7 @@ void _global_unlock() {
 	_global_mutex.unlock();
 }
 
-template class MutexImpl<std::recursive_mutex>;
-template class MutexImpl<std::mutex>;
-template class MutexLock<MutexImpl<std::recursive_mutex>>;
-template class MutexLock<MutexImpl<std::mutex>>;
+template class MutexImpl<THREADING_NAMESPACE::recursive_mutex>;
+template class MutexImpl<THREADING_NAMESPACE::mutex>;
+template class MutexLock<MutexImpl<THREADING_NAMESPACE::recursive_mutex>>;
+template class MutexLock<MutexImpl<THREADING_NAMESPACE::mutex>>;

core/os/mutex.h

@@ -34,7 +34,14 @@
 #include "core/error/error_macros.h"
 #include "core/typedefs.h"
 
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.mutex.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <mutex>
+#define THREADING_NAMESPACE std
+#endif
 
 template <class MutexT>
 class MutexLock;
@@ -73,9 +80,9 @@ template <int Tag>
 class SafeBinaryMutex {
 	friend class MutexLock<SafeBinaryMutex>;
 
-	using StdMutexType = std::mutex;
+	using StdMutexType = THREADING_NAMESPACE::mutex;
 
-	mutable std::mutex mutex;
+	mutable THREADING_NAMESPACE::mutex mutex;
 	static thread_local uint32_t count;
 
 public:
@@ -115,7 +122,7 @@ template <class MutexT>
 class MutexLock {
 	friend class ConditionVariable;
 
-	std::unique_lock<typename MutexT::StdMutexType> lock;
+	THREADING_NAMESPACE::unique_lock<typename MutexT::StdMutexType> lock;
 
 public:
 	_ALWAYS_INLINE_ explicit MutexLock(const MutexT &p_mutex) :
@@ -128,7 +135,7 @@ template <int Tag>
 class MutexLock<SafeBinaryMutex<Tag>> {
 	friend class ConditionVariable;
 
-	std::unique_lock<std::mutex> lock;
+	THREADING_NAMESPACE::unique_lock<THREADING_NAMESPACE::mutex> lock;
 
 public:
 	_ALWAYS_INLINE_ explicit MutexLock(const SafeBinaryMutex<Tag> &p_mutex) :
@@ -140,12 +147,12 @@ public:
 	};
 };
 
-using Mutex = MutexImpl<std::recursive_mutex>; // Recursive, for general use
-using BinaryMutex = MutexImpl<std::mutex>; // Non-recursive, handle with care
+using Mutex = MutexImpl<THREADING_NAMESPACE::recursive_mutex>; // Recursive, for general use
+using BinaryMutex = MutexImpl<THREADING_NAMESPACE::mutex>; // Non-recursive, handle with care
 
-extern template class MutexImpl<std::recursive_mutex>;
-extern template class MutexImpl<std::mutex>;
-extern template class MutexLock<MutexImpl<std::recursive_mutex>>;
-extern template class MutexLock<MutexImpl<std::mutex>>;
+extern template class MutexImpl<THREADING_NAMESPACE::recursive_mutex>;
+extern template class MutexImpl<THREADING_NAMESPACE::mutex>;
+extern template class MutexLock<MutexImpl<THREADING_NAMESPACE::recursive_mutex>>;
+extern template class MutexLock<MutexImpl<THREADING_NAMESPACE::mutex>>;
 
 #endif // MUTEX_H

core/os/os.cpp

@@ -39,7 +39,15 @@
 #include "core/version_generated.gen.h"
 
 #include <stdarg.h>
+
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.thread.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <thread>
+#define THREADING_NAMESPACE std
+#endif
 
 OS *OS::singleton = nullptr;
 uint64_t OS::target_ticks = 0;
@@ -359,7 +367,7 @@ String OS::get_unique_id() const {
 }
 
 int OS::get_processor_count() const {
-	return std::thread::hardware_concurrency();
+	return THREADING_NAMESPACE::thread::hardware_concurrency();
 }
 
 String OS::get_processor_name() const {

core/os/rw_lock.h

@@ -33,10 +33,17 @@
 
 #include "core/typedefs.h"
 
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.shared_mutex.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <shared_mutex>
+#define THREADING_NAMESPACE std
+#endif
 
 class RWLock {
-	mutable std::shared_timed_mutex mutex;
+	mutable THREADING_NAMESPACE::shared_timed_mutex mutex;
 
 public:
 	// Lock the RWLock, block if locked by someone else.

core/os/semaphore.h

@@ -37,13 +37,21 @@
 #include "core/error/error_macros.h"
 #endif
 
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.condition_variable.h"
+#include "thirdparty/mingw-std-threads/mingw.mutex.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <condition_variable>
 #include <mutex>
+#define THREADING_NAMESPACE std
+#endif
 
 class Semaphore {
 private:
-	mutable std::mutex mutex;
-	mutable std::condition_variable condition;
+	mutable THREADING_NAMESPACE::mutex mutex;
+	mutable THREADING_NAMESPACE::condition_variable condition;
 	mutable uint32_t count = 0; // Initialized as locked.
 #ifdef DEBUG_ENABLED
 	mutable uint32_t awaiters = 0;
@@ -57,7 +65,7 @@ public:
 	}
 
 	_ALWAYS_INLINE_ void wait() const {
-		std::unique_lock lock(mutex);
+		THREADING_NAMESPACE::unique_lock lock(mutex);
 #ifdef DEBUG_ENABLED
 		++awaiters;
 #endif
@@ -116,7 +124,7 @@ public:
 					"A Semaphore object is being destroyed while one or more threads are still waiting on it.\n"
 					"Please call post() on it as necessary to prevent such a situation and so ensure correct cleanup.");
 			// And now, the hacky countermeasure (i.e., leak the condition variable).
-			new (&condition) std::condition_variable();
+			new (&condition) THREADING_NAMESPACE::condition_variable();
 		}
 	}
 #endif

core/os/thread.cpp

@@ -69,8 +69,7 @@ void Thread::callback(ID p_caller_id, const Settings &p_settings, Callback p_cal
 Thread::ID Thread::start(Thread::Callback p_callback, void *p_user, const Settings &p_settings) {
 	ERR_FAIL_COND_V_MSG(id != UNASSIGNED_ID, UNASSIGNED_ID, "A Thread object has been re-started without wait_to_finish() having been called on it.");
 	id = id_counter.increment();
-	std::thread new_thread(&Thread::callback, id, p_settings, p_callback, p_user);
-	thread.swap(new_thread);
+	thread = THREADING_NAMESPACE::thread(&Thread::callback, id, p_settings, p_callback, p_user);
 	return id;
 }
 
@@ -82,8 +81,7 @@ void Thread::wait_to_finish() {
 	ERR_FAIL_COND_MSG(id == UNASSIGNED_ID, "Attempt of waiting to finish on a thread that was never started.");
 	ERR_FAIL_COND_MSG(id == get_caller_id(), "Threads can't wait to finish on themselves, another thread must wait.");
 	thread.join();
-	std::thread empty_thread;
-	thread.swap(empty_thread);
+	thread = THREADING_NAMESPACE::thread();
 	id = UNASSIGNED_ID;
 }
 

core/os/thread.h

@@ -42,7 +42,14 @@
 #include "core/templates/safe_refcount.h"
 #include "core/typedefs.h"
 
+#ifdef MINGW_ENABLED
+#define MINGW_STDTHREAD_REDUNDANCY_WARNING
+#include "thirdparty/mingw-std-threads/mingw.thread.h"
+#define THREADING_NAMESPACE mingw_stdthread
+#else
 #include <thread>
+#define THREADING_NAMESPACE std
+#endif
 
 class String;
 
@@ -82,7 +89,7 @@ private:
 	ID id = UNASSIGNED_ID;
 	static SafeNumeric<uint64_t> id_counter;
 	static thread_local ID caller_id;
-	std::thread thread;
+	THREADING_NAMESPACE::thread thread;
 
 	static void callback(ID p_caller_id, const Settings &p_settings, Thread::Callback p_callback, void *p_userdata);