Removed using namespace std from namespace JPH (#308)

Jolt/AABBTree/AABBTreeToBuffer.h

@@ -13,7 +13,7 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
-template <class T> using Deque = deque<T, STLAllocator<T>>;
+template <class T> using Deque = std::deque<T, STLAllocator<T>>;
 
 /// Conversion algorithm that converts an AABB tree to an optimized binary buffer
 template <class TriangleCodec, class NodeCodec>

Jolt/Core/Atomics.h

@@ -9,6 +9,14 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
+// Things we're using from STL
+using std::atomic;
+using std::memory_order;
+using std::memory_order_relaxed;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_seq_cst;
+
 /// Atomically compute the min(ioAtomic, inValue) and store it in ioAtomic, returns true if value was updated
 template <class T>
 bool AtomicMin(atomic<T> &ioAtomic, const T inValue, const memory_order inMemoryOrder = memory_order_seq_cst)

Jolt/Core/ByteBuffer.h

@@ -8,7 +8,7 @@
 JPH_NAMESPACE_BEGIN
 
 /// Underlying data type for ByteBuffer
-using ByteBufferVector = vector<uint8, STLAlignedAllocator<uint8, JPH_CACHE_LINE_SIZE>>;
+using ByteBufferVector = std::vector<uint8, STLAlignedAllocator<uint8, JPH_CACHE_LINE_SIZE>>;
 
 /// Simple byte buffer, aligned to a cache line
 class ByteBuffer : public ByteBufferVector

Jolt/Core/Core.h

@@ -115,14 +115,8 @@
 #define JPH_SUPPRESS_WARNING_PUSH		JPH_PRAGMA(clang diagnostic push)
 #define JPH_SUPPRESS_WARNING_POP		JPH_PRAGMA(clang diagnostic pop)
 #define JPH_CLANG_SUPPRESS_WARNING(w)	JPH_PRAGMA(clang diagnostic ignored w)
-	#if __clang_major__ >= 15
-		#define JPH_CLANG15_SUPPRESS_WARNING(w)	JPH_PRAGMA(clang diagnostic ignored w)
-	#else
-		#define JPH_CLANG15_SUPPRESS_WARNING(w)
-	#endif
 #else
 #define JPH_CLANG_SUPPRESS_WARNING(w)
-#define JPH_CLANG15_SUPPRESS_WARNING(w)
 #endif
 #ifdef JPH_COMPILER_GCC
 #define JPH_PRAGMA(x)					_Pragma(#x)
@@ -163,7 +157,6 @@
 	JPH_CLANG_SUPPRESS_WARNING("-Wdocumentation-unknown-command")								\
 	JPH_CLANG_SUPPRESS_WARNING("-Wctad-maybe-unsupported")										\
 	JPH_CLANG_SUPPRESS_WARNING("-Wdeprecated-copy")												\
-	JPH_CLANG15_SUPPRESS_WARNING("-Wunqualified-std-cast-call")									\
 	JPH_IF_NOT_ANDROID(JPH_CLANG_SUPPRESS_WARNING("-Wimplicit-int-float-conversion"))			\
 																								\
 	JPH_GCC_SUPPRESS_WARNING("-Wcomment")														\
@@ -258,7 +251,30 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
-using namespace std;
+// Commonly used STL types
+using std::pair;
+using std::min;
+using std::max;
+using std::abs;
+using std::sqrt;
+using std::ceil;
+using std::floor;
+using std::trunc;
+using std::round;
+using std::fmod;
+using std::swap;
+using std::size;
+using std::string;
+using std::string_view;
+using std::function;
+using std::numeric_limits;
+using std::isfinite;
+using std::isnan;
+using std::is_trivial;
+using std::is_trivially_constructible;
+using std::is_trivially_destructible;
+using std::ostream;
+using std::istream;
 
 // Standard types
 using uint = unsigned int;

Jolt/Core/FixedSizeFreeList.h

@@ -5,10 +5,7 @@
 
 #include <Jolt/Core/NonCopyable.h>
 #include <Jolt/Core/Mutex.h>
-
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#include <atomic>
-JPH_SUPPRESS_WARNINGS_STD_END
+#include <Jolt/Core/Atomics.h>
 
 JPH_NAMESPACE_BEGIN
 

Jolt/Core/FixedSizeFreeList.inl

@@ -74,7 +74,7 @@ uint32 FixedSizeFreeList<Object>::ConstructObject(Parameters &&... inParameters)
 			// Allocation successful
 			JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_sub(1, memory_order_relaxed);)
 			ObjectStorage &storage = GetStorage(first_free);
-			::new (&storage.mObject) Object(forward<Parameters>(inParameters)...);
+			::new (&storage.mObject) Object(std::forward<Parameters>(inParameters)...);
 			storage.mNextFreeObject.store(first_free, memory_order_release);
 			return first_free;
 		}
@@ -92,7 +92,7 @@ uint32 FixedSizeFreeList<Object>::ConstructObject(Parameters &&... inParameters)
 				// Allocation successful
 				JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_sub(1, memory_order_relaxed);)
 				ObjectStorage &storage = GetStorage(first_free);
-				::new (&storage.mObject) Object(forward<Parameters>(inParameters)...);
+				::new (&storage.mObject) Object(std::forward<Parameters>(inParameters)...);
 				storage.mNextFreeObject.store(first_free, memory_order_release);
 				return first_free;
 			}

Jolt/Core/InsertionSort.h

@@ -16,7 +16,7 @@ inline void InsertionSort(Iterator inBegin, Iterator inEnd, Compare inCompare)
 		for (Iterator i = inBegin + 1; i != inEnd; ++i)
 		{
 			// Move this element to a temporary value
-			auto x = move(*i);
+			auto x = std::move(*i);
 
 			// Check if the element goes before inBegin (we can't decrement the iterator before inBegin so this needs to be a separate branch)
 			if (inCompare(x, *inBegin))
@@ -30,17 +30,17 @@ inline void InsertionSort(Iterator inBegin, Iterator inEnd, Compare inCompare)
 				}
 
 				// Move x to the first place
-				*inBegin = move(x);
+				*inBegin = std::move(x);
 			}
 			else
 			{
 				// Move elements to the right as long as they are bigger than x
 				Iterator j = i;
 				for (Iterator prev = j - 1; inCompare(x, *prev); j = prev, --prev)
-					*j = move(*prev);
+					*j = std::move(*prev);
 
 				// Move x into place
-				*j = move(x);
+				*j = std::move(x);
 			}
 		}
 	}
@@ -50,7 +50,7 @@ inline void InsertionSort(Iterator inBegin, Iterator inEnd, Compare inCompare)
 template <typename Iterator>
 inline void InsertionSort(Iterator inBegin, Iterator inEnd)
 {
-	less<> compare;
+	std::less<> compare;
 	InsertionSort(inBegin, inEnd, compare);
 }
 

Jolt/Core/JobSystem.h

@@ -8,10 +8,7 @@
 #include <Jolt/Core/Profiler.h>
 #include <Jolt/Core/NonCopyable.h>
 #include <Jolt/Core/StaticArray.h>
-
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#include <atomic>
-JPH_SUPPRESS_WARNINGS_STD_END
+#include <Jolt/Core/Atomics.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -57,14 +54,14 @@ public:
 		/// Constructor 
 		inline				JobHandle() = default;
 		inline				JobHandle(const JobHandle &inHandle) = default;
-		inline				JobHandle(JobHandle &&inHandle) noexcept	: Ref<Job>(move(inHandle)) { }
+		inline				JobHandle(JobHandle &&inHandle) noexcept	: Ref<Job>(std::move(inHandle)) { }
 
 		/// Constructor, only to be used by JobSystem
 		inline explicit		JobHandle(Job *inJob)						: Ref<Job>(inJob) { }
 
 		/// Assignment
 		inline JobHandle &	operator = (const JobHandle &inHandle)		{ Ref<Job>::operator = (inHandle); return *this; }
-		inline JobHandle &	operator = (JobHandle &&inHandle) noexcept	{ Ref<Job>::operator = (move(inHandle)); return *this; }
+		inline JobHandle &	operator = (JobHandle &&inHandle) noexcept	{ Ref<Job>::operator = (std::move(inHandle)); return *this; }
 
 		/// Check if this handle contains a job
 		inline bool			IsValid() const								{ return GetPtr() != nullptr; }

Jolt/Core/JobSystemThreadPool.cpp

@@ -113,7 +113,7 @@ void JobSystemThreadPool::BarrierImpl::AddJob(const JobHandle &inJob)
 		while (write_index - mJobReadIndex >= cMaxJobs)
 		{
 			JPH_ASSERT(false, "Barrier full, stalling!");
-			this_thread::sleep_for(100us);
+			std::this_thread::sleep_for(std::chrono::microseconds(100));
 		}
 		mJobs[write_index & (cMaxJobs - 1)] = job;
 	}
@@ -149,7 +149,7 @@ void JobSystemThreadPool::BarrierImpl::AddJobs(const JobHandle *inHandles, uint
 			while (write_index - mJobReadIndex >= cMaxJobs)
 			{
 				JPH_ASSERT(false, "Barrier full, stalling!");
-				this_thread::sleep_for(100us);
+				std::this_thread::sleep_for(std::chrono::microseconds(100));
 			}
 			mJobs[write_index & (cMaxJobs - 1)] = job;
 		}
@@ -339,7 +339,7 @@ JobHandle JobSystemThreadPool::CreateJob(const char *inJobName, ColorArg inColor
 		if (index != AvailableJobs::cInvalidObjectIndex)
 			break;
 		JPH_ASSERT(false, "No jobs available!");
-		this_thread::sleep_for(100us);
+		std::this_thread::sleep_for(std::chrono::microseconds(100));
 	}
 	Job *job = &mJobs.Get(index);
 	
@@ -431,7 +431,7 @@ void JobSystemThreadPool::QueueJobInternal(Job *inJob)
 				mSemaphore.Release((uint)mThreads.size()); 
 
 				// Sleep a little (we have to wait for other threads to update their head pointer in order for us to be able to continue)
-				this_thread::sleep_for(100us);
+				std::this_thread::sleep_for(std::chrono::microseconds(100));
 				continue;
 			}
 		}

Jolt/Core/JobSystemThreadPool.h

@@ -14,6 +14,11 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
+// Things we're using from STL
+using std::atomic;
+using std::thread;
+using std::condition_variable;
+
 /// Implementation of a JobSystem using a thread pool
 /// 
 /// Note that this is considered an example implementation. It is expected that when you integrate

Jolt/Core/LockFreeHashMap.h

@@ -4,10 +4,7 @@
 #pragma once
 
 #include <Jolt/Core/NonCopyable.h>
-
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#include <atomic>
-JPH_SUPPRESS_WARNINGS_STD_END
+#include <Jolt/Core/Atomics.h>
 
 JPH_NAMESPACE_BEGIN
 

Jolt/Core/LockFreeHashMap.inl

@@ -192,7 +192,7 @@ inline typename LockFreeHashMap<Key, Value>::KeyValue *LockFreeHashMap<Key, Valu
 	memset(kv, 0xcd, size);
 #endif
 	kv->mKey = inKey;
-	new (&kv->mValue) Value(forward<Params>(inConstructorParams)...);
+	new (&kv->mValue) Value(std::forward<Params>(inConstructorParams)...);
 
 	// Get the offset to the first object from the bucket with corresponding hash
 	atomic<uint32> &offset = mBuckets[inKeyHash & (mNumBuckets - 1)];

Jolt/Core/Memory.h

@@ -26,14 +26,14 @@ void RegisterDefaultAllocator();
 
 /// Macro to override the new and delete functions
 #define JPH_OVERRIDE_NEW_DELETE \
-	JPH_INLINE void *operator new (size_t inCount)											{ return JPH::Allocate(inCount); } \
-	JPH_INLINE void operator delete (void *inPointer) noexcept								{ JPH::Free(inPointer); } \
-	JPH_INLINE void *operator new[] (size_t inCount)										{ return JPH::Allocate(inCount); } \
-	JPH_INLINE void operator delete[] (void *inPointer) noexcept							{ JPH::Free(inPointer); } \
-	JPH_INLINE void *operator new (size_t inCount, align_val_t inAlignment)					{ return JPH::AlignedAllocate(inCount, static_cast<size_t>(inAlignment)); } \
-	JPH_INLINE void operator delete (void *inPointer, align_val_t inAlignment) noexcept		{ JPH::AlignedFree(inPointer); } \
-	JPH_INLINE void *operator new[] (size_t inCount, align_val_t inAlignment)				{ return JPH::AlignedAllocate(inCount, static_cast<size_t>(inAlignment)); } \
-	JPH_INLINE void operator delete[] (void *inPointer, align_val_t inAlignment) noexcept	{ JPH::AlignedFree(inPointer); }
+	JPH_INLINE void *operator new (size_t inCount)												{ return JPH::Allocate(inCount); } \
+	JPH_INLINE void operator delete (void *inPointer) noexcept									{ JPH::Free(inPointer); } \
+	JPH_INLINE void *operator new[] (size_t inCount)											{ return JPH::Allocate(inCount); } \
+	JPH_INLINE void operator delete[] (void *inPointer) noexcept								{ JPH::Free(inPointer); } \
+	JPH_INLINE void *operator new (size_t inCount, std::align_val_t inAlignment)				{ return JPH::AlignedAllocate(inCount, static_cast<size_t>(inAlignment)); } \
+	JPH_INLINE void operator delete (void *inPointer, std::align_val_t inAlignment) noexcept	{ JPH::AlignedFree(inPointer); } \
+	JPH_INLINE void *operator new[] (size_t inCount, std::align_val_t inAlignment)				{ return JPH::AlignedAllocate(inCount, static_cast<size_t>(inAlignment)); } \
+	JPH_INLINE void operator delete[] (void *inPointer, std::align_val_t inAlignment) noexcept	{ JPH::AlignedFree(inPointer); }
 
 #else
 

Jolt/Core/Mutex.h

@@ -14,6 +14,14 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
+// Things we're using from STL
+using std::mutex;
+using std::shared_mutex;
+using std::thread;
+using std::lock_guard;
+using std::shared_lock;
+using std::unique_lock;
+
 #ifdef JPH_PLATFORM_BLUE
 
 // On Platform Blue the mutex class is not very fast so we implement it using the official APIs
@@ -114,10 +122,10 @@ class Mutex : public MutexBase
 public:
 	inline bool		try_lock()
 	{
-		JPH_ASSERT(mLockedThreadID != this_thread::get_id());
+		JPH_ASSERT(mLockedThreadID != std::this_thread::get_id());
 		if (MutexBase::try_lock())
 		{
-			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = this_thread::get_id();)
+			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = std::this_thread::get_id();)
 			return true;
 		}
 		return false;
@@ -129,13 +137,13 @@ public:
 		{
 			JPH_PROFILE("Lock", 0xff00ffff);
 			MutexBase::lock();
-			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = this_thread::get_id();)
+			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = std::this_thread::get_id();)
 		}
 	}
 
 	inline void		unlock()
 	{
-		JPH_ASSERT(mLockedThreadID == this_thread::get_id());
+		JPH_ASSERT(mLockedThreadID == std::this_thread::get_id());
 		JPH_IF_ENABLE_ASSERTS(mLockedThreadID = thread::id();)
 		MutexBase::unlock();
 	}
@@ -158,10 +166,10 @@ class SharedMutex : public SharedMutexBase
 public:
 	inline bool		try_lock()
 	{
-		JPH_ASSERT(mLockedThreadID != this_thread::get_id());
+		JPH_ASSERT(mLockedThreadID != std::this_thread::get_id());
 		if (SharedMutexBase::try_lock())
 		{
-			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = this_thread::get_id();)
+			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = std::this_thread::get_id();)
 			return true;
 		}
 		return false;
@@ -173,13 +181,13 @@ public:
 		{
 			JPH_PROFILE("WLock", 0xff00ffff);
 			SharedMutexBase::lock();
-			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = this_thread::get_id();)
+			JPH_IF_ENABLE_ASSERTS(mLockedThreadID = std::this_thread::get_id();)
 		}
 	}
 
 	inline void		unlock()
 	{
-		JPH_ASSERT(mLockedThreadID == this_thread::get_id());
+		JPH_ASSERT(mLockedThreadID == std::this_thread::get_id());
 		JPH_IF_ENABLE_ASSERTS(mLockedThreadID = thread::id();)
 		SharedMutexBase::unlock();
 	}

Jolt/Core/Profiler.cpp

@@ -27,7 +27,7 @@ bool ProfileMeasurement::sOutOfSamplesReported = false;
 
 void Profiler::NextFrame()
 {
-	lock_guard lock(mLock);
+	std::lock_guard lock(mLock);
 
 	if (mDump)
 	{
@@ -47,14 +47,14 @@ void Profiler::Dump(const string_view &inTag)
 
 void Profiler::AddThread(ProfileThread *inThread)										
 { 
-	lock_guard lock(mLock); 
+	std::lock_guard lock(mLock); 
 
 	mThreads.push_back(inThread); 
 }
 
 void Profiler::RemoveThread(ProfileThread *inThread)									
 { 
-	lock_guard lock(mLock); 
+	std::lock_guard lock(mLock); 
 	
 	Array<ProfileThread *>::iterator i = find(mThreads.begin(), mThreads.end(), inThread); 
 	JPH_ASSERT(i != mThreads.end()); 
@@ -179,8 +179,8 @@ static String sHTMLEncode(const char *inString)
 void Profiler::DumpList(const char *inTag, const Aggregators &inAggregators)
 {
 	// Open file
-	ofstream f;
-	f.open(StringFormat("profile_list_%s.html", inTag).c_str(), ofstream::out | ofstream::trunc);
+	std::ofstream f;
+	f.open(StringFormat("profile_list_%s.html", inTag).c_str(), std::ofstream::out | std::ofstream::trunc);
 	if (!f.is_open()) 
 		return;
 
@@ -259,8 +259,8 @@ void Profiler::DumpList(const char *inTag, const Aggregators &inAggregators)
 void Profiler::DumpChart(const char *inTag, const Threads &inThreads, const KeyToAggregator &inKeyToAggregators, const Aggregators &inAggregators)
 {
 	// Open file
-	ofstream f;
-	f.open(StringFormat("profile_chart_%s.html", inTag).c_str(), ofstream::out | ofstream::trunc);
+	std::ofstream f;
+	f.open(StringFormat("profile_chart_%s.html", inTag).c_str(), std::ofstream::out | std::ofstream::trunc);
 	if (!f.is_open()) 
 		return;
 

Jolt/Core/Profiler.h

@@ -149,7 +149,7 @@ private:
 	void						DumpList(const char *inTag, const Aggregators &inAggregators);
 	void						DumpChart(const char *inTag, const Threads &inThreads, const KeyToAggregator &inKeyToAggregators, const Aggregators &inAggregators);
 
-	mutex						mLock;																///< Lock that protects mThreads
+	std::mutex					mLock;																///< Lock that protects mThreads
 	Array<ProfileThread *>		mThreads;															///< List of all active threads
 	bool						mDump = false;														///< When true, the samples are dumped next frame
 	String						mDumpTag;															///< When not empty, this overrides the auto incrementing number of the dump filename

Jolt/Core/QuickSort.h

@@ -129,7 +129,7 @@ inline void QuickSort(Iterator inBegin, Iterator inEnd, Compare inCompare)
 template <typename Iterator>
 inline void QuickSort(Iterator inBegin, Iterator inEnd)
 {
-	less<> compare;
+	std::less<> compare;
 	QuickSort(inBegin, inEnd, compare);
 }
 

Jolt/Core/Reference.h

@@ -3,9 +3,7 @@
 
 #pragma once
 
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#include <atomic>
-JPH_SUPPRESS_WARNINGS_STD_END
+#include <Jolt/Core/Atomics.h>
 
 JPH_NAMESPACE_BEGIN
 

Jolt/Core/Result.h

@@ -42,11 +42,11 @@ public:
 		switch (inRHS.mState)
 		{
 		case EState::Valid:
-			::new (&mResult) Type (move(inRHS.mResult));
+			::new (&mResult) Type (std::move(inRHS.mResult));
 			break;
 
 		case EState::Error:
-			::new (&mError) String(move(inRHS.mError));
+			::new (&mError) String(std::move(inRHS.mError));
 			break;
 
 		case EState::Invalid:
@@ -93,11 +93,11 @@ public:
 		switch (inRHS.mState)
 		{
 		case EState::Valid:
-			::new (&mResult) Type (move(inRHS.mResult));
+			::new (&mResult) Type (std::move(inRHS.mResult));
 			break;
 
 		case EState::Error:
-			::new (&mError) String(move(inRHS.mError));
+			::new (&mError) String(std::move(inRHS.mError));
 			break;
 
 		case EState::Invalid:
@@ -142,7 +142,7 @@ public:
 	void				Set(const Type &inResult)					{ Clear(); ::new (&mResult) Type(inResult); mState = EState::Valid; }
 
 	/// Set the result value (move value)
-	void				Set(const Type &&inResult)					{ Clear(); ::new (&mResult) Type(move(inResult)); mState = EState::Valid; }
+	void				Set(const Type &&inResult)					{ Clear(); ::new (&mResult) Type(std::move(inResult)); mState = EState::Valid; }
 
 	/// Check if we had an error
 	bool				HasError() const							{ return mState == EState::Error; }
@@ -153,7 +153,7 @@ public:
 	/// Set an error value
 	void				SetError(const char *inError)				{ Clear(); ::new (&mError) String(inError); mState = EState::Error; }
 	void				SetError(const string_view &inError)		{ Clear(); ::new (&mError) String(inError); mState = EState::Error; }
-	void				SetError(String &&inError)					{ Clear(); ::new (&mError) String(move(inError)); mState = EState::Error; }
+	void				SetError(String &&inError)					{ Clear(); ::new (&mError) String(std::move(inError)); mState = EState::Error; }
 
 private:
 	union

Jolt/Core/STLAllocator.h

@@ -72,14 +72,14 @@ public:
 
 #else
 
-template <typename T> using STLAllocator = allocator<T>;
+template <typename T> using STLAllocator = std::allocator<T>;
 
 #endif // !JPH_DISABLE_CUSTOM_ALLOCATOR
 
 // Declare STL containers that use our allocator
-template <class T> using Array = vector<T, STLAllocator<T>>;
-using String = basic_string<char, char_traits<char>, STLAllocator<char>>;
-using IStringStream = basic_istringstream<char, char_traits<char>, STLAllocator<char>>;
+template <class T> using Array = std::vector<T, STLAllocator<T>>;
+using String = std::basic_string<char, std::char_traits<char>, STLAllocator<char>>;
+using IStringStream = std::basic_istringstream<char, std::char_traits<char>, STLAllocator<char>>;
 
 JPH_NAMESPACE_END
 

Jolt/Core/StaticArray.h

@@ -18,10 +18,10 @@ public:
 						StaticArray() = default;
 
 	/// Constructor from initializer list
-	explicit			StaticArray(initializer_list<T> inList)
+	explicit			StaticArray(std::initializer_list<T> inList)
 	{
 		JPH_ASSERT(inList.size() <= N);
-		for (typename initializer_list<T>::iterator i = inList.begin(); i != inList.end(); ++i)
+		for (typename std::initializer_list<T>::iterator i = inList.begin(); i != inList.end(); ++i)
 			::new (reinterpret_cast<T *>(&mElements[mSize++])) T(*i);
 	}
 
@@ -64,7 +64,7 @@ public:
 	void				emplace_back(A &&... inElement)
 	{	
 		JPH_ASSERT(mSize < N);
-		::new (&mElements[mSize++]) T(forward<A>(inElement)...);
+		::new (&mElements[mSize++]) T(std::forward<A>(inElement)...);
 	}
 
 	/// Remove element from the back of the array

Jolt/Core/StreamIn.h

@@ -30,7 +30,7 @@ public:
 	
 	/// Read a vector of primitives from the binary stream
 	template <class T, class A>
-	void				Read(vector<T, A> &outT)
+	void				Read(std::vector<T, A> &outT)
 	{
 		typename Array<T>::size_type len = outT.size(); // Initialize to previous array size, this is used for validation in the StateRecorder class
 		Read(len);
@@ -46,9 +46,9 @@ public:
 
 	/// Read a string from the binary stream (reads the number of characters and then the characters)
 	template <class Type, class Traits, class Allocator>
-	void				Read(basic_string<Type, Traits, Allocator> &outString)
+	void				Read(std::basic_string<Type, Traits, Allocator> &outString)
 	{
-		typename basic_string<Type, Traits, Allocator>::size_type len = 0;
+		typename std::basic_string<Type, Traits, Allocator>::size_type len = 0;
 		Read(len);
 		if (!IsEOF() && !IsFailed())
 		{

Jolt/Core/StreamOut.h

@@ -27,7 +27,7 @@ public:
 
 	/// Write a vector of primitives from the binary stream
 	template <class T, class A>
-	void				Write(const vector<T, A> &inT)
+	void				Write(const std::vector<T, A> &inT)
 	{
 		typename Array<T>::size_type len = inT.size();
 		Write(len);
@@ -38,9 +38,9 @@ public:
 
 	/// Write a string to the binary stream (writes the number of characters and then the characters)
 	template <class Type, class Traits, class Allocator>
-	void				Write(const basic_string<Type, Traits, Allocator> &inString)
+	void				Write(const std::basic_string<Type, Traits, Allocator> &inString)
 	{
-		typename basic_string<Type, Traits, Allocator>::size_type len = inString.size();
+		typename std::basic_string<Type, Traits, Allocator>::size_type len = inString.size();
 		Write(len);
 		if (!IsFailed())
 			WriteBytes(inString.data(), len * sizeof(Type));

Jolt/Core/StringTools.h

@@ -13,7 +13,7 @@ String StringFormat(const char *inFMT, ...);
 template<typename T>
 String ConvertToString(const T &inValue)
 {
-	using OStringStream = basic_ostringstream<char, char_traits<char>, STLAllocator<char>>;
+	using OStringStream = std::basic_ostringstream<char, std::char_traits<char>, STLAllocator<char>>;
     OStringStream oss;
     oss << inValue;
     return oss.str();

Jolt/Core/TickCounter.cpp

@@ -59,7 +59,7 @@ static const uint64 sProcessorTicksPerSecond = []() {
 	return JPH_PLATFORM_BLUE_GET_TICK_FREQUENCY();
 #elif defined(JPH_PLATFORM_LINUX) || defined(JPH_PLATFORM_ANDROID) 
 	// Open /proc/cpuinfo
-    ifstream ifs("/proc/cpuinfo");
+    std::ifstream ifs("/proc/cpuinfo");
     if (ifs.is_open())
 	{
 		// Read all lines

Jolt/Core/UnorderedMap.h

@@ -9,6 +9,6 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
-template <class Key, class T, class Hash = hash<Key>, class KeyEqual = equal_to<Key>> using UnorderedMap = unordered_map<Key, T, Hash, KeyEqual, STLAllocator<pair<const Key, T>>>;
+template <class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>> using UnorderedMap = std::unordered_map<Key, T, Hash, KeyEqual, STLAllocator<pair<const Key, T>>>;
 
 JPH_NAMESPACE_END

Jolt/Core/UnorderedSet.h

@@ -9,6 +9,6 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
-template <class Key, class Hash = hash<Key>, class KeyEqual = equal_to<Key>> using UnorderedSet = unordered_set<Key, Hash, KeyEqual, STLAllocator<Key>>;
+template <class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>> using UnorderedSet = std::unordered_set<Key, Hash, KeyEqual, STLAllocator<Key>>;
 
 JPH_NAMESPACE_END

Jolt/Geometry/ConvexHullBuilder.cpp

@@ -1448,14 +1448,14 @@ void ConvexHullBuilder::DumpShape() const
 	static atomic<int> sShapeNo = 1;
 	int shape_no = sShapeNo++;
 
-	ofstream f;
-	f.open(StringFormat("dumped_shape%d.cpp", shape_no).c_str(), ofstream::out | ofstream::trunc);
+	std::ofstream f;
+	f.open(StringFormat("dumped_shape%d.cpp", shape_no).c_str(), std::ofstream::out | std::ofstream::trunc);
 	if (!f.is_open()) 
 		return;
 
 	f << "{\n";
 	for (Vec3 v : mPositions)
-		f << StringFormat("\tVec3(%.9gf, %.9gf, %.9gf),\n", v.GetX(), v.GetY(), v.GetZ());
+		f << StringFormat("\tVec3(%.9gf, %.9gf, %.9gf),\n", (double)v.GetX(), (double)v.GetY(), (double)v.GetZ());
 	f << "},\n";
 }
 

Jolt/Geometry/EPAConvexHullBuilder.h

@@ -196,7 +196,7 @@ public:
 			inT->mInQueue = true;
 
 			// Resort heap
-			push_heap(begin(), end(), sTriangleSorter);
+			std::push_heap(begin(), end(), sTriangleSorter);
 		}
 
 		/// Peek the next closest triangle without removing it
@@ -209,7 +209,7 @@ public:
 		Triangle *		PopClosest()
 		{
 			// Move largest to end
-			pop_heap(begin(), end(), sTriangleSorter);
+			std::pop_heap(begin(), end(), sTriangleSorter);
 
 			// Remove last triangle
 			Triangle *t = back();
@@ -372,7 +372,7 @@ public:
 
 #if defined(JPH_EPA_CONVEX_BUILDER_VALIDATE) || defined(JPH_EPA_CONVEX_BUILDER_DRAW)
 		// Remove from list of all triangles
-		Triangles::iterator i = find(mTriangles.begin(), mTriangles.end(), inT);
+		Triangles::iterator i = std::find(mTriangles.begin(), mTriangles.end(), inT);
 		JPH_ASSERT(i != mTriangles.end());
 		mTriangles.erase(i);
 #endif

Jolt/Geometry/GJKClosestPoint.h

@@ -34,7 +34,7 @@ private:
 	{
 #ifdef JPH_GJK_DEBUG
 		for (int i = 0; i < mNumPoints; ++i)
-			Trace("y[%d] = [%s], |y[%d]| = %g", i, ConvertToString(mY[i]).c_str(), i, mY[i].Length());
+			Trace("y[%d] = [%s], |y[%d]| = %g", i, ConvertToString(mY[i]).c_str(), i, (double)mY[i].Length());
 #endif
 
 		uint32 set;
@@ -69,7 +69,7 @@ private:
 		}
 
 #ifdef JPH_GJK_DEBUG
- 		Trace("GetClosest: set = 0b%s, v = [%s], |v| = %g", NibbleToBinary(set), ConvertToString(v).c_str(), v.Length());
+ 		Trace("GetClosest: set = 0b%s, v = [%s], |v| = %g", NibbleToBinary(set), ConvertToString(v).c_str(), (double)v.Length());
 #endif
 
 		float v_len_sq = v.LengthSq();
@@ -434,7 +434,7 @@ public:
 
 			// If v is very small compared to the length of y, we also consider this a collision
 #ifdef JPH_GJK_DEBUG
-			Trace("Check v small compared to y: %g <= %g", v_len_sq, FLT_EPSILON * GetMaxYLengthSq());
+			Trace("Check v small compared to y: %g <= %g", (double)v_len_sq, (double)(FLT_EPSILON * GetMaxYLengthSq()));
 #endif
 			if (v_len_sq <= FLT_EPSILON * GetMaxYLengthSq())
 			{
@@ -452,7 +452,7 @@ public:
 
 			// If the squared length of v is not changing enough, we've converged and there is no collision
 #ifdef JPH_GJK_DEBUG
-			Trace("Check v not changing enough: %g <= %g", prev_v_len_sq - v_len_sq, FLT_EPSILON * prev_v_len_sq);
+			Trace("Check v not changing enough: %g <= %g", (double)(prev_v_len_sq - v_len_sq), (double)(FLT_EPSILON * prev_v_len_sq));
 #endif
 			JPH_ASSERT(prev_v_len_sq >= v_len_sq);
 			if (prev_v_len_sq - v_len_sq <= FLT_EPSILON * prev_v_len_sq)
@@ -470,7 +470,7 @@ public:
 		CalculatePointAAndB(outPointA, outPointB);
 
 #ifdef JPH_GJK_DEBUG
-		Trace("Return: v = [%s], |v| = %g", ConvertToString(ioV).c_str(), ioV.Length());
+		Trace("Return: v = [%s], |v| = %g", ConvertToString(ioV).c_str(), (double)ioV.Length());
 
 		// Draw -ioV to show the closest point to the origin from the previous simplex
 		DebugRenderer::sInstance->DrawArrow(mOffset, mOffset - ioV, Color::sOrange, 0.05f);
@@ -539,14 +539,14 @@ public:
 
 			float v_dot_w = v.Dot(w);
 #ifdef JPH_GJK_DEBUG
-			Trace("v . w = %g", v_dot_w);
+			Trace("v . w = %g", (double)v_dot_w);
 #endif
 			if (v_dot_w > 0.0f)
 			{
 				// If ray and normal are in the same direction, we've passed A and there's no collision
 				float v_dot_r = v.Dot(inRayDirection);
 #ifdef JPH_GJK_DEBUG
-				Trace("v . r = %g", v_dot_r);
+				Trace("v . r = %g", (double)v_dot_r);
 #endif
 				if (v_dot_r >= 0.0f)
 					return false;
@@ -556,7 +556,7 @@ public:
 				float old_lambda = lambda;
 				lambda -= delta;
 #ifdef JPH_GJK_DEBUG
-				Trace("lambda = %g, delta = %g", lambda, delta);
+				Trace("lambda = %g, delta = %g", (double)lambda, (double)delta);
 #endif
 
 				// If lambda didn't change, we cannot converge any further and we assume a hit
@@ -743,14 +743,14 @@ public:
 			// So to v . w we have to add: v . (-(inConvexRadiusA + inConvexRadiusB) * v / |v|) = -(inConvexRadiusA + inConvexRadiusB) * |v|
 			float v_dot_w = v.Dot(w) - sum_convex_radius * v.Length();
 #ifdef JPH_GJK_DEBUG
-			Trace("v . w = %g", v_dot_w);
+			Trace("v . w = %g", (double)v_dot_w);
 #endif
 			if (v_dot_w > 0.0f)
 			{
 				// If ray and normal are in the same direction, we've passed A and there's no collision
 				float v_dot_r = v.Dot(inDirection);
 #ifdef JPH_GJK_DEBUG
-				Trace("v . r = %g", v_dot_r);
+				Trace("v . r = %g", (double)v_dot_r);
 #endif
 				if (v_dot_r >= 0.0f)
 					return false;
@@ -760,7 +760,7 @@ public:
 				float old_lambda = lambda;
 				lambda -= delta;
 #ifdef JPH_GJK_DEBUG
-				Trace("lambda = %g, delta = %g", lambda, delta);
+				Trace("lambda = %g, delta = %g", (double)lambda, (double)delta);
 #endif
 
 				// If lambda didn't change, we cannot converge any further and we assume a hit

Jolt/Math/Quat.inl

@@ -141,10 +141,10 @@ Quat Quat::sFromTo(Vec3Arg inFrom, Vec3Arg inTo)
 template <class Random>
 Quat Quat::sRandom(Random &inRandom)
 {
-	uniform_real_distribution<float> zero_to_one(0.0f, 1.0f);
+	std::uniform_real_distribution<float> zero_to_one(0.0f, 1.0f);
 	float x0 = zero_to_one(inRandom);
 	float r1 = sqrt(1.0f - x0), r2 = sqrt(x0);
-	uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
+	std::uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
 	Vec4 s, c;
 	Vec4(zero_to_two_pi(inRandom), zero_to_two_pi(inRandom), 0, 0).SinCos(s, c);
 	return Quat(s.GetX() * r1, c.GetX() * r1, s.GetY() * r2, c.GetY() * r2);

Jolt/Math/Vec3.cpp

@@ -8,7 +8,7 @@
 
 JPH_NAMESPACE_BEGIN
 
-static void sCreateVertices(unordered_set<Vec3> &ioVertices, Vec3Arg inDir1, Vec3Arg inDir2, Vec3Arg inDir3, int inLevel)
+static void sCreateVertices(std::unordered_set<Vec3> &ioVertices, Vec3Arg inDir1, Vec3Arg inDir2, Vec3Arg inDir3, int inLevel)
 {
 	Vec3 center1 = (inDir1 + inDir2).Normalized();
 	Vec3 center2 = (inDir2 + inDir3).Normalized();
@@ -28,11 +28,11 @@ static void sCreateVertices(unordered_set<Vec3> &ioVertices, Vec3Arg inDir1, Vec
 	}
 }
 
-const vector<Vec3> Vec3::sUnitSphere = []() { 
+const std::vector<Vec3> Vec3::sUnitSphere = []() { 
 
 	const int level = 3;
 
-	unordered_set<Vec3> verts;
+	std::unordered_set<Vec3> verts;
 	
 	// Add unit axis
 	verts.insert(Vec3::sAxisX());
@@ -52,7 +52,7 @@ const vector<Vec3> Vec3::sUnitSphere = []() {
 	sCreateVertices(verts, Vec3::sAxisX(), -Vec3::sAxisY(), -Vec3::sAxisZ(), level);
 	sCreateVertices(verts, -Vec3::sAxisX(), -Vec3::sAxisY(), -Vec3::sAxisZ(), level);
 
-	return vector<Vec3>(verts.begin(), verts.end());
+	return std::vector<Vec3>(verts.begin(), verts.end());
 }();
 
 JPH_NAMESPACE_END

Jolt/Math/Vec3.h

@@ -99,7 +99,7 @@ public:
 	static JPH_INLINE Vec3		sUnitSpherical(float inTheta, float inPhi);
 
 	/// A set of vectors uniformly spanning the surface of a unit sphere, usable for debug purposes
-	static const vector<Vec3>	sUnitSphere;
+	static const std::vector<Vec3> sUnitSphere;
 
 	/// Get random unit vector
 	template <class Random>

Jolt/Math/Vec3.inl

@@ -327,7 +327,7 @@ Vec3 Vec3::sUnitSpherical(float inTheta, float inPhi)
 template <class Random>
 Vec3 Vec3::sRandom(Random &inRandom)
 {
-	uniform_real_distribution<float> zero_to_one(0.0f, 1.0f);
+	std::uniform_real_distribution<float> zero_to_one(0.0f, 1.0f);
 	float theta = JPH_PI * zero_to_one(inRandom);
 	float phi = 2.0f * JPH_PI * zero_to_one(inRandom);
 	return sUnitSpherical(theta, phi);

Jolt/ObjectStream/ObjectStreamIn.h

@@ -53,8 +53,8 @@ public:
 	template <class T>
 	static bool sReadObject(const char *inFileName, T *&outObject)
 	{
-		ifstream stream;
-		stream.open(inFileName, ifstream::in | ifstream::binary);
+		std::ifstream stream;
+		stream.open(inFileName, std::ifstream::in | std::ifstream::binary);
 		if (!stream.is_open()) 
 			return false;
 		return sReadObject(stream, outObject);

Jolt/ObjectStream/ObjectStreamOut.h

@@ -15,7 +15,7 @@ JPH_SUPPRESS_WARNINGS_STD_END
 
 JPH_NAMESPACE_BEGIN
 
-template <class T> using Queue = queue<T, deque<T, STLAllocator<T>>>;
+template <class T> using Queue = std::queue<T, std::deque<T, STLAllocator<T>>>;
 
 /// ObjectStreamOut contains all logic for writing an object to disk. It is the base 
 /// class for the text and binary output streams (ObjectStreamTextOut and ObjectStreamBinaryOut).
@@ -46,8 +46,8 @@ public:
 	template <class T>
 	static bool	sWriteObject(const char *inFileName, ObjectStream::EStreamType inType, const T &inObject)
 	{
-		ofstream stream;
-		stream.open(inFileName, ofstream::out | ofstream::trunc | ofstream::binary);
+		std::ofstream stream;
+		stream.open(inFileName, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
 		if (!stream.is_open()) 
 			return false;
 		return sWriteObject(stream, inType, inObject);

Jolt/ObjectStream/ObjectStreamTextOut.cpp

@@ -53,37 +53,37 @@ void ObjectStreamTextOut::WriteIdentifier(Identifier inIdentifier)
 
 void ObjectStreamTextOut::WriteCount(uint32 inCount)
 {
-	WriteWord(to_string(inCount));
+	WriteWord(std::to_string(inCount));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const uint8 &inPrimitive)
 {
-	WriteWord(to_string(inPrimitive));
+	WriteWord(std::to_string(inPrimitive));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const uint16 &inPrimitive)
 {
-	WriteWord(to_string(inPrimitive));
+	WriteWord(std::to_string(inPrimitive));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const int &inPrimitive)
 {
-	WriteWord(to_string(inPrimitive));
+	WriteWord(std::to_string(inPrimitive));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const uint32 &inPrimitive)
 {
-	WriteWord(to_string(inPrimitive));
+	WriteWord(std::to_string(inPrimitive));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const uint64 &inPrimitive)
 {
-	WriteWord(to_string(inPrimitive));
+	WriteWord(std::to_string(inPrimitive));
 }
 
 void ObjectStreamTextOut::WritePrimitiveData(const float &inPrimitive)
 {
-	ostringstream stream;
+	std::ostringstream stream;
 	stream.precision(9);
 	stream << inPrimitive;
 	WriteWord(stream.str());

Jolt/Physics/Character/CharacterVirtual.cpp

@@ -390,7 +390,7 @@ void CharacterVirtual::SolveConstraints(Vec3Arg inVelocity, float inDeltaTime, f
 	}
 
 	// Create array that holds the constraints in order of time of impact (sort will happen later)
-	vector<Constraint *, STLTempAllocator<Constraint *>> sorted_constraints(inAllocator);
+	std::vector<Constraint *, STLTempAllocator<Constraint *>> sorted_constraints(inAllocator);
 	sorted_constraints.resize(ioConstraints.size());
 	for (size_t index = 0; index < sorted_constraints.size(); index++)
 		sorted_constraints[index] = &ioConstraints[index];
@@ -406,7 +406,7 @@ void CharacterVirtual::SolveConstraints(Vec3Arg inVelocity, float inDeltaTime, f
 	outTimeSimulated = 0.0f;
 
 	// These are the contacts that we hit previously without moving a significant distance
-	vector<Constraint *, STLTempAllocator<Constraint *>> previous_contacts(inAllocator);
+	std::vector<Constraint *, STLTempAllocator<Constraint *>> previous_contacts(inAllocator);
 	previous_contacts.resize(mMaxConstraintIterations);
 	int num_previous_contacts = 0;
 

Jolt/Physics/Character/CharacterVirtual.h

@@ -182,7 +182,7 @@ public:
 		Vec3Arg							mWalkStairsStepUp { 0, 0.4f, 0 };										///< See WalkStairs inStepUp parameter. Can be zero to turn off.
 		float							mWalkStairsMinStepForward { 0.02f };									///< See WalkStairs inStepForward parameter. Note that the parameter only indicates a magnitude, direction is taken from current velocity.
 		float							mWalkStairsStepForwardTest { 0.15f };									///< See WalkStairs inStepForwardTest parameter. Note that the parameter only indicates a magnitude, direction is taken from current velocity.
-		float							mWalkStairsCosAngleForwardContact { cos(DegreesToRadians(75.0f)) };		///< Cos(angle) where angle is the maximum angle between the ground normal in the horizontal plane and the character forward vector where we're willing to adjust the step forward test towards the contact normal.
+		float							mWalkStairsCosAngleForwardContact { Cos(DegreesToRadians(75.0f)) };		///< Cos(angle) where angle is the maximum angle between the ground normal in the horizontal plane and the character forward vector where we're willing to adjust the step forward test towards the contact normal.
 		Vec3Arg							mWalkStairsStepDownExtra { Vec3::sZero() };								///< See WalkStairs inStepDownExtra
 	};
 
@@ -254,7 +254,7 @@ private:
 		bool							mCanPushCharacter = true;								///< When true, the velocity of the contact point can push the character
 	};
 
-	using TempContactList = vector<Contact, STLTempAllocator<Contact>>;
+	using TempContactList = std::vector<Contact, STLTempAllocator<Contact>>;
 	using ContactList = Array<Contact>;
 
 	// A contact that needs to be ignored
@@ -267,7 +267,7 @@ private:
 		SubShapeID						mSubShapeID;											///< Sub shape of body we're colliding with
 	};
 
-	using IgnoredContactList = vector<IgnoredContact, STLTempAllocator<IgnoredContact>>;
+	using IgnoredContactList = std::vector<IgnoredContact, STLTempAllocator<IgnoredContact>>;
 
 	// A constraint that limits the movement of the character
 	struct Constraint
@@ -279,7 +279,7 @@ private:
 		Plane							mPlane;													///< Plane around the origin that describes how far we can displace (from the origin)
 	};
 
-	using ConstraintList = vector<Constraint, STLTempAllocator<Constraint>>;
+	using ConstraintList = std::vector<Constraint, STLTempAllocator<Constraint>>;
 
 	// Collision collector that collects hits for CollideShape
 	class ContactCollector : public CollideShapeCollector

Jolt/Physics/Collision/BroadPhase/BroadPhaseQuadTree.cpp

@@ -169,7 +169,7 @@ BroadPhase::AddState BroadPhaseQuadTree::AddBodiesPrepare(BodyID *ioBodies, int
 		JPH_ASSERT(broadphase_layer < mNumLayers);
 
 		// Find first body with different layer
-		BodyID *b_mid = upper_bound(b_start, b_end, broadphase_layer, [bodies_ptr](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < (BroadPhaseLayer::Type)bodies_ptr[inBodyID.GetIndex()]->GetBroadPhaseLayer(); });
+		BodyID *b_mid = std::upper_bound(b_start, b_end, broadphase_layer, [bodies_ptr](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < (BroadPhaseLayer::Type)bodies_ptr[inBodyID.GetIndex()]->GetBroadPhaseLayer(); });
 
 		// Keep track of state for this layer
 		LayerState &layer_state = state[broadphase_layer];
@@ -293,7 +293,7 @@ void BroadPhaseQuadTree::RemoveBodies(BodyID *ioBodies, int inNumber)
 		JPH_ASSERT(broadphase_layer != (BroadPhaseLayer::Type)cBroadPhaseLayerInvalid);
 
 		// Find first body with different layer
-		BodyID *b_mid = upper_bound(b_start, b_end, broadphase_layer, [tracking](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mBroadPhaseLayer; });
+		BodyID *b_mid = std::upper_bound(b_start, b_end, broadphase_layer, [tracking](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mBroadPhaseLayer; });
 
 		// Remove all bodies of the same layer
 		mLayers[broadphase_layer].RemoveBodies(bodies, mTracking, b_start, int(b_mid - b_start));
@@ -343,7 +343,7 @@ void BroadPhaseQuadTree::NotifyBodiesAABBChanged(BodyID *ioBodies, int inNumber,
 		JPH_ASSERT(broadphase_layer != (BroadPhaseLayer::Type)cBroadPhaseLayerInvalid);
 
 		// Find first body with different layer
-		BodyID *b_mid = upper_bound(b_start, b_end, broadphase_layer, [tracking](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mBroadPhaseLayer; });
+		BodyID *b_mid = std::upper_bound(b_start, b_end, broadphase_layer, [tracking](BroadPhaseLayer::Type inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mBroadPhaseLayer; });
 
 		// Nodify all bodies of the same layer changed
 		mLayers[broadphase_layer].NotifyBodiesAABBChanged(bodies, mTracking, b_start, int(b_mid - b_start));
@@ -556,7 +556,7 @@ void BroadPhaseQuadTree::FindCollidingPairs(BodyID *ioActiveBodies, int inNumAct
 		JPH_ASSERT(object_layer != cObjectLayerInvalid);
 
 		// Find first body with different layer
-		BodyID *b_mid = upper_bound(b_start, b_end, object_layer, [tracking](ObjectLayer inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mObjectLayer; });
+		BodyID *b_mid = std::upper_bound(b_start, b_end, object_layer, [tracking](ObjectLayer inLayer, BodyID inBodyID) { return inLayer < tracking[inBodyID.GetIndex()].mObjectLayer; });
 
 		// Loop over all layers and test the ones that could hit
 		for (BroadPhaseLayer::Type l = 0; l < mNumLayers; ++l)

Jolt/Physics/Collision/BroadPhase/QuadTree.cpp

@@ -13,6 +13,10 @@
 #include <Jolt/Geometry/RayAABox.h>
 #include <Jolt/Geometry/OrientedBox.h>
 
+#ifdef JPH_DUMP_BROADPHASE_TREE
+#include <fstream>
+#endif // JPH_DUMP_BROADPHASE_TREE
+
 JPH_NAMESPACE_BEGIN
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1529,8 +1533,8 @@ void QuadTree::ValidateTree(const BodyVector &inBodies, const TrackingVector &in
 void QuadTree::DumpTree(const NodeID &inRoot, const char *inFileNamePrefix) const
 {
 	// Open DOT file
-	ofstream f;
-	f.open(StringFormat("%s.dot", inFileNamePrefix), ofstream::out | ofstream::trunc);
+	std::ofstream f;
+	f.open(StringFormat("%s.dot", inFileNamePrefix).c_str(), std::ofstream::out | std::ofstream::trunc);
 	if (!f.is_open())
 		return;
 

Jolt/Physics/Collision/Shape/CapsuleShape.cpp

@@ -31,20 +31,20 @@ JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(CapsuleShapeSettings)
 
 static const int cCapsuleDetailLevel = 2;
 
-static const vector<Vec3> sCapsuleTopTriangles = []() { 
-	vector<Vec3> verts;	
+static const std::vector<Vec3> sCapsuleTopTriangles = []() { 
+	std::vector<Vec3> verts;	
 	GetTrianglesContextVertexList::sCreateHalfUnitSphereTop(verts, cCapsuleDetailLevel);
 	return verts;
 }();
 
-static const vector<Vec3> sCapsuleMiddleTriangles = []() { 
-	vector<Vec3> verts;
+static const std::vector<Vec3> sCapsuleMiddleTriangles = []() { 
+	std::vector<Vec3> verts;
 	GetTrianglesContextVertexList::sCreateUnitOpenCylinder(verts, cCapsuleDetailLevel);
 	return verts;
 }();
 
-static const vector<Vec3> sCapsuleBottomTriangles = []() { 
-	vector<Vec3> verts;	
+static const std::vector<Vec3> sCapsuleBottomTriangles = []() { 
+	std::vector<Vec3> verts;	
 	GetTrianglesContextVertexList::sCreateHalfUnitSphereBottom(verts, cCapsuleDetailLevel);
 	return verts;
 }();

Jolt/Physics/Collision/Shape/ConvexShape.cpp

@@ -32,10 +32,10 @@ JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(ConvexShapeSettings)
 	JPH_ADD_ATTRIBUTE(ConvexShapeSettings, mMaterial)
 }
 
-const vector<Vec3> ConvexShape::sUnitSphereTriangles = []() { 
+const std::vector<Vec3> ConvexShape::sUnitSphereTriangles = []() { 
 	const int level = 2;
 
-	vector<Vec3> verts;	
+	std::vector<Vec3> verts;	
 	GetTrianglesContextVertexList::sCreateHalfUnitSphereTop(verts, level);
 	GetTrianglesContextVertexList::sCreateHalfUnitSphereBottom(verts, level);
 	return verts;

Jolt/Physics/Collision/Shape/ConvexShape.h

@@ -130,7 +130,7 @@ protected:
 	virtual void					RestoreBinaryState(StreamIn &inStream) override;
 
 	/// Vertex list that forms a unit sphere
-	static const vector<Vec3>		sUnitSphereTriangles;
+	static const std::vector<Vec3>	sUnitSphereTriangles;
 
 private:
 	// Class for GetTrianglesStart/Next

Jolt/Physics/Collision/Shape/CylinderShape.cpp

@@ -43,8 +43,8 @@ static const Vec3 cTopFace[] =
 	Vec3(-cSin45,	1.0f,	cSin45)
 };
 
-static const vector<Vec3> sUnitCylinderTriangles = []() { 
-	vector<Vec3> verts;
+static const std::vector<Vec3> sUnitCylinderTriangles = []() { 
+	std::vector<Vec3> verts;
 
 	const Vec3 bottom_offset(0.0f, -2.0f, 0.0f);
 

Jolt/Physics/Collision/Shape/GetTrianglesContext.h

@@ -67,7 +67,7 @@ public:
 	}
 
 	/// Helper function that creates a vertex list of a half unit sphere (top part)
-	static void		sCreateHalfUnitSphereTop(vector<Vec3> &ioVertices, int inDetailLevel)
+	static void		sCreateHalfUnitSphereTop(std::vector<Vec3> &ioVertices, int inDetailLevel)
 	{
 		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisX(),  Vec3::sAxisY(),  Vec3::sAxisZ(), inDetailLevel);
 		sCreateUnitSphereHelper(ioVertices,  Vec3::sAxisY(), -Vec3::sAxisX(),  Vec3::sAxisZ(), inDetailLevel);
@@ -76,7 +76,7 @@ public:
 	}
 
 	/// Helper function that creates a vertex list of a half unit sphere (bottom part)
-	static void		sCreateHalfUnitSphereBottom(vector<Vec3> &ioVertices, int inDetailLevel)
+	static void		sCreateHalfUnitSphereBottom(std::vector<Vec3> &ioVertices, int inDetailLevel)
 	{
 		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisX(), -Vec3::sAxisY(),  Vec3::sAxisZ(), inDetailLevel);
 		sCreateUnitSphereHelper(ioVertices, -Vec3::sAxisY(),  Vec3::sAxisX(),  Vec3::sAxisZ(), inDetailLevel);
@@ -85,7 +85,7 @@ public:
 	}
 
 	/// Helper function that creates an open cyclinder of half height 1 and radius 1
-	static void		sCreateUnitOpenCylinder(vector<Vec3> &ioVertices, int inDetailLevel)
+	static void		sCreateUnitOpenCylinder(std::vector<Vec3> &ioVertices, int inDetailLevel)
 	{
 		const Vec3 bottom_offset(0.0f, -2.0f, 0.0f);
 		int num_verts = 4 * (1 << inDetailLevel);
@@ -111,7 +111,7 @@ public:
 
 private:
 	/// Recursive helper function for creating a sphere
-	static void		sCreateUnitSphereHelper(vector<Vec3> &ioVertices, Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, int inLevel)
+	static void		sCreateUnitSphereHelper(std::vector<Vec3> &ioVertices, Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, int inLevel)
 	{
 		Vec3 center1 = (inV1 + inV2).Normalized();
 		Vec3 center2 = (inV2 + inV3).Normalized();

Jolt/Physics/DeterminismLog.h

@@ -26,7 +26,7 @@ private:
 public:
 							DeterminismLog()
 	{
-		mLog.open("detlog.txt", ios::out | ios::trunc | ios::binary); // Binary because we don't want a difference between Unix and Windows line endings.
+		mLog.open("detlog.txt", std::ios::out | std::ios::trunc | std::ios::binary); // Binary because we don't want a difference between Unix and Windows line endings.
 		mLog.fill('0');
 	}
 
@@ -38,31 +38,31 @@ public:
 
 	DeterminismLog &		operator << (const char *inValue)
 	{
-		mLog << dec << inValue;
+		mLog << std::dec << inValue;
 		return *this;
 	}
 
 	DeterminismLog &		operator << (const string &inValue)
 	{
-		mLog << dec << inValue;
+		mLog << std::dec << inValue;
 		return *this;
 	}
 
 	DeterminismLog &		operator << (const BodyID &inValue)
 	{
-		mLog << hex << setw(8) << inValue.GetIndexAndSequenceNumber();
+		mLog << std::hex << std::setw(8) << inValue.GetIndexAndSequenceNumber();
 		return *this;
 	}
 
 	DeterminismLog &		operator << (const SubShapeID &inValue)
 	{
-		mLog << hex << setw(8) << inValue.GetValue();
+		mLog << std::hex << std::setw(8) << inValue.GetValue();
 		return *this;
 	}
 
 	DeterminismLog &		operator << (float inValue)
 	{
-		mLog << hex << setw(8) << Convert(inValue);
+		mLog << std::hex << std::setw(8) << Convert(inValue);
 		return *this;
 	}
 
@@ -74,31 +74,31 @@ public:
 
 	DeterminismLog &		operator << (uint32 inValue)
 	{
-		mLog << hex << setw(8) << inValue;
+		mLog << std::hex << std::setw(8) << inValue;
 		return *this;
 	}
 
 	DeterminismLog &		operator << (uint64 inValue)
 	{
-		mLog << hex << setw(16) << inValue;
+		mLog << std::hex << std::setw(16) << inValue;
 		return *this;
 	}
 
 	DeterminismLog &		operator << (Vec3Arg inValue)
 	{
-		mLog << hex << setw(8) << Convert(inValue.GetX()) << " " << setw(8) << Convert(inValue.GetY()) << " " << setw(8) << Convert(inValue.GetZ());
+		mLog << std::hex << std::setw(8) << Convert(inValue.GetX()) << " " << std::setw(8) << Convert(inValue.GetY()) << " " << std::setw(8) << Convert(inValue.GetZ());
 		return *this;
 	}
 	
 	DeterminismLog &		operator << (Vec4Arg inValue)
 	{
-		mLog << hex << setw(8) << Convert(inValue.GetX()) << " " << setw(8) << Convert(inValue.GetY()) << " " << setw(8) << Convert(inValue.GetZ()) << " " << setw(8) << Convert(inValue.GetW());
+		mLog << std::hex << std::setw(8) << Convert(inValue.GetX()) << " " << std::setw(8) << Convert(inValue.GetY()) << " " << std::setw(8) << Convert(inValue.GetZ()) << " " << std::setw(8) << Convert(inValue.GetW());
 		return *this;
 	}
 	
 	DeterminismLog &		operator << (const Float3 &inValue)
 	{
-		mLog << hex << setw(8) << Convert(inValue.x) << " " << setw(8) << Convert(inValue.y) << " " << setw(8) << Convert(inValue.z);
+		mLog << std::hex << std::setw(8) << Convert(inValue.x) << " " << std::setw(8) << Convert(inValue.y) << " " << std::setw(8) << Convert(inValue.z);
 		return *this;
 	}
 	
@@ -118,7 +118,7 @@ public:
 	static DeterminismLog	sLog;
 
 private:
-	ofstream				mLog;
+	std::ofstream			mLog;
 };
 
 /// Will log something to the determinism log, usage: JPH_DET_LOG("label " << value);

Jolt/Physics/IslandBuilder.h

@@ -5,10 +5,7 @@
 
 #include <Jolt/Physics/Body/BodyID.h>
 #include <Jolt/Core/NonCopyable.h>
-
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#include <atomic>
-JPH_SUPPRESS_WARNINGS_STD_END
+#include <Jolt/Core/Atomics.h>
 
 JPH_NAMESPACE_BEGIN
 

Jolt/Physics/PhysicsUpdateContext.h

@@ -146,7 +146,7 @@ public:
 		JobHandle			mStartNextStep;											///< Job that kicks the next step (empty for the last step)
 	};
 
-	using Steps = vector<Step, STLTempAllocator<Step>>;
+	using Steps = std::vector<Step, STLTempAllocator<Step>>;
 
 	/// Maximum amount of concurrent jobs on this machine
 	int						GetMaxConcurrency() const								{ const int max_concurrency = PhysicsUpdateContext::cMaxConcurrency; return min(max_concurrency, mJobSystem->GetMaxConcurrency()); } ///< Need to put max concurrency in temp var as min requires a reference

Jolt/Physics/StateRecorderImpl.cpp

@@ -14,7 +14,7 @@ void StateRecorderImpl::WriteBytes(const void *inData, size_t inNumBytes)
 
 void StateRecorderImpl::Rewind()
 {
-	mStream.seekg(0, stringstream::beg);
+	mStream.seekg(0, std::stringstream::beg);
 }
 
 void StateRecorderImpl::ReadBytes(void *outData, size_t inNumBytes)
@@ -49,14 +49,14 @@ void StateRecorderImpl::ReadBytes(void *outData, size_t inNumBytes)
 bool StateRecorderImpl::IsEqual(StateRecorderImpl &inReference)
 {	
 	// Get length of new state
-	mStream.seekg(0, stringstream::end);
+	mStream.seekg(0, std::stringstream::end);
 	std::streamoff this_len = mStream.tellg();
-	mStream.seekg(0, stringstream::beg);
+	mStream.seekg(0, std::stringstream::beg);
 
 	// Get length of old state
-	inReference.mStream.seekg(0, stringstream::end);
+	inReference.mStream.seekg(0, std::stringstream::end);
 	std::streamoff reference_len = inReference.mStream.tellg();
-	inReference.mStream.seekg(0, stringstream::beg);
+	inReference.mStream.seekg(0, std::stringstream::beg);
 
 	// Compare size
 	bool fail = reference_len != this_len;

Jolt/Physics/StateRecorderImpl.h

@@ -13,7 +13,7 @@ class StateRecorderImpl final : public StateRecorder
 public:
 	/// Constructor
 						StateRecorderImpl() = default;
-						StateRecorderImpl(StateRecorderImpl &&inRHS)				: StateRecorder(inRHS), mStream(move(inRHS.mStream)) { }
+						StateRecorderImpl(StateRecorderImpl &&inRHS)				: StateRecorder(inRHS), mStream(std::move(inRHS.mStream)) { }
 
 	/// Write a string of bytes to the binary stream
 	virtual void		WriteBytes(const void *inData, size_t inNumBytes) override;
@@ -37,7 +37,7 @@ public:
 	string				GetData() const												{ return mStream.str(); }
 
 private:
-	stringstream		mStream;
+	std::stringstream	mStream;
 };
 
 JPH_NAMESPACE_END

Jolt/Skeleton/SkeletonMapper.cpp

@@ -91,7 +91,7 @@ void SkeletonMapper::Initialize(const Skeleton *inSkeleton1, const Mat44 *inNeut
 					mapped2[j2] = true;
 
 				// Insert the chain
-				mChains.emplace_back(move(chain1), move(chain2));
+				mChains.emplace_back(std::move(chain1), std::move(chain2));
 			}
 		}
 	}

Jolt/Skeleton/SkeletonMapper.h

@@ -30,7 +30,7 @@ public:
 	{
 	public:
 							Chain() = default;
-							Chain(Array<int> &&inJointIndices1, Array<int> &&inJointIndices2) : mJointIndices1(move(inJointIndices1)), mJointIndices2(move(inJointIndices2)) { }
+							Chain(Array<int> &&inJointIndices1, Array<int> &&inJointIndices2) : mJointIndices1(std::move(inJointIndices1)), mJointIndices2(std::move(inJointIndices2)) { }
 
 		Array<int>			mJointIndices1;																///< Joint chain from skeleton 1
 		Array<int>			mJointIndices2;																///< Corresponding joint chain from skeleton 2

Jolt/TriangleGrouper/TriangleGrouperClosestCentroid.cpp

@@ -76,7 +76,7 @@ void TriangleGrouperClosestCentroid::Group(const VertexList &inVertices, const I
 				*other = *batch_end_minus_1;
 
 				// Find first element that is bigger than this one and insert the current item before it
-				Array<uint>::iterator upper = upper_bound(batch_begin_plus_1, batch_end, dist, 
+				Array<uint>::iterator upper = std::upper_bound(batch_begin_plus_1, batch_end, dist, 
 					[&first_centroid, &centroids](float inLHS, uint inRHS)
 					{
 						return inLHS < (centroids[inRHS] - first_centroid).LengthSq(); 

Samples/SamplesApp.cpp

@@ -2102,7 +2102,7 @@ void SamplesApp::DrawPhysics()
 	}
 
 	// Replace the map with the newly created map so that shapes that we don't draw / were removed are released
-	mShapeToGeometry = move(shape_to_geometry);
+	mShapeToGeometry = std::move(shape_to_geometry);
 }
 
 void SamplesApp::StepPhysics(JobSystem *inJobSystem)

Samples/Tests/ConvexCollision/ConvexHullShrinkTest.cpp

@@ -107,7 +107,7 @@ void ConvexHullShrinkTest::Initialize()
 					points_stream.read((char *)&v, sizeof(v));
 					p.push_back(Vec3(v));
 				}
-				mPoints.push_back(move(p));
+				mPoints.push_back(std::move(p));
 			}
 		}
 	}

Samples/Tests/ConvexCollision/ConvexHullTest.cpp

@@ -417,7 +417,7 @@ void ConvexHullTest::Initialize()
 			for (int y = 0; y < 10; ++y)
 				for (int z = 0; z < 10; ++z)
 					p.push_back(Vec3::sReplicate(-0.5f) * 0.1f * Vec3(float(x), float(y), float(z)));
-		mPoints.push_back(move(p));
+		mPoints.push_back(std::move(p));
 	}
 
 	// Add disc of many points
@@ -427,7 +427,7 @@ void ConvexHullTest::Initialize()
 		for (float r = 0.0f; r < 2.0f; r += 0.1f)
 			for (float phi = 0.0f; phi <= 2.0f * JPH_PI; phi += 2.0f * JPH_PI / 20.0f)
 				p.push_back(rot * Vec3(r * Cos(phi), r * Sin(phi), 0));
-		mPoints.push_back(move(p));
+		mPoints.push_back(std::move(p));
 	}
 
 	// Add wedge shaped disc that is just above the hull tolerance on its widest side and zero on the other side
@@ -439,7 +439,7 @@ void ConvexHullTest::Initialize()
 			p.push_back(pos);
 			p.push_back(pos + Vec3(0, 2.0e-3f * (2.0f + pos.GetX()) / 4.0f, 0));
 		}
-		mPoints.push_back(move(p));
+		mPoints.push_back(std::move(p));
 	}
 
 	// Add a sphere of many points
@@ -448,7 +448,7 @@ void ConvexHullTest::Initialize()
 		for (float theta = 0.0f; theta <= JPH_PI; theta += JPH_PI / 20.0f)
 			for (float phi = 0.0f; phi <= 2.0f * JPH_PI; phi += 2.0f * JPH_PI / 20.0f)
 				p.push_back(Vec3::sUnitSpherical(theta, phi));
-		mPoints.push_back(move(p));
+		mPoints.push_back(std::move(p));
 	}
 
 	// Open the external file with hulls
@@ -474,7 +474,7 @@ void ConvexHullTest::Initialize()
 					points_stream.read((char *)&v, sizeof(v));
 					p.push_back(Vec3(v));
 				}
-				mPoints.push_back(move(p));
+				mPoints.push_back(std::move(p));
 			}
 		}
 	}

TestFramework/TestFramework.h

@@ -33,3 +33,4 @@ JPH_SUPPRESS_WARNING_POP
 
 using Microsoft::WRL::ComPtr;
 using namespace JPH;
+using namespace std;

UnitTests/Geometry/EPATests.cpp

@@ -53,17 +53,17 @@ TEST_SUITE("EPATests")
 			// Check angle between v1 and v2
 			float angle = AngleBetweenVectors(v1, v2);
 			CHECK(angle < 0.1f);
-			EPA_TESTS_TRACE("Angle = %.9g\n", angle);
+			EPA_TESTS_TRACE("Angle = %.9g\n", (double)angle);
 
 			// Check delta between contact on A
 			Vec3 dpa = pa2 - pa1;
 			CHECK(dpa.Length() < 8.0e-4f);
-			EPA_TESTS_TRACE("Delta A = %.9g\n", dpa.Length());
+			EPA_TESTS_TRACE("Delta A = %.9g\n", (double)dpa.Length());
 
 			// Check delta between contact on B
 			Vec3 dpb = pb2 - pb1;
 			CHECK(dpb.Length() < 8.0e-4f);
-			EPA_TESTS_TRACE("Delta B = %.9g\n", dpb.Length());
+			EPA_TESTS_TRACE("Delta B = %.9g\n", (double)dpb.Length());
 		}
 
 		return intersect1;

UnitTests/UnitTestFramework.h

@@ -12,6 +12,7 @@ JPH_CLANG_SUPPRESS_WARNING("-Wheader-hygiene")
 #include "doctest.h"
 
 using namespace JPH;
+using namespace std;
 
 inline void CHECK_APPROX_EQUAL(float inLHS, float inRHS, float inTolerance = 1.0e-6f)
 {