@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,170 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2025 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/STLAllocator.h>
-
-JPH_NAMESPACE_BEGIN
-
-#ifndef JPH_DISABLE_CUSTOM_ALLOCATOR
-
-/// STL allocator that keeps N elements in a local buffer before falling back to regular allocations
-template <typename T, size_t N>
-class STLLocalAllocator : private STLAllocator<T>
-{
-	using Base = STLAllocator<T>;
-
-public:
-	/// General properties
-	using value_type = T;
-	using pointer = T *;
-	using const_pointer = const T *;
-	using reference = T &;
-	using const_reference = const T &;
-	using size_type = size_t;
-	using difference_type = ptrdiff_t;
-
-	/// The allocator is not stateless (has local buffer)
-	using is_always_equal = std::false_type;
-
-	/// We cannot copy, move or swap allocators
-	using propagate_on_container_copy_assignment = std::false_type;
-	using propagate_on_container_move_assignment = std::false_type;
-	using propagate_on_container_swap = std::false_type;
-
-	/// Constructor
-							STLLocalAllocator() = default;
-							STLLocalAllocator(const STLLocalAllocator &) = delete; // Can't copy an allocator as the buffer is local to the original
-							STLLocalAllocator(STLLocalAllocator &&) = delete; // Can't move an allocator as the buffer is local to the original
-	STLLocalAllocator &		operator = (const STLLocalAllocator &) = delete; // Can't copy an allocator as the buffer is local to the original
-
-	/// Constructor used when rebinding to another type. This expects the allocator to use the original memory pool from the first allocator,
-	/// but in our case we cannot use the local buffer of the original allocator as it has different size and alignment rules.
-	/// To solve this we make this allocator fall back to the heap immediately.
-	template <class T2>
-	explicit				STLLocalAllocator(const STLLocalAllocator<T2, N> &) : mNumElementsUsed(N) { }
-
-	/// Check if inPointer is in the local buffer
-	inline bool				is_local(const_pointer inPointer) const
-	{
-		ptrdiff_t diff = inPointer - reinterpret_cast<const_pointer>(mElements);
-		return diff >= 0 && diff < ptrdiff_t(N);
-	}
-
-	/// Allocate memory
-	inline pointer			allocate(size_type inN)
-	{
-		// If we allocate more than we have, fall back to the heap
-		if (mNumElementsUsed + inN > N)
-			return Base::allocate(inN);
-
-		// Allocate from our local buffer
-		pointer result = reinterpret_cast<pointer>(mElements) + mNumElementsUsed;
-		mNumElementsUsed += inN;
-		return result;
-	}
-
-	/// Always implements a reallocate function as we can often reallocate in place
-	static constexpr bool	has_reallocate = true;
-
-	/// Reallocate memory
-	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
-
-		// If there was no previous allocation, we can go through the regular allocate function
-		if (inOldPointer == nullptr)
-			return allocate(inNewSize);
-
-		// If the pointer is outside our local buffer, fall back to the heap
-		if (!is_local(inOldPointer))
-		{
-			if constexpr (AllocatorHasReallocate<Base>::sValue)
-				return Base::reallocate(inOldPointer, inOldSize, inNewSize);
-			else
-				return ReallocateImpl(inOldPointer, inOldSize, inNewSize);
-		}
-
-		// If we happen to have space left, we only need to update our bookkeeping
-		pointer base_ptr = reinterpret_cast<pointer>(mElements) + mNumElementsUsed - inOldSize;
-		if (inOldPointer == base_ptr
-			&& mNumElementsUsed - inOldSize + inNewSize <= N)
-		{
-			mNumElementsUsed += inNewSize - inOldSize;
-			return base_ptr;
-		}
-
-		// We can't reallocate in place, fall back to the heap
-		return ReallocateImpl(inOldPointer, inOldSize, inNewSize);
-	}
-
-	/// Free memory
-	inline void				deallocate(pointer inPointer, size_type inN)
-	{
-		// If the pointer is not in our local buffer, fall back to the heap
-		if (!is_local(inPointer))
-			return Base::deallocate(inPointer, inN);
-
-		// Else we can only reclaim memory if it was the last allocation
-		if (inPointer == reinterpret_cast<pointer>(mElements) + mNumElementsUsed - inN)
-			mNumElementsUsed -= inN;
-	}
-
-	/// Allocators are not-stateless, assume if allocator address matches that the allocators are the same
-	inline bool				operator == (const STLLocalAllocator<T, N> &inRHS) const
-	{
-		return this == &inRHS;
-	}
-
-	inline bool				operator != (const STLLocalAllocator<T, N> &inRHS) const
-	{
-		return this != &inRHS;
-	}
-
-	/// Converting to allocator for other type
-	template <typename T2>
-	struct rebind
-	{
-		using other = STLLocalAllocator<T2, N>;
-	};
-
-private:
-	/// Implements reallocate when the base class doesn't or when we go from local buffer to heap
-	inline pointer			ReallocateImpl(pointer inOldPointer, size_type inOldSize, size_type inNewSize)
-	{
-		pointer new_pointer = Base::allocate(inNewSize);
-		size_type n = min(inOldSize, inNewSize);
-		if constexpr (std::is_trivially_copyable<T>())
-		{
-			// Can use mem copy
-			memcpy(new_pointer, inOldPointer, n * sizeof(T));
-		}
-		else
-		{
-			// Need to actually move the elements
-			for (size_t i = 0; i < n; ++i)
-			{
-				new (new_pointer + i) T(std::move(inOldPointer[i]));
-				inOldPointer[i].~T();
-			}
-		}
-		deallocate(inOldPointer, inOldSize);
-		return new_pointer;
-	}
-
-	alignas(T) uint8		mElements[N * sizeof(T)];
-	size_type				mNumElementsUsed = 0;
-};
-
-/// The STLLocalAllocator always implements a reallocate function as it can often reallocate in place
-template <class T, size_t N> struct AllocatorHasReallocate<STLLocalAllocator<T, N>> { static constexpr bool sValue = STLLocalAllocator<T, N>::has_reallocate; };
-
-#else
-
-template <typename T, size_t N> using STLLocalAllocator = std::allocator<T>;
-
-#endif // !JPH_DISABLE_CUSTOM_ALLOCATOR
-
-JPH_NAMESPACE_END

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

@@ -1,80 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/TempAllocator.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// STL allocator that wraps around TempAllocator
-template <typename T>
-class STLTempAllocator
-{
-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 not stateless (depends on the temp allocator)
-	using is_always_equal = std::false_type;
-
-	/// Constructor
-	inline					STLTempAllocator(TempAllocator &inAllocator) : mAllocator(inAllocator) { }
-
-	/// Constructor from other allocator
-	template <typename T2>
-	inline explicit			STLTempAllocator(const STLTempAllocator<T2> &inRHS) : mAllocator(inRHS.GetAllocator()) { }
-
-	/// Allocate memory
-	inline pointer			allocate(size_type inN)
-	{
-		return pointer(mAllocator.Allocate(uint(inN * sizeof(value_type))));
-	}
-
-	/// Free memory
-	inline void				deallocate(pointer inPointer, size_type inN)
-	{
-		mAllocator.Free(inPointer, uint(inN * sizeof(value_type)));
-	}
-
-	/// Allocators are not-stateless, assume if allocator address matches that the allocators are the same
-	inline bool				operator == (const STLTempAllocator<T> &inRHS) const
-	{
-		return &mAllocator == &inRHS.mAllocator;
-	}
-
-	inline bool				operator != (const STLTempAllocator<T> &inRHS) const
-	{
-		return &mAllocator != &inRHS.mAllocator;
-	}
-
-	/// Converting to allocator for other type
-	template <typename T2>
-	struct rebind
-	{
-		using other = STLTempAllocator<T2>;
-	};
-
-	/// Get our temp allocator
-	TempAllocator &			GetAllocator() const
-	{
-		return mAllocator;
-	}
-
-private:
-	TempAllocator &			mAllocator;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,49 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/NonCopyable.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Class that calls a function when it goes out of scope
-template <class F>
-class ScopeExit : public NonCopyable
-{
-public:
-	/// Constructor specifies the exit function
-	JPH_INLINE explicit	ScopeExit(F &&inFunction) : mFunction(std::move(inFunction)) { }
-
-	/// Destructor calls the exit function
-	JPH_INLINE			~ScopeExit() { if (!mInvoked) mFunction(); }
-
-	/// Call the exit function now instead of when going out of scope
-	JPH_INLINE void		Invoke()
-	{
-		if (!mInvoked)
-		{
-			mFunction();
-			mInvoked = true;
-		}
-	}
-
-	/// No longer call the exit function when going out of scope
-	JPH_INLINE void		Release()
-	{
-		mInvoked = true;
-	}
-
-private:
-	F					mFunction;
-	bool				mInvoked = false;
-};
-
-#define JPH_SCOPE_EXIT_TAG2(line)			scope_exit##line
-#define JPH_SCOPE_EXIT_TAG(line)			JPH_SCOPE_EXIT_TAG2(line)
-
-/// Usage: JPH_SCOPE_EXIT([]{ code to call on scope exit });
-#define JPH_SCOPE_EXIT(...) ScopeExit JPH_SCOPE_EXIT_TAG(__LINE__)(__VA_ARGS__)
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Core/Semaphore.cpp

@@ -1,135 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Core/Semaphore.h>
-
-#ifdef JPH_PLATFORM_WINDOWS
-	JPH_SUPPRESS_WARNING_PUSH
-	JPH_MSVC_SUPPRESS_WARNING(5039) // winbase.h(13179): warning C5039: 'TpSetCallbackCleanupGroup': pointer or reference to potentially throwing function passed to 'extern "C"' function under -EHc. Undefined behavior may occur if this function throws an exception.
-	JPH_MSVC2026_PLUS_SUPPRESS_WARNING(4865) // wingdi.h(2806,1): '<unnamed-enum-DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER>': the underlying type will change from 'int' to '__int64' when '/Zc:enumTypes' is specified on the command line
-#ifndef WIN32_LEAN_AND_MEAN
-		#define WIN32_LEAN_AND_MEAN
-	#endif
-#ifndef JPH_COMPILER_MINGW
-	#include <Windows.h>
-#else
-	#include <windows.h>
-#endif
-	JPH_SUPPRESS_WARNING_POP
-#endif
-
-JPH_NAMESPACE_BEGIN
-
-Semaphore::Semaphore()
-{
-#ifdef JPH_PLATFORM_WINDOWS
-	mSemaphore = CreateSemaphore(nullptr, 0, INT_MAX, nullptr);
-	if (mSemaphore == nullptr)
-	{
-		Trace("Failed to create semaphore");
-		std::abort();
-	}
-#elif defined(JPH_USE_PTHREADS)
-	int ret = sem_init(&mSemaphore, 0, 0);
-	if (ret == -1)
-	{
-		Trace("Failed to create semaphore");
-		std::abort();
-	}
-#elif defined(JPH_USE_GRAND_CENTRAL_DISPATCH)
-	mSemaphore = dispatch_semaphore_create(0);
-	if (mSemaphore == nullptr)
-	{
-		Trace("Failed to create semaphore");
-		std::abort();
-	}
-#elif defined(JPH_PLATFORM_BLUE)
-	if (!JPH_PLATFORM_BLUE_SEMAPHORE_INIT(mSemaphore))
-	{
-		Trace("Failed to create semaphore");
-		std::abort();
-	}
-#endif
-}
-
-Semaphore::~Semaphore()
-{
-#ifdef JPH_PLATFORM_WINDOWS
-	CloseHandle(mSemaphore);
-#elif defined(JPH_USE_PTHREADS)
-	sem_destroy(&mSemaphore);
-#elif defined(JPH_USE_GRAND_CENTRAL_DISPATCH)
-	dispatch_release(mSemaphore);
-#elif defined(JPH_PLATFORM_BLUE)
-	JPH_PLATFORM_BLUE_SEMAPHORE_DESTROY(mSemaphore);
-#endif
-}
-
-void Semaphore::Release(uint inNumber)
-{
-	JPH_ASSERT(inNumber > 0);
-
-#if defined(JPH_PLATFORM_WINDOWS) || defined(JPH_USE_PTHREADS) || defined(JPH_USE_GRAND_CENTRAL_DISPATCH) || defined(JPH_PLATFORM_BLUE)
-	int old_value = mCount.fetch_add(inNumber, std::memory_order_release);
-	if (old_value < 0)
-	{
-		int new_value = old_value + (int)inNumber;
-		int num_to_release = min(new_value, 0) - old_value;
-	#ifdef JPH_PLATFORM_WINDOWS
-		::ReleaseSemaphore(mSemaphore, num_to_release, nullptr);
-	#elif defined(JPH_USE_PTHREADS)
-		for (int i = 0; i < num_to_release; ++i)
-			sem_post(&mSemaphore);
-	#elif defined(JPH_USE_GRAND_CENTRAL_DISPATCH)
-		for (int i = 0; i < num_to_release; ++i)
-			dispatch_semaphore_signal(mSemaphore);
-	#elif defined(JPH_PLATFORM_BLUE)
-		JPH_PLATFORM_BLUE_SEMAPHORE_SIGNAL(mSemaphore, num_to_release);
-	#endif
-	}
-#else
-	std::lock_guard lock(mLock);
-	mCount.fetch_add(inNumber, std::memory_order_relaxed);
-	if (inNumber > 1)
-		mWaitVariable.notify_all();
-	else
-		mWaitVariable.notify_one();
-#endif
-}
-
-void Semaphore::Acquire(uint inNumber)
-{
-	JPH_ASSERT(inNumber > 0);
-
-#if defined(JPH_PLATFORM_WINDOWS) || defined(JPH_USE_PTHREADS) || defined(JPH_USE_GRAND_CENTRAL_DISPATCH) || defined(JPH_PLATFORM_BLUE)
-	int old_value = mCount.fetch_sub(inNumber, std::memory_order_acquire);
-	int new_value = old_value - (int)inNumber;
-	if (new_value < 0)
-	{
-		int num_to_acquire = min(old_value, 0) - new_value;
-	#ifdef JPH_PLATFORM_WINDOWS
-		for (int i = 0; i < num_to_acquire; ++i)
-			WaitForSingleObject(mSemaphore, INFINITE);
-	#elif defined(JPH_USE_PTHREADS)
-		for (int i = 0; i < num_to_acquire; ++i)
-			sem_wait(&mSemaphore);
-	#elif defined(JPH_USE_GRAND_CENTRAL_DISPATCH)
-		for (int i = 0; i < num_to_acquire; ++i)
-			dispatch_semaphore_wait(mSemaphore, DISPATCH_TIME_FOREVER);
-	#elif defined(JPH_PLATFORM_BLUE)
-		JPH_PLATFORM_BLUE_SEMAPHORE_WAIT(mSemaphore, num_to_acquire);
-	#endif
-	}
-#else
-	std::unique_lock lock(mLock);
-	mWaitVariable.wait(lock, [this, inNumber]() {
-		return mCount.load(std::memory_order_relaxed) >= int(inNumber);
-	});
-	mCount.fetch_sub(inNumber, std::memory_order_relaxed);
-#endif
-}
-
-JPH_NAMESPACE_END

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

@@ -1,68 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/Atomics.h>
-
-// Determine which platform specific construct we'll use
-JPH_SUPPRESS_WARNINGS_STD_BEGIN
-#ifdef JPH_PLATFORM_WINDOWS
-	// We include windows.h in the cpp file, the semaphore itself is a void pointer
-#elif defined(JPH_PLATFORM_LINUX) || defined(JPH_PLATFORM_ANDROID) || defined(JPH_PLATFORM_BSD) || defined(JPH_PLATFORM_WASM)
-	#include <semaphore.h>
-	#define JPH_USE_PTHREADS
-#elif defined(JPH_PLATFORM_MACOS) || defined(JPH_PLATFORM_IOS)
-	#include <dispatch/dispatch.h>
-	#define JPH_USE_GRAND_CENTRAL_DISPATCH
-#elif defined(JPH_PLATFORM_BLUE)
-	// Jolt/Core/PlatformBlue.h should have defined everything that is needed below
-#else
-	#include <mutex>
-	#include <condition_variable>
-#endif
-JPH_SUPPRESS_WARNINGS_STD_END
-
-JPH_NAMESPACE_BEGIN
-
-/// Implements a semaphore
-/// When we switch to C++20 we can use counting_semaphore to unify this
-class JPH_EXPORT Semaphore
-{
-public:
-	/// Constructor
-							Semaphore();
-							~Semaphore();
-
-	/// Release the semaphore, signaling the thread waiting on the barrier that there may be work
-	void					Release(uint inNumber = 1);
-
-	/// Acquire the semaphore inNumber times
-	void					Acquire(uint inNumber = 1);
-
-	/// Get the current value of the semaphore
-	inline int				GetValue() const								{ return mCount.load(std::memory_order_relaxed); }
-
-private:
-#if defined(JPH_PLATFORM_WINDOWS) || defined(JPH_USE_PTHREADS) || defined(JPH_USE_GRAND_CENTRAL_DISPATCH) || defined(JPH_PLATFORM_BLUE)
-#ifdef JPH_PLATFORM_WINDOWS
-	using SemaphoreType = void *;
-#elif defined(JPH_USE_PTHREADS)
-	using SemaphoreType = sem_t;
-#elif defined(JPH_USE_GRAND_CENTRAL_DISPATCH)
-	using SemaphoreType = dispatch_semaphore_t;
-#elif defined(JPH_PLATFORM_BLUE)
-	using SemaphoreType = JPH_PLATFORM_BLUE_SEMAPHORE;
-#endif
-	alignas(JPH_CACHE_LINE_SIZE) atomic<int> mCount { 0 };					///< We increment mCount for every release, to acquire we decrement the count. If the count is negative we know that we are waiting on the actual semaphore.
-	SemaphoreType			mSemaphore { };									///< The semaphore is an expensive construct so we only acquire/release it if we know that we need to wait/have waiting threads
-#else
-	// Other platforms: Emulate a semaphore using a mutex, condition variable and count
-	std::mutex				mLock;
-	std::condition_variable	mWaitVariable;
-	atomic<int>				mCount { 0 };
-#endif
-};
-
-JPH_NAMESPACE_END