@bloomengine/engine 0.3.1

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

@@ -0,0 +1,53 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+
+JPH_SUPPRESS_WARNINGS_STD_BEGIN
+#include <ostream>
+JPH_SUPPRESS_WARNINGS_STD_END
+
+JPH_NAMESPACE_BEGIN
+
+/// Wrapper around std::ostream
+class StreamOutWrapper : public StreamOut
+{
+public:
+	/// Constructor
+						StreamOutWrapper(ostream &ioWrapped)						: mWrapped(ioWrapped) { }
+
+	/// Write a string of bytes to the binary stream
+	virtual void		WriteBytes(const void *inData, size_t inNumBytes) override	{ mWrapped.write((const char *)inData, inNumBytes); }
+
+	/// Returns true if there was an IO failure
+	virtual bool		IsFailed() const override									{ return mWrapped.fail(); }
+
+private:
+	ostream &			mWrapped;
+};
+
+/// Wrapper around std::istream
+class StreamInWrapper : public StreamIn
+{
+public:
+	/// Constructor
+						StreamInWrapper(istream &ioWrapped)							: mWrapped(ioWrapped) { }
+
+	/// Write a string of bytes to the binary stream
+	virtual void		ReadBytes(void *outData, size_t inNumBytes) override		{ mWrapped.read((char *)outData, inNumBytes); }
+
+	/// Returns true when an attempt has been made to read past the end of the file
+	virtual bool		IsEOF() const override										{ return mWrapped.eof(); }
+
+	/// Returns true if there was an IO failure
+	virtual bool		IsFailed() const override									{ return mWrapped.fail(); }
+
+private:
+	istream &			mWrapped;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,63 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// A strided pointer behaves exactly like a normal pointer except that the
+/// elements that the pointer points to can be part of a larger structure.
+/// The stride gives the number of bytes from one element to the next.
+template <class T>
+class JPH_EXPORT StridedPtr
+{
+public:
+	using value_type = T;
+
+	/// Constructors
+							StridedPtr() = default;
+							StridedPtr(const StridedPtr &inRHS) = default;
+							StridedPtr(T *inPtr, int inStride = sizeof(T))			: mPtr(const_cast<uint8 *>(reinterpret_cast<const uint8 *>(inPtr))), mStride(inStride) { }
+
+	/// Assignment
+	inline StridedPtr &		operator = (const StridedPtr &inRHS) = default;
+
+	/// Incrementing / decrementing
+	inline StridedPtr &		operator ++ ()											{ mPtr += mStride; return *this; }
+	inline StridedPtr &		operator -- ()											{ mPtr -= mStride; return *this; }
+	inline StridedPtr		operator ++ (int)										{ StridedPtr old_ptr(*this); mPtr += mStride; return old_ptr; }
+	inline StridedPtr		operator -- (int)										{ StridedPtr old_ptr(*this); mPtr -= mStride; return old_ptr; }
+	inline StridedPtr		operator + (int inOffset) const							{ StridedPtr new_ptr(*this); new_ptr.mPtr += inOffset * mStride; return new_ptr; }
+	inline StridedPtr		operator - (int inOffset) const							{ StridedPtr new_ptr(*this); new_ptr.mPtr -= inOffset * mStride; return new_ptr; }
+	inline void				operator += (int inOffset)								{ mPtr += inOffset * mStride; }
+	inline void				operator -= (int inOffset)								{ mPtr -= inOffset * mStride; }
+
+	/// Distance between two pointers in elements
+	inline int				operator - (const StridedPtr &inRHS) const				{ JPH_ASSERT(inRHS.mStride == mStride); return (mPtr - inRHS.mPtr) / mStride; }
+
+	/// Comparison operators
+	inline bool				operator == (const StridedPtr &inRHS) const				{ return mPtr == inRHS.mPtr; }
+	inline bool				operator != (const StridedPtr &inRHS) const				{ return mPtr != inRHS.mPtr; }
+	inline bool				operator <= (const StridedPtr &inRHS) const				{ return mPtr <= inRHS.mPtr; }
+	inline bool				operator >= (const StridedPtr &inRHS) const				{ return mPtr >= inRHS.mPtr; }
+	inline bool				operator <  (const StridedPtr &inRHS) const				{ return mPtr <  inRHS.mPtr; }
+	inline bool				operator >  (const StridedPtr &inRHS) const				{ return mPtr >  inRHS.mPtr; }
+
+	/// Access value
+	inline T &				operator * () const										{ return *reinterpret_cast<T *>(mPtr); }
+	inline T *				operator -> () const									{ return reinterpret_cast<T *>(mPtr); }
+	inline T &				operator [] (int inOffset) const						{ uint8 *ptr = mPtr + inOffset * mStride; return *reinterpret_cast<T *>(ptr); }
+
+	/// Explicit conversion
+	inline T *				GetPtr() const											{ return reinterpret_cast<T *>(mPtr); }
+
+	/// Get stride in bytes
+	inline int				GetStride() const										{ return mStride; }
+
+private:
+	uint8 *					mPtr = nullptr;											/// Pointer to element
+	int						mStride = 0;											/// Stride (number of bytes) between elements
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,101 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Core/StringTools.h>
+
+JPH_SUPPRESS_WARNINGS_STD_BEGIN
+#include <cstdarg>
+JPH_SUPPRESS_WARNINGS_STD_END
+
+JPH_NAMESPACE_BEGIN
+
+String StringFormat(const char *inFMT, ...)
+{
+	char buffer[1024];
+
+	// Format the string
+	va_list list;
+	va_start(list, inFMT);
+	vsnprintf(buffer, sizeof(buffer), inFMT, list);
+	va_end(list);
+
+	return String(buffer);
+}
+
+void StringReplace(String &ioString, const string_view &inSearch, const string_view &inReplace)
+{
+	size_t index = 0;
+	for (;;)
+	{
+		 index = ioString.find(inSearch, index);
+		 if (index == String::npos)
+			 break;
+
+		 ioString.replace(index, inSearch.size(), inReplace);
+
+		 index += inReplace.size();
+	}
+}
+
+void StringToVector(const string_view &inString, Array<String> &outVector, const string_view &inDelimiter, bool inClearVector)
+{
+	JPH_ASSERT(inDelimiter.size() > 0);
+
+	// Ensure vector empty
+	if (inClearVector)
+		outVector.clear();
+
+	// No string? no elements
+	if (inString.empty())
+		return;
+
+	// Start with initial string
+	String s(inString);
+
+	// Add to vector while we have a delimiter
+	size_t i;
+	while (!s.empty() && (i = s.find(inDelimiter)) != String::npos)
+	{
+		outVector.push_back(s.substr(0, i));
+		s.erase(0, i + inDelimiter.length());
+	}
+
+	// Add final element
+	outVector.push_back(s);
+}
+
+void VectorToString(const Array<String> &inVector, String &outString, const string_view &inDelimiter)
+{
+	// Ensure string empty
+	outString.clear();
+
+	for (const String &s : inVector)
+	{
+		// Add delimiter if not first element
+		if (!outString.empty())
+			outString.append(inDelimiter);
+
+		// Add element
+		outString.append(s);
+	}
+}
+
+String ToLower(const string_view &inString)
+{
+	String out;
+	out.reserve(inString.length());
+	for (char c : inString)
+		out.push_back((char)tolower(c));
+	return out;
+}
+
+const char *NibbleToBinary(uint32 inNibble)
+{
+	static const char *nibbles[] = { "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111" };
+	return nibbles[inNibble & 0xf];
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,38 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Create a formatted text string for debugging purposes.
+/// Note that this function has an internal buffer of 1024 characters, so long strings will be trimmed.
+JPH_EXPORT String StringFormat(const char *inFMT, ...);
+
+/// Convert type to string
+template<typename T>
+String ConvertToString(const T &inValue)
+{
+	using OStringStream = std::basic_ostringstream<char, std::char_traits<char>, STLAllocator<char>>;
+	OStringStream oss;
+	oss << inValue;
+	return oss.str();
+}
+
+/// Replace substring with other string
+JPH_EXPORT void StringReplace(String &ioString, const string_view &inSearch, const string_view &inReplace);
+
+/// Convert a delimited string to an array of strings
+JPH_EXPORT void StringToVector(const string_view &inString, Array<String> &outVector, const string_view &inDelimiter = ",", bool inClearVector = true);
+
+/// Convert an array strings to a delimited string
+JPH_EXPORT void VectorToString(const Array<String> &inVector, String &outString, const string_view &inDelimiter = ",");
+
+/// Convert a string to lower case
+JPH_EXPORT String ToLower(const string_view &inString);
+
+/// Converts the lower 4 bits of inNibble to a string that represents the number in binary format
+JPH_EXPORT const char *NibbleToBinary(uint32 inNibble);
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,209 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/NonCopyable.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Allocator for temporary allocations.
+/// This allocator works as a stack: The blocks must always be freed in the reverse order as they are allocated.
+/// Note that allocations and frees can take place from different threads, but the order is guaranteed though
+/// job dependencies, so it is not needed to use any form of locking.
+class JPH_EXPORT TempAllocator : public NonCopyable
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// If this allocator needs to fall back to aligned allocations because JPH_RVECTOR_ALIGNMENT is bigger than the platform default
+	static constexpr bool			needs_aligned_allocate = JPH_RVECTOR_ALIGNMENT > JPH_DEFAULT_ALLOCATE_ALIGNMENT;
+
+	/// Destructor
+	virtual							~TempAllocator() = default;
+
+	/// Allocates inSize bytes of memory, returned memory address must be JPH_RVECTOR_ALIGNMENT byte aligned
+	virtual void *					Allocate(uint inSize) = 0;
+
+	/// Frees inSize bytes of memory located at inAddress
+	virtual void					Free(void *inAddress, uint inSize) = 0;
+};
+
+/// Default implementation of the temp allocator that allocates a large block through malloc upfront
+class JPH_EXPORT TempAllocatorImpl final : public TempAllocator
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructs the allocator with a maximum allocatable size of inSize
+	explicit						TempAllocatorImpl(size_t inSize) : mSize(inSize)
+	{
+		if constexpr (needs_aligned_allocate)
+			mBase = static_cast<uint8 *>(AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT));
+		else
+			mBase = static_cast<uint8 *>(JPH::Allocate(inSize));
+	}
+
+	/// Destructor, frees the block
+	virtual							~TempAllocatorImpl() override
+	{
+		JPH_ASSERT(mTop == 0);
+		if constexpr (needs_aligned_allocate)
+			AlignedFree(mBase);
+		else
+			JPH::Free(mBase);
+	}
+
+	// See: TempAllocator
+	virtual void *					Allocate(uint inSize) override
+	{
+		if (inSize == 0)
+		{
+			return nullptr;
+		}
+		else
+		{
+			size_t new_top = mTop + AlignUp(inSize, JPH_RVECTOR_ALIGNMENT);
+			if (new_top > mSize)
+			{
+				Trace("TempAllocator: Out of memory trying to allocate %u bytes", inSize);
+				std::abort();
+			}
+			void *address = mBase + mTop;
+			mTop = new_top;
+			return address;
+		}
+	}
+
+	// See: TempAllocator
+	virtual void					Free(void *inAddress, uint inSize) override
+	{
+		if (inAddress == nullptr)
+		{
+			JPH_ASSERT(inSize == 0);
+		}
+		else
+		{
+			mTop -= AlignUp(inSize, JPH_RVECTOR_ALIGNMENT);
+			if (mBase + mTop != inAddress)
+			{
+				Trace("TempAllocator: Freeing in the wrong order");
+				std::abort();
+			}
+		}
+	}
+
+	/// Check if no allocations have been made
+	bool							IsEmpty() const
+	{
+		return mTop == 0;
+	}
+
+	/// Get the total size of the fixed buffer
+	size_t							GetSize() const
+	{
+		return mSize;
+	}
+
+	/// Get current usage in bytes of the buffer
+	size_t							GetUsage() const
+	{
+		return mTop;
+	}
+
+	/// Check if an allocation of inSize can be made in this fixed buffer allocator
+	bool							CanAllocate(uint inSize) const
+	{
+		return mTop + AlignUp(inSize, JPH_RVECTOR_ALIGNMENT) <= mSize;
+	}
+
+	/// Check if memory block at inAddress is owned by this allocator
+	bool							OwnsMemory(const void *inAddress) const
+	{
+		return inAddress >= mBase && inAddress < mBase + mSize;
+	}
+
+private:
+	uint8 *							mBase;							///< Base address of the memory block
+	size_t							mSize;							///< Size of the memory block
+	size_t							mTop = 0;						///< End of currently allocated area
+};
+
+/// Implementation of the TempAllocator that just falls back to malloc/free
+/// Note: This can be quite slow when running in the debugger as large memory blocks need to be initialized with 0xcd
+class JPH_EXPORT TempAllocatorMalloc final : public TempAllocator
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	// See: TempAllocator
+	virtual void *					Allocate(uint inSize) override
+	{
+		if (inSize > 0)
+		{
+			if constexpr (needs_aligned_allocate)
+				return AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT);
+			else
+				return JPH::Allocate(inSize);
+		}
+		else
+			return nullptr;
+	}
+
+	// See: TempAllocator
+	virtual void					Free(void *inAddress, [[maybe_unused]] uint inSize) override
+	{
+		if (inAddress != nullptr)
+		{
+			if constexpr (needs_aligned_allocate)
+				AlignedFree(inAddress);
+			else
+				JPH::Free(inAddress);
+		}
+	}
+};
+
+/// Implementation of the TempAllocator that tries to allocate from a large preallocated block, but falls back to malloc when it is exhausted
+class JPH_EXPORT TempAllocatorImplWithMallocFallback final : public TempAllocator
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructs the allocator with an initial fixed block if inSize
+	explicit						TempAllocatorImplWithMallocFallback(uint inSize) :
+		mAllocator(inSize)
+	{
+	}
+
+	// See: TempAllocator
+	virtual void *					Allocate(uint inSize) override
+	{
+		if (mAllocator.CanAllocate(inSize))
+			return mAllocator.Allocate(inSize);
+		else
+			return mFallbackAllocator.Allocate(inSize);
+	}
+
+	// See: TempAllocator
+	virtual void					Free(void *inAddress, uint inSize) override
+	{
+		if (inAddress == nullptr)
+		{
+			JPH_ASSERT(inSize == 0);
+		}
+		else
+		{
+			if (mAllocator.OwnsMemory(inAddress))
+				mAllocator.Free(inAddress, inSize);
+			else
+				mFallbackAllocator.Free(inAddress, inSize);
+		}
+	}
+
+private:
+	TempAllocatorImpl				mAllocator;
+	TempAllocatorMalloc				mFallbackAllocator;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,37 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Core/TickCounter.h>
+
+#if defined(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
+
+#if defined(JPH_PLATFORM_WINDOWS_UWP) || (defined(JPH_PLATFORM_WINDOWS) && defined(JPH_CPU_ARM))
+
+uint64 GetProcessorTickCount()
+{
+	LARGE_INTEGER count;
+	QueryPerformanceCounter(&count);
+	return uint64(count.QuadPart);
+}
+
+#endif // JPH_PLATFORM_WINDOWS_UWP || (JPH_PLATFORM_WINDOWS && JPH_CPU_ARM)
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,58 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// Include for __rdtsc
+#if defined(JPH_PLATFORM_WINDOWS)
+	#include <intrin.h>
+#elif defined(JPH_CPU_X86) && defined(JPH_COMPILER_GCC)
+	#include <x86intrin.h>
+#elif defined(JPH_CPU_E2K)
+	#include <x86intrin.h>
+#elif defined(JPH_CPU_LOONGARCH)
+	#include <larchintrin.h>
+#endif
+
+JPH_NAMESPACE_BEGIN
+
+#if defined(JPH_PLATFORM_WINDOWS_UWP) || (defined(JPH_PLATFORM_WINDOWS) && defined(JPH_CPU_ARM))
+
+/// Functionality to get the processors cycle counter
+uint64 GetProcessorTickCount(); // Not inline to avoid having to include Windows.h
+
+#else
+
+/// Functionality to get the processors cycle counter
+JPH_INLINE uint64 GetProcessorTickCount()
+{
+#if defined(JPH_PLATFORM_BLUE)
+	return JPH_PLATFORM_BLUE_GET_TICKS();
+#elif defined(JPH_CPU_X86)
+	return __rdtsc();
+#elif defined(JPH_CPU_E2K)
+	return __rdtsc();
+#elif defined(JPH_CPU_ARM) && defined(JPH_USE_NEON)
+	uint64 val;
+	asm volatile("mrs %0, cntvct_el0" : "=r" (val));
+	return val;
+#elif defined(JPH_CPU_LOONGARCH)
+	#if JPH_CPU_ARCH_BITS == 64
+		__drdtime_t t = __rdtime_d();
+		return t.dvalue;
+	#else
+		__rdtime_t h = __rdtimeh_w();
+		__rdtime_t l = __rdtimel_w();
+		return ((uint64)h.value << 32) + l.value;
+	#endif
+#elif defined(JPH_CPU_ARM) || defined(JPH_CPU_RISCV) || defined(JPH_CPU_WASM) || defined(JPH_CPU_PPC)
+	return 0; // Not supported
+#else
+	#error Undefined
+#endif
+}
+
+#endif // JPH_PLATFORM_WINDOWS_UWP || (JPH_PLATFORM_WINDOWS && JPH_CPU_ARM)
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,80 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/HashTable.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Internal helper class to provide context for UnorderedMap
+template <class Key, class Value>
+class UnorderedMapDetail
+{
+public:
+	/// Get key from key value pair
+	static const Key &			sGetKey(const std::pair<Key, Value> &inKeyValue)
+	{
+		return inKeyValue.first;
+	}
+};
+
+/// Hash Map class
+/// @tparam Key Key type
+/// @tparam Value Value type
+/// @tparam Hash Hash function (note should be 64-bits)
+/// @tparam KeyEqual Equality comparison function
+template <class Key, class Value, class Hash = JPH::Hash<Key>, class KeyEqual = std::equal_to<Key>>
+class UnorderedMap : public HashTable<Key, std::pair<Key, Value>, UnorderedMapDetail<Key, Value>, Hash, KeyEqual>
+{
+	using Base = HashTable<Key, std::pair<Key, Value>, UnorderedMapDetail<Key, Value>, Hash, KeyEqual>;
+
+public:
+	using size_type = typename Base::size_type;
+	using iterator = typename Base::iterator;
+	using const_iterator = typename Base::const_iterator;
+	using value_type = typename Base::value_type;
+
+	Value &						operator [] (const Key &inKey)
+	{
+		size_type index;
+		bool inserted = this->InsertKey(inKey, index);
+		value_type &key_value = this->GetElement(index);
+		if (inserted)
+			new (&key_value) value_type(inKey, Value());
+		return key_value.second;
+	}
+
+	template<class... Args>
+	std::pair<iterator, bool>	try_emplace(const Key &inKey, Args &&...inArgs)
+	{
+		size_type index;
+		bool inserted = this->InsertKey(inKey, index);
+		if (inserted)
+			new (&this->GetElement(index)) value_type(std::piecewise_construct, std::forward_as_tuple(inKey), std::forward_as_tuple(std::forward<Args>(inArgs)...));
+		return std::make_pair(iterator(this, index), inserted);
+	}
+
+	template<class... Args>
+	std::pair<iterator, bool>	try_emplace(Key &&inKey, Args &&...inArgs)
+	{
+		size_type index;
+		bool inserted = this->InsertKey(inKey, index);
+		if (inserted)
+			new (&this->GetElement(index)) value_type(std::piecewise_construct, std::forward_as_tuple(std::move(inKey)), std::forward_as_tuple(std::forward<Args>(inArgs)...));
+		return std::make_pair(iterator(this, index), inserted);
+	}
+
+	/// Const version of find
+	using Base::find;
+
+	/// Non-const version of find
+	iterator					find(const Key &inKey)
+	{
+		const_iterator it = Base::find(inKey);
+		return iterator(this, it.mIndex);
+	}
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,32 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/HashTable.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Internal helper class to provide context for UnorderedSet
+template <class Key>
+class UnorderedSetDetail
+{
+public:
+	/// The key is the key, just return it
+	static const Key &		sGetKey(const Key &inKey)
+	{
+		return inKey;
+	}
+};
+
+/// Hash Set class
+/// @tparam Key Key type
+/// @tparam Hash Hash function (note should be 64-bits)
+/// @tparam KeyEqual Equality comparison function
+template <class Key, class Hash = JPH::Hash<Key>, class KeyEqual = std::equal_to<Key>>
+class UnorderedSet : public HashTable<Key, Key, UnorderedSetDetail<Key>, Hash, KeyEqual>
+{
+};
+
+JPH_NAMESPACE_END