@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/Core/Reference.h

@@ -1,244 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/Atomics.h>
-
-JPH_NAMESPACE_BEGIN
-
-// Forward declares
-template <class T> class Ref;
-template <class T> class RefConst;
-
-/// Simple class to facilitate reference counting / releasing
-/// Derive your class from RefTarget and you can reference it by using Ref<classname> or RefConst<classname>
-///
-/// Reference counting classes keep an integer which indicates how many references
-/// to the object are active. Reference counting objects are derived from RefTarget
-/// and staT & their life with a reference count of zero. They can then be assigned
-/// to equivalents of pointers (Ref) which will increase the reference count immediately.
-/// If the destructor of Ref is called or another object is assigned to the reference
-/// counting pointer it will decrease the reference count of the object again. If this
-/// reference count becomes zero, the object is destroyed.
-///
-/// This provides a very powerful mechanism to prevent memory leaks, but also gives
-/// some responsibility to the programmer. The most notable point is that you cannot
-/// have one object reference another and have the other reference the first one
-/// back, because this way the reference count of both objects will never become
-/// lower than 1, resulting in a memory leak. By carefully designing your classes
-/// (and particularly identifying who owns who in the class hierarchy) you can avoid
-/// these problems.
-template <class T>
-class RefTarget
-{
-public:
-	/// Constructor
-	inline					RefTarget() = default;
-	inline					RefTarget(const RefTarget &)					{ /* Do not copy refcount */ }
-	inline					~RefTarget()									{ JPH_IF_ENABLE_ASSERTS(uint32 value = mRefCount.load(memory_order_relaxed);) JPH_ASSERT(value == 0 || value == cEmbedded); } ///< assert no one is referencing us
-
-	/// Mark this class as embedded, this means the type can be used in a compound or constructed on the stack.
-	/// The Release function will never destruct the object, it is assumed the destructor will be called by whoever allocated
-	/// the object and at that point in time it is checked that no references are left to the structure.
-	inline void				SetEmbedded() const								{ JPH_IF_ENABLE_ASSERTS(uint32 old = ) mRefCount.fetch_add(cEmbedded, memory_order_relaxed); JPH_ASSERT(old < cEmbedded); }
-
-	/// Assignment operator
-	inline RefTarget &		operator = (const RefTarget &)					{ /* Don't copy refcount */ return *this; }
-
-	/// Get current refcount of this object
-	uint32					GetRefCount() const								{ return mRefCount.load(memory_order_relaxed); }
-
-	/// Add or release a reference to this object
-	inline void				AddRef() const
-	{
-		// Adding a reference can use relaxed memory ordering
-		mRefCount.fetch_add(1, memory_order_relaxed);
-	}
-
-	inline void				Release() const
-	{
-	#ifndef JPH_TSAN_ENABLED
-		// Releasing a reference must use release semantics...
-		if (mRefCount.fetch_sub(1, memory_order_release) == 1)
-		{
-			// ... so that we can use acquire to ensure that we see any updates from other threads that released a ref before deleting the object
-			atomic_thread_fence(memory_order_acquire);
-			delete static_cast<const T *>(this);
-		}
-	#else
-		// But under TSAN, we cannot use atomic_thread_fence, so we use an acq_rel operation unconditionally instead
-		if (mRefCount.fetch_sub(1, memory_order_acq_rel) == 1)
-			delete static_cast<const T *>(this);
-	#endif
-	}
-
-	/// INTERNAL HELPER FUNCTION USED BY SERIALIZATION
-	static int				sInternalGetRefCountOffset()					{ return offsetof(T, mRefCount); }
-
-protected:
-	static constexpr uint32 cEmbedded = 0x0ebedded;							///< A large value that gets added to the refcount to mark the object as embedded
-
-	mutable atomic<uint32>	mRefCount = 0;									///< Current reference count
-};
-
-/// Pure virtual version of RefTarget
-class JPH_EXPORT RefTargetVirtual
-{
-public:
-	/// Virtual destructor
-	virtual					~RefTargetVirtual() = default;
-
-	/// Virtual add reference
-	virtual void			AddRef() = 0;
-
-	/// Virtual release reference
-	virtual void			Release() = 0;
-};
-
-/// Class for automatic referencing, this is the equivalent of a pointer to type T
-/// if you assign a value to this class it will increment the reference count by one
-/// of this object, and if you assign something else it will decrease the reference
-/// count of the first object again. If it reaches a reference count of zero it will
-/// be deleted
-template <class T>
-class Ref
-{
-public:
-	/// Constructor
-	inline					Ref()											: mPtr(nullptr) { }
-	inline					Ref(T *inRHS)									: mPtr(inRHS) { AddRef(); }
-	inline					Ref(const Ref<T> &inRHS)						: mPtr(inRHS.mPtr) { AddRef(); }
-	inline					Ref(Ref<T> &&inRHS) noexcept					: mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
-	inline					~Ref()											{ Release(); }
-
-	/// Assignment operators
-	inline Ref<T> &			operator = (T *inRHS)							{ if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
-	inline Ref<T> &			operator = (const Ref<T> &inRHS)				{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
-	inline Ref<T> &			operator = (Ref<T> &&inRHS) noexcept			{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
-
-	/// Casting operators
-	inline					operator T *() const							{ return mPtr; }
-
-	/// Access like a normal pointer
-	inline T *				operator -> () const							{ return mPtr; }
-	inline T &				operator * () const								{ return *mPtr; }
-
-	/// Comparison
-	inline bool				operator == (const T * inRHS) const				{ return mPtr == inRHS; }
-	inline bool				operator == (const Ref<T> &inRHS) const			{ return mPtr == inRHS.mPtr; }
-	inline bool				operator != (const T * inRHS) const				{ return mPtr != inRHS; }
-	inline bool				operator != (const Ref<T> &inRHS) const			{ return mPtr != inRHS.mPtr; }
-
-	/// Get pointer
-	inline T *				GetPtr() const									{ return mPtr; }
-
-	/// Get hash for this object
-	uint64					GetHash() const
-	{
-		return Hash<T *> { } (mPtr);
-	}
-
-	/// INTERNAL HELPER FUNCTION USED BY SERIALIZATION
-	void **					InternalGetPointer()							{ return reinterpret_cast<void **>(&mPtr); }
-
-private:
-	template <class T2> friend class RefConst;
-
-	/// Use "variable = nullptr;" to release an object, do not call these functions
-	inline void				AddRef()										{ if (mPtr != nullptr) mPtr->AddRef(); }
-	inline void				Release()										{ if (mPtr != nullptr) mPtr->Release(); }
-
-	T *						mPtr;											///< Pointer to object that we are reference counting
-};
-
-/// Class for automatic referencing, this is the equivalent of a CONST pointer to type T
-/// if you assign a value to this class it will increment the reference count by one
-/// of this object, and if you assign something else it will decrease the reference
-/// count of the first object again. If it reaches a reference count of zero it will
-/// be deleted
-template <class T>
-class RefConst
-{
-public:
-	/// Constructor
-	inline					RefConst()										: mPtr(nullptr) { }
-	inline					RefConst(const T * inRHS)						: mPtr(inRHS) { AddRef(); }
-	inline					RefConst(const RefConst<T> &inRHS)				: mPtr(inRHS.mPtr) { AddRef(); }
-	inline					RefConst(RefConst<T> &&inRHS) noexcept			: mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
-	inline					RefConst(const Ref<T> &inRHS)					: mPtr(inRHS.mPtr) { AddRef(); }
-	inline					RefConst(Ref<T> &&inRHS) noexcept				: mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
-	inline					~RefConst()										{ Release(); }
-
-	/// Assignment operators
-	inline RefConst<T> &	operator = (const T * inRHS)					{ if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
-	inline RefConst<T> &	operator = (const RefConst<T> &inRHS)			{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
-	inline RefConst<T> &	operator = (RefConst<T> &&inRHS) noexcept		{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
-	inline RefConst<T> &	operator = (const Ref<T> &inRHS)				{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
-	inline RefConst<T> &	operator = (Ref<T> &&inRHS) noexcept			{ if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
-
-	/// Casting operators
-	inline					operator const T * () const						{ return mPtr; }
-
-	/// Access like a normal pointer
-	inline const T *		operator -> () const							{ return mPtr; }
-	inline const T &		operator * () const								{ return *mPtr; }
-
-	/// Comparison
-	inline bool				operator == (const T * inRHS) const				{ return mPtr == inRHS; }
-	inline bool				operator == (const RefConst<T> &inRHS) const	{ return mPtr == inRHS.mPtr; }
-	inline bool				operator == (const Ref<T> &inRHS) const			{ return mPtr == inRHS.mPtr; }
-	inline bool				operator != (const T * inRHS) const				{ return mPtr != inRHS; }
-	inline bool				operator != (const RefConst<T> &inRHS) const	{ return mPtr != inRHS.mPtr; }
-	inline bool				operator != (const Ref<T> &inRHS) const			{ return mPtr != inRHS.mPtr; }
-
-	/// Get pointer
-	inline const T *		GetPtr() const									{ return mPtr; }
-
-	/// Get hash for this object
-	uint64					GetHash() const
-	{
-		return Hash<const T *> { } (mPtr);
-	}
-
-	/// INTERNAL HELPER FUNCTION USED BY SERIALIZATION
-	void **					InternalGetPointer()							{ return const_cast<void **>(reinterpret_cast<const void **>(&mPtr)); }
-
-private:
-	/// Use "variable = nullptr;" to release an object, do not call these functions
-	inline void				AddRef()										{ if (mPtr != nullptr) mPtr->AddRef(); }
-	inline void				Release()										{ if (mPtr != nullptr) mPtr->Release(); }
-
-	const T *				mPtr;											///< Pointer to object that we are reference counting
-};
-
-JPH_NAMESPACE_END
-
-JPH_SUPPRESS_WARNING_PUSH
-JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
-
-namespace std
-{
-	/// Declare std::hash for Ref
-	template <class T>
-	struct hash<JPH::Ref<T>>
-	{
-		size_t operator () (const JPH::Ref<T> &inRHS) const
-		{
-			return size_t(inRHS.GetHash());
-		}
-	};
-
-	/// Declare std::hash for RefConst
-	template <class T>
-	struct hash<JPH::RefConst<T>>
-	{
-		size_t operator () (const JPH::RefConst<T> &inRHS) const
-		{
-			return size_t(inRHS.GetHash());
-		}
-	};
-}
-
-JPH_SUPPRESS_WARNING_POP

package/native/third_party/JoltPhysics/Jolt/Core/Result.h

@@ -1,174 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Helper class that either contains a valid result or an error
-template <class Type>
-class Result
-{
-public:
-	/// Default constructor
-						Result()									{ }
-
-	/// Copy constructor
-						Result(const Result<Type> &inRHS) :
-		mState(inRHS.mState)
-	{
-		switch (inRHS.mState)
-		{
-		case EState::Valid:
-			new (&mResult) Type (inRHS.mResult);
-			break;
-
-		case EState::Error:
-			new (&mError) String(inRHS.mError);
-			break;
-
-		case EState::Invalid:
-			break;
-		}
-	}
-
-	/// Move constructor
-						Result(Result<Type> &&inRHS) noexcept :
-		mState(inRHS.mState)
-	{
-		switch (inRHS.mState)
-		{
-		case EState::Valid:
-			new (&mResult) Type (std::move(inRHS.mResult));
-			break;
-
-		case EState::Error:
-			new (&mError) String(std::move(inRHS.mError));
-			break;
-
-		case EState::Invalid:
-			break;
-		}
-
-		// Don't reset the state of inRHS, the destructors still need to be called after a move operation
-	}
-
-	/// Destructor
-						~Result()									{ Clear(); }
-
-	/// Copy assignment
-	Result<Type> &		operator = (const Result<Type> &inRHS)
-	{
-		Clear();
-
-		mState = inRHS.mState;
-
-		switch (inRHS.mState)
-		{
-		case EState::Valid:
-			new (&mResult) Type (inRHS.mResult);
-			break;
-
-		case EState::Error:
-			new (&mError) String(inRHS.mError);
-			break;
-
-		case EState::Invalid:
-			break;
-		}
-
-		return *this;
-	}
-
-	/// Move assignment
-	Result<Type> &		operator = (Result<Type> &&inRHS) noexcept
-	{
-		Clear();
-
-		mState = inRHS.mState;
-
-		switch (inRHS.mState)
-		{
-		case EState::Valid:
-			new (&mResult) Type (std::move(inRHS.mResult));
-			break;
-
-		case EState::Error:
-			new (&mError) String(std::move(inRHS.mError));
-			break;
-
-		case EState::Invalid:
-			break;
-		}
-
-		// Don't reset the state of inRHS, the destructors still need to be called after a move operation
-
-		return *this;
-	}
-
-	/// Clear result or error
-	void				Clear()
-	{
-		switch (mState)
-		{
-		case EState::Valid:
-			mResult.~Type();
-			break;
-
-		case EState::Error:
-			mError.~String();
-			break;
-
-		case EState::Invalid:
-			break;
-		}
-
-		mState = EState::Invalid;
-	}
-
-	/// Checks if the result is still uninitialized
-	bool				IsEmpty() const								{ return mState == EState::Invalid; }
-
-	/// Checks if the result is valid
-	bool				IsValid() const								{ return mState == EState::Valid; }
-
-	/// Get the result value
-	const Type &		Get() const									{ JPH_ASSERT(IsValid()); return mResult; }
-
-	/// Set the result value
-	void				Set(const Type &inResult)					{ Clear(); new (&mResult) Type(inResult); mState = EState::Valid; }
-
-	/// Set the result value (move value)
-	void				Set(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; }
-
-	/// Get the error value
-	const String &		GetError() const							{ JPH_ASSERT(HasError()); return mError; }
-
-	/// 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(std::move(inError)); mState = EState::Error; }
-
-private:
-	union
-	{
-		Type			mResult;									///< The actual result object
-		String			mError;										///< The error description if the result failed
-	};
-
-	/// State of the result
-	enum class EState : uint8
-	{
-		Invalid,
-		Valid,
-		Error
-	};
-
-	EState				mState = EState::Invalid;
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Core/STLAlignedAllocator.h

@@ -1,72 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// STL allocator that takes care that memory is aligned to N bytes
-template <typename T, size_t N>
-class STLAlignedAllocator
-{
-public:
-	using value_type = T;
-
-	/// Pointer to type
-	using pointer = T *;
-	using const_pointer = const T *;
-
-	/// Reference to type.
-	/// Can be removed in C++20.
-	using reference = T &;
-	using const_reference = const T &;
-
-	using size_type = size_t;
-	using difference_type = ptrdiff_t;
-
-	/// The allocator is stateless
-	using is_always_equal = std::true_type;
-
-	/// Allocator supports moving
-	using propagate_on_container_move_assignment = std::true_type;
-
-	/// Constructor
-	inline					STLAlignedAllocator() = default;
-
-	/// Constructor from other allocator
-	template <typename T2>
-	inline explicit			STLAlignedAllocator(const STLAlignedAllocator<T2, N> &) { }
-
-	/// Allocate memory
-	inline pointer			allocate(size_type inN)
-	{
-		return (pointer)AlignedAllocate(inN * sizeof(value_type), N);
-	}
-
-	/// Free memory
-	inline void				deallocate(pointer inPointer, size_type)
-	{
-		AlignedFree(inPointer);
-	}
-
-	/// Allocators are stateless so assumed to be equal
-	inline bool				operator == (const STLAlignedAllocator<T, N> &) const
-	{
-		return true;
-	}
-
-	inline bool				operator != (const STLAlignedAllocator<T, N> &) const
-	{
-		return false;
-	}
-
-	/// Converting to allocator for other type
-	template <typename T2>
-	struct rebind
-	{
-		using other = STLAlignedAllocator<T2, N>;
-	};
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Core/STLAllocator.h

@@ -1,127 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Default implementation of AllocatorHasReallocate which tells if an allocator has a reallocate function
-template <class T> struct AllocatorHasReallocate { static constexpr bool sValue = false; };
-
-#ifndef JPH_DISABLE_CUSTOM_ALLOCATOR
-
-/// STL allocator that forwards to our allocation functions
-template <typename T>
-class STLAllocator
-{
-public:
-	using value_type = T;
-
-	/// Pointer to type
-	using pointer = T *;
-	using const_pointer = const T *;
-
-	/// Reference to type.
-	/// Can be removed in C++20.
-	using reference = T &;
-	using const_reference = const T &;
-
-	using size_type = size_t;
-	using difference_type = ptrdiff_t;
-
-	/// The allocator is stateless
-	using is_always_equal = std::true_type;
-
-	/// Allocator supports moving
-	using propagate_on_container_move_assignment = std::true_type;
-
-	/// Constructor
-	inline					STLAllocator() = default;
-
-	/// Constructor from other allocator
-	template <typename T2>
-	inline					STLAllocator(const STLAllocator<T2> &) { }
-
-	/// If this allocator needs to fall back to aligned allocations because the type requires it
-	static constexpr bool	needs_aligned_allocate = alignof(T) > JPH_DEFAULT_ALLOCATE_ALIGNMENT;
-
-	/// Allocate memory
-	inline pointer			allocate(size_type inN)
-	{
-		if constexpr (needs_aligned_allocate)
-			return pointer(AlignedAllocate(inN * sizeof(value_type), alignof(T)));
-		else
-			return pointer(Allocate(inN * sizeof(value_type)));
-	}
-
-	/// Should we expose a reallocate function?
-	static constexpr bool	has_reallocate = std::is_trivially_copyable<T>() && !needs_aligned_allocate;
-
-	/// Reallocate memory
-	template <bool has_reallocate_v = has_reallocate, typename = std::enable_if_t<has_reallocate_v>>
-	inline pointer			reallocate(pointer inOldPointer, size_type inOldSize, size_type inNewSize)
-	{
-		JPH_ASSERT(inNewSize > 0); // Reallocating to zero size is implementation dependent, so we don't allow it
-		return pointer(Reallocate(inOldPointer, inOldSize * sizeof(value_type), inNewSize * sizeof(value_type)));
-	}
-
-	/// Free memory
-	inline void				deallocate(pointer inPointer, size_type)
-	{
-		if constexpr (needs_aligned_allocate)
-			AlignedFree(inPointer);
-		else
-			Free(inPointer);
-	}
-
-	/// Allocators are stateless so assumed to be equal
-	inline bool				operator == (const STLAllocator<T> &) const
-	{
-		return true;
-	}
-
-	inline bool				operator != (const STLAllocator<T> &) const
-	{
-		return false;
-	}
-
-	/// Converting to allocator for other type
-	template <typename T2>
-	struct rebind
-	{
-		using other = STLAllocator<T2>;
-	};
-};
-
-/// The STLAllocator implements the reallocate function if the alignment of the class is smaller or equal to the default alignment for the platform
-template <class T> struct AllocatorHasReallocate<STLAllocator<T>> { static constexpr bool sValue = STLAllocator<T>::has_reallocate; };
-
-#else
-
-template <typename T> using STLAllocator = std::allocator<T>;
-
-#endif // !JPH_DISABLE_CUSTOM_ALLOCATOR
-
-// Declare STL containers that use our allocator
-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
-
-#if (!defined(JPH_PLATFORM_WINDOWS) || defined(JPH_COMPILER_MINGW)) && !defined(JPH_DISABLE_CUSTOM_ALLOCATOR)
-
-namespace std
-{
-	/// Declare std::hash for String, for some reason on Linux based platforms template deduction takes the wrong variant
-	template <>
-	struct hash<JPH::String>
-	{
-		inline size_t operator () (const JPH::String &inRHS) const
-		{
-			return hash<string_view> { } (inRHS);
-		}
-	};
-}
-
-#endif // (!JPH_PLATFORM_WINDOWS || JPH_COMPILER_MINGW) && !JPH_DISABLE_CUSTOM_ALLOCATOR