@bloomengine/engine 0.4.0 → 0.4.1

package/native/third_party/JoltPhysics/Jolt/Core/FixedSizeFreeList.inl

@@ -1,215 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-JPH_NAMESPACE_BEGIN
-
-template <typename Object>
-FixedSizeFreeList<Object>::~FixedSizeFreeList()
-{
-	// Check if we got our Init call
-	if (mPages != nullptr)
-	{
-		// Ensure everything is freed before the freelist is destructed
-		JPH_ASSERT(mNumFreeObjects.load(memory_order_relaxed) == mNumPages * mPageSize);
-
-		// Free memory for pages
-		uint32 num_pages = mNumObjectsAllocated / mPageSize;
-		for (uint32 page = 0; page < num_pages; ++page)
-			AlignedFree(mPages[page]);
-		Free(mPages);
-	}
-}
-
-template <typename Object>
-void FixedSizeFreeList<Object>::Init(uint inMaxObjects, uint inPageSize)
-{
-	// Check sanity
-	JPH_ASSERT(inPageSize > 0 && IsPowerOf2(inPageSize));
-	JPH_ASSERT(mPages == nullptr);
-
-	// Store configuration parameters
-	mNumPages = (inMaxObjects + inPageSize - 1) / inPageSize;
-	mPageSize = inPageSize;
-	mPageShift = CountTrailingZeros(inPageSize);
-	mObjectMask = inPageSize - 1;
-	JPH_IF_ENABLE_ASSERTS(mNumFreeObjects = mNumPages * inPageSize;)
-
-	// Allocate page table
-	mPages = reinterpret_cast<ObjectStorage **>(Allocate(mNumPages * sizeof(ObjectStorage *)));
-
-	// We didn't yet use any objects of any page
-	mNumObjectsAllocated = 0;
-	mFirstFreeObjectInNewPage = 0;
-
-	// Start with 1 as the first tag
-	mAllocationTag = 1;
-
-	// Set first free object (with tag 0)
-	mFirstFreeObjectAndTag = cInvalidObjectIndex;
-}
-
-template <typename Object>
-template <typename... Parameters>
-uint32 FixedSizeFreeList<Object>::ConstructObject(Parameters &&... inParameters)
-{
-	for (;;)
-	{
-		// Get first object from the linked list
-		uint64 first_free_object_and_tag = mFirstFreeObjectAndTag.load(memory_order_acquire);
-		uint32 first_free = uint32(first_free_object_and_tag);
-		if (first_free == cInvalidObjectIndex)
-		{
-			// The free list is empty, we take an object from the page that has never been used before
-			first_free = mFirstFreeObjectInNewPage.fetch_add(1, memory_order_relaxed);
-			if (first_free >= mNumObjectsAllocated)
-			{
-				// Allocate new page
-				lock_guard lock(mPageMutex);
-				while (first_free >= mNumObjectsAllocated)
-				{
-					uint32 next_page = mNumObjectsAllocated / mPageSize;
-					if (next_page == mNumPages)
-						return cInvalidObjectIndex; // Out of space!
-					mPages[next_page] = reinterpret_cast<ObjectStorage *>(AlignedAllocate(mPageSize * sizeof(ObjectStorage), max<size_t>(alignof(ObjectStorage), JPH_CACHE_LINE_SIZE)));
-					mNumObjectsAllocated += mPageSize;
-				}
-			}
-
-			// Allocation successful
-			JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_sub(1, memory_order_relaxed);)
-			ObjectStorage &storage = GetStorage(first_free);
-			new (&storage.mObject) Object(std::forward<Parameters>(inParameters)...);
-			storage.mNextFreeObject.store(first_free, memory_order_release);
-			return first_free;
-		}
-		else
-		{
-			// Load next pointer
-			uint32 new_first_free = GetStorage(first_free).mNextFreeObject.load(memory_order_acquire);
-
-			// Construct a new first free object tag
-			uint64 new_first_free_object_and_tag = uint64(new_first_free) + (uint64(mAllocationTag.fetch_add(1, memory_order_relaxed)) << 32);
-
-			// Compare and swap
-			if (mFirstFreeObjectAndTag.compare_exchange_weak(first_free_object_and_tag, new_first_free_object_and_tag, memory_order_release))
-			{
-				// Allocation successful
-				JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_sub(1, memory_order_relaxed);)
-				ObjectStorage &storage = GetStorage(first_free);
-				new (&storage.mObject) Object(std::forward<Parameters>(inParameters)...);
-				storage.mNextFreeObject.store(first_free, memory_order_release);
-				return first_free;
-			}
-		}
-	}
-}
-
-template <typename Object>
-void FixedSizeFreeList<Object>::AddObjectToBatch(Batch &ioBatch, uint32 inObjectIndex)
-{
-	JPH_ASSERT(ioBatch.mNumObjects != uint32(-1), "Trying to reuse a batch that has already been freed");
-
-	// Reset next index
-	atomic<uint32> &next_free_object = GetStorage(inObjectIndex).mNextFreeObject;
-	JPH_ASSERT(next_free_object.load(memory_order_relaxed) == inObjectIndex, "Trying to add a object to the batch that is already in a free list");
-	next_free_object.store(cInvalidObjectIndex, memory_order_release);
-
-	// Link object in batch to free
-	if (ioBatch.mFirstObjectIndex == cInvalidObjectIndex)
-		ioBatch.mFirstObjectIndex = inObjectIndex;
-	else
-		GetStorage(ioBatch.mLastObjectIndex).mNextFreeObject.store(inObjectIndex, memory_order_release);
-	ioBatch.mLastObjectIndex = inObjectIndex;
-	ioBatch.mNumObjects++;
-}
-
-template <typename Object>
-void FixedSizeFreeList<Object>::DestructObjectBatch(Batch &ioBatch)
-{
-	if (ioBatch.mFirstObjectIndex != cInvalidObjectIndex)
-	{
-		// Call destructors
-		if constexpr (!std::is_trivially_destructible<Object>())
-		{
-			uint32 object_idx = ioBatch.mFirstObjectIndex;
-			do
-			{
-				ObjectStorage &storage = GetStorage(object_idx);
-				storage.mObject.~Object();
-				object_idx = storage.mNextFreeObject.load(memory_order_relaxed);
-			}
-			while (object_idx != cInvalidObjectIndex);
-		}
-
-		// Add to objects free list
-		ObjectStorage &storage = GetStorage(ioBatch.mLastObjectIndex);
-		for (;;)
-		{
-			// Get first object from the list
-			uint64 first_free_object_and_tag = mFirstFreeObjectAndTag.load(memory_order_acquire);
-			uint32 first_free = uint32(first_free_object_and_tag);
-
-			// Make it the next pointer of the last object in the batch that is to be freed
-			storage.mNextFreeObject.store(first_free, memory_order_release);
-
-			// Construct a new first free object tag
-			uint64 new_first_free_object_and_tag = uint64(ioBatch.mFirstObjectIndex) + (uint64(mAllocationTag.fetch_add(1, memory_order_relaxed)) << 32);
-
-			// Compare and swap
-			if (mFirstFreeObjectAndTag.compare_exchange_weak(first_free_object_and_tag, new_first_free_object_and_tag, memory_order_release))
-			{
-				// Free successful
-				JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_add(ioBatch.mNumObjects, memory_order_relaxed);)
-
-				// Mark the batch as freed
-#ifdef JPH_ENABLE_ASSERTS
-				ioBatch.mNumObjects = uint32(-1);
-#endif
-				return;
-			}
-		}
-	}
-}
-
-template <typename Object>
-void FixedSizeFreeList<Object>::DestructObject(uint32 inObjectIndex)
-{
-	JPH_ASSERT(inObjectIndex != cInvalidObjectIndex);
-
-	// Call destructor
-	ObjectStorage &storage = GetStorage(inObjectIndex);
-	storage.mObject.~Object();
-
-	// Add to object free list
-	for (;;)
-	{
-		// Get first object from the list
-		uint64 first_free_object_and_tag = mFirstFreeObjectAndTag.load(memory_order_acquire);
-		uint32 first_free = uint32(first_free_object_and_tag);
-
-		// Make it the next pointer of the last object in the batch that is to be freed
-		storage.mNextFreeObject.store(first_free, memory_order_release);
-
-		// Construct a new first free object tag
-		uint64 new_first_free_object_and_tag = uint64(inObjectIndex) + (uint64(mAllocationTag.fetch_add(1, memory_order_relaxed)) << 32);
-
-		// Compare and swap
-		if (mFirstFreeObjectAndTag.compare_exchange_weak(first_free_object_and_tag, new_first_free_object_and_tag, memory_order_release))
-		{
-			// Free successful
-			JPH_IF_ENABLE_ASSERTS(mNumFreeObjects.fetch_add(1, memory_order_relaxed);)
-			return;
-		}
-	}
-}
-
-template<typename Object>
-inline void FixedSizeFreeList<Object>::DestructObject(Object *inObject)
-{
-	uint32 index = reinterpret_cast<ObjectStorage *>(inObject)->mNextFreeObject.load(memory_order_relaxed);
-	JPH_ASSERT(index < mNumObjectsAllocated);
-	DestructObject(index);
-}
-
-JPH_NAMESPACE_END

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

@@ -1,234 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// Implements the FNV-1a hash algorithm
-/// @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-/// @param inData Data block of bytes
-/// @param inSize Number of bytes
-/// @param inSeed Seed of the hash (can be used to pass in the hash of a previous operation, otherwise leave default)
-/// @return Hash
-inline uint64 HashBytes(const void *inData, uint inSize, uint64 inSeed = 0xcbf29ce484222325UL)
-{
-	uint64 hash = inSeed;
-	for (const uint8 *data = reinterpret_cast<const uint8 *>(inData); data < reinterpret_cast<const uint8 *>(inData) + inSize; ++data)
-	{
-		hash ^= uint64(*data);
-		hash *= 0x100000001b3UL;
-	}
-	return hash;
-}
-
-/// Calculate the FNV-1a hash of inString.
-/// @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-constexpr uint64 HashString(const char *inString, uint64 inSeed = 0xcbf29ce484222325UL)
-{
-	uint64 hash = inSeed;
-	for (const char *c = inString; *c != 0; ++c)
-	{
-		hash ^= uint64(*c);
-		hash *= 0x100000001b3UL;
-	}
-	return hash;
-}
-
-/// A 64 bit hash function by Thomas Wang, Jan 1997
-/// See: http://web.archive.org/web/20071223173210/http://www.concentric.net/~Ttwang/tech/inthash.htm
-/// @param inValue Value to hash
-/// @return Hash
-inline uint64 Hash64(uint64 inValue)
-{
-	uint64 hash = inValue;
-	hash = (~hash) + (hash << 21); // hash = (hash << 21) - hash - 1;
-	hash = hash ^ (hash >> 24);
-	hash = (hash + (hash << 3)) + (hash << 8); // hash * 265
-	hash = hash ^ (hash >> 14);
-	hash = (hash + (hash << 2)) + (hash << 4); // hash * 21
-	hash = hash ^ (hash >> 28);
-	hash = hash + (hash << 31);
-	return hash;
-}
-
-/// Fallback hash function that calls T::GetHash()
-template <class T>
-struct Hash
-{
-	uint64		operator () (const T &inValue) const
-	{
-		return inValue.GetHash();
-	}
-};
-
-/// A hash function for floats
-template <>
-struct Hash<float>
-{
-	uint64		operator () (float inValue) const
-	{
-		float value = inValue == 0.0f? 0.0f : inValue; // Convert -0.0f to 0.0f
-		return HashBytes(&value, sizeof(value));
-	}
-};
-
-/// A hash function for doubles
-template <>
-struct Hash<double>
-{
-	uint64		operator () (double inValue) const
-	{
-		double value = inValue == 0.0? 0.0 : inValue; // Convert -0.0 to 0.0
-		return HashBytes(&value, sizeof(value));
-	}
-};
-
-/// A hash function for character pointers
-template <>
-struct Hash<const char *>
-{
-	uint64		operator () (const char *inValue) const
-	{
-		return HashString(inValue);
-	}
-};
-
-/// A hash function for std::string_view
-template <>
-struct Hash<std::string_view>
-{
-	uint64		operator () (const std::string_view &inValue) const
-	{
-		return HashBytes(inValue.data(), uint(inValue.size()));
-	}
-};
-
-/// A hash function for String
-template <>
-struct Hash<String>
-{
-	uint64		operator () (const String &inValue) const
-	{
-		return HashBytes(inValue.data(), uint(inValue.size()));
-	}
-};
-
-/// A fallback function for generic pointers
-template <class T>
-struct Hash<T *>
-{
-	uint64		operator () (T *inValue) const
-	{
-		return HashBytes(&inValue, sizeof(inValue));
-	}
-};
-
-/// Helper macro to define a hash function for trivial types
-#define JPH_DEFINE_TRIVIAL_HASH(type)						\
-template <>													\
-struct Hash<type>											\
-{															\
-	uint64		operator () (const type &inValue) const		\
-	{														\
-		return HashBytes(&inValue, sizeof(inValue));		\
-	}														\
-};
-
-/// Commonly used types
-JPH_DEFINE_TRIVIAL_HASH(char)
-JPH_DEFINE_TRIVIAL_HASH(int)
-JPH_DEFINE_TRIVIAL_HASH(uint32)
-JPH_DEFINE_TRIVIAL_HASH(uint64)
-
-/// Helper function that hashes a single value into ioSeed
-/// Based on https://github.com/jonmaiga/mx3 by Jon Maiga
-template <typename T>
-inline void HashCombine(uint64 &ioSeed, const T &inValue)
-{
-	constexpr uint64 c = 0xbea225f9eb34556dUL;
-
-	uint64 h = ioSeed;
-	uint64 x = Hash<T> { } (inValue);
-
-	// See: https://github.com/jonmaiga/mx3/blob/master/mx3.h
-	// mix_stream(h, x)
-	x *= c;
-	x ^= x >> 39;
-	h += x * c;
-	h *= c;
-
-	// mix(h)
-	h ^= h >> 32;
-	h *= c;
-	h ^= h >> 29;
-	h *= c;
-	h ^= h >> 32;
-	h *= c;
-	h ^= h >> 29;
-
-	ioSeed = h;
-}
-
-/// Hash combiner to use a custom struct in an unordered map or set
-///
-/// Usage:
-///
-///		struct SomeHashKey
-///		{
-///			std::string key1;
-///			std::string key2;
-///			bool key3;
-///		};
-///
-///		JPH_MAKE_HASHABLE(SomeHashKey, t.key1, t.key2, t.key3)
-template <typename FirstValue, typename... Values>
-inline uint64 HashCombineArgs(const FirstValue &inFirstValue, Values... inValues)
-{
-	// Prime the seed by hashing the first value
-	uint64 seed = Hash<FirstValue> { } (inFirstValue);
-
-	// Hash all remaining values together using a fold expression
-	(HashCombine(seed, inValues), ...);
-
-	return seed;
-}
-
-#define JPH_MAKE_HASH_STRUCT(type, name, ...)				\
-	struct [[nodiscard]] name								\
-	{														\
-		::JPH::uint64 operator()(const type &t) const		\
-		{													\
-			return ::JPH::HashCombineArgs(__VA_ARGS__);		\
-		}													\
-	};
-
-#define JPH_MAKE_STD_HASH(type)								\
-	JPH_SUPPRESS_WARNING_PUSH								\
-	JPH_SUPPRESS_WARNINGS									\
-	namespace std											\
-	{														\
-		template<>											\
-		struct [[nodiscard]] hash<type>						\
-		{													\
-			size_t operator()(const type &t) const			\
-			{												\
-				return size_t(::JPH::Hash<type>{ }(t));		\
-			}												\
-		};													\
-	}														\
-	JPH_SUPPRESS_WARNING_POP
-
-#define JPH_MAKE_HASHABLE(type, ...)						\
-	JPH_SUPPRESS_WARNING_PUSH								\
-	JPH_SUPPRESS_WARNINGS									\
-	namespace JPH											\
-	{														\
-		template<>											\
-		JPH_MAKE_HASH_STRUCT(type, Hash<type>, __VA_ARGS__) \
-	}														\
-	JPH_SUPPRESS_WARNING_POP								\
-	JPH_MAKE_STD_HASH(type)
-
-JPH_NAMESPACE_END