@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,143 +0,0 @@
-// 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
-
-#if defined(JPH_CPU_WASM)
-
-// Not supported
-
-#elif defined(JPH_USE_SSE)
-
-/// Helper class that needs to be put on the stack to update the state of the floating point control word.
-/// This state is kept per thread.
-template <uint Value, uint Mask>
-class FPControlWord : public NonCopyable
-{
-public:
-				FPControlWord()
-	{
-		mPrevState = _mm_getcsr();
-		_mm_setcsr((mPrevState & ~Mask) | Value);
-	}
-
-				~FPControlWord()
-	{
-		_mm_setcsr((_mm_getcsr() & ~Mask) | (mPrevState & Mask));
-	}
-
-private:
-	uint		mPrevState;
-};
-
-#elif defined(JPH_CPU_ARM) && defined(JPH_COMPILER_MSVC)
-
-/// Helper class that needs to be put on the stack to update the state of the floating point control word.
-/// This state is kept per thread.
-template <unsigned int Value, unsigned int Mask>
-class FPControlWord : public NonCopyable
-{
-public:
-				FPControlWord()
-	{
-		// Read state before change
-		_controlfp_s(&mPrevState, 0, 0);
-
-		// Update the state
-		unsigned int dummy;
-		_controlfp_s(&dummy, Value, Mask);
-	}
-
-				~FPControlWord()
-	{
-		// Restore state
-		unsigned int dummy;
-		_controlfp_s(&dummy, mPrevState, Mask);
-	}
-
-private:
-	unsigned int mPrevState;
-};
-
-#elif defined(JPH_CPU_ARM) && defined(JPH_USE_NEON)
-
-/// Helper class that needs to be put on the stack to update the state of the floating point control word.
-/// This state is kept per thread.
-template <uint64 Value, uint64 Mask>
-class FPControlWord : public NonCopyable
-{
-public:
-				FPControlWord()
-	{
-		uint64 val;
-		asm volatile("mrs %0, fpcr" : "=r" (val));
-		mPrevState = val;
-		val &= ~Mask;
-		val |= Value;
-		asm volatile("msr fpcr, %0" : /* no output */ : "r" (val));
-	}
-
-				~FPControlWord()
-	{
-		uint64 val;
-		asm volatile("mrs %0, fpcr" : "=r" (val));
-		val &= ~Mask;
-		val |= mPrevState & Mask;
-		asm volatile("msr fpcr, %0" : /* no output */ : "r" (val));
-	}
-
-private:
-	uint64		mPrevState;
-};
-
-#elif defined(JPH_CPU_ARM)
-
-/// Helper class that needs to be put on the stack to update the state of the floating point control word.
-/// This state is kept per thread.
-template <uint32 Value, uint32 Mask>
-class FPControlWord : public NonCopyable
-{
-public:
-	FPControlWord()
-	{
-		uint32 val;
-		asm volatile("vmrs %0, fpscr" : "=r" (val));
-		mPrevState = val;
-		val &= ~Mask;
-		val |= Value;
-		asm volatile("vmsr fpscr, %0" : /* no output */ : "r" (val));
-	}
-
-	~FPControlWord()
-	{
-		uint32 val;
-		asm volatile("vmrs %0, fpscr" : "=r" (val));
-		val &= ~Mask;
-		val |= mPrevState & Mask;
-		asm volatile("vmsr fpscr, %0" : /* no output */ : "r" (val));
-	}
-
-private:
-	uint32		mPrevState;
-};
-
-#elif defined(JPH_CPU_RISCV)
-
-// RISC-V only implements manually checking if exceptions occurred by reading the fcsr register. It doesn't generate exceptions.
-
-#elif defined(JPH_CPU_PPC) || defined(JPH_CPU_LOONGARCH)
-
-// Not implemented right now
-
-#else
-
-#error Unsupported CPU architecture
-
-#endif
-
-JPH_NAMESPACE_END

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

@@ -1,96 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/FPControlWord.h>
-
-JPH_NAMESPACE_BEGIN
-
-#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
-
-#if defined(JPH_CPU_WASM)
-
-// Not supported
-class FPExceptionsEnable { };
-class FPExceptionDisableInvalid { };
-class FPExceptionDisableDivByZero { };
-class FPExceptionDisableOverflow { };
-
-#elif defined(JPH_USE_SSE)
-
-/// Enable floating point divide by zero exception, overflow exceptions and exceptions on invalid numbers
-class FPExceptionsEnable : public FPControlWord<0, _MM_MASK_DIV_ZERO | _MM_MASK_INVALID | _MM_MASK_OVERFLOW> { };
-
-/// Disable invalid floating point value exceptions
-class FPExceptionDisableInvalid : public FPControlWord<_MM_MASK_INVALID, _MM_MASK_INVALID> { };
-
-/// Disable division by zero floating point exceptions
-class FPExceptionDisableDivByZero : public FPControlWord<_MM_MASK_DIV_ZERO, _MM_MASK_DIV_ZERO> { };
-
-/// Disable floating point overflow exceptions
-class FPExceptionDisableOverflow : public FPControlWord<_MM_MASK_OVERFLOW, _MM_MASK_OVERFLOW> { };
-
-#elif defined(JPH_CPU_ARM) && defined(JPH_COMPILER_MSVC)
-
-/// Enable floating point divide by zero exception, overflow exceptions and exceptions on invalid numbers
-class FPExceptionsEnable : public FPControlWord<0, _EM_INVALID | _EM_ZERODIVIDE | _EM_OVERFLOW> { };
-
-/// Disable invalid floating point value exceptions
-class FPExceptionDisableInvalid : public FPControlWord<_EM_INVALID, _EM_INVALID> { };
-
-/// Disable division by zero floating point exceptions
-class FPExceptionDisableDivByZero : public FPControlWord<_EM_ZERODIVIDE, _EM_ZERODIVIDE> { };
-
-/// Disable floating point overflow exceptions
-class FPExceptionDisableOverflow : public FPControlWord<_EM_OVERFLOW, _EM_OVERFLOW> { };
-
-#elif defined(JPH_CPU_ARM)
-
-/// Invalid operation exception bit
-static constexpr uint64 FP_IOE = 1 << 8;
-
-/// Enable divide by zero exception bit
-static constexpr uint64 FP_DZE = 1 << 9;
-
-/// Enable floating point overflow bit
-static constexpr uint64 FP_OFE = 1 << 10;
-
-/// Enable floating point divide by zero exception, overflow exceptions and exceptions on invalid numbers
-class FPExceptionsEnable : public FPControlWord<FP_IOE | FP_DZE | FP_OFE, FP_IOE | FP_DZE | FP_OFE> { };
-
-/// Disable invalid floating point value exceptions
-class FPExceptionDisableInvalid : public FPControlWord<0, FP_IOE> { };
-
-/// Disable division by zero floating point exceptions
-class FPExceptionDisableDivByZero : public FPControlWord<0, FP_DZE> { };
-
-/// Disable floating point overflow exceptions
-class FPExceptionDisableOverflow : public FPControlWord<0, FP_OFE> { };
-
-#elif defined(JPH_CPU_RISCV)
-
-#error "RISC-V only implements manually checking if exceptions occurred by reading the fcsr register. It doesn't generate exceptions. JPH_FLOATING_POINT_EXCEPTIONS_ENABLED must be disabled."
-
-#elif defined(JPH_CPU_PPC)
-
-#error PowerPC floating point exception handling to be implemented. JPH_FLOATING_POINT_EXCEPTIONS_ENABLED must be disabled.
-
-#else
-
-#error Unsupported CPU architecture
-
-#endif
-
-#else
-
-/// Dummy implementations
-class FPExceptionsEnable { };
-class FPExceptionDisableInvalid { };
-class FPExceptionDisableDivByZero { };
-class FPExceptionDisableOverflow { };
-
-#endif
-
-JPH_NAMESPACE_END

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

@@ -1,43 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/FPControlWord.h>
-
-JPH_NAMESPACE_BEGIN
-
-#if defined(JPH_CPU_WASM) || defined(JPH_CPU_RISCV) || defined(JPH_CPU_PPC) || defined(JPH_CPU_LOONGARCH)
-
-// Not supported
-class FPFlushDenormals { };
-
-#elif defined(JPH_USE_SSE)
-
-/// Helper class that needs to be put on the stack to enable flushing denormals to zero
-/// This can make floating point operations much faster when working with very small numbers
-class FPFlushDenormals : public FPControlWord<_MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_MASK> { };
-
-#elif defined(JPH_CPU_ARM) && defined(JPH_COMPILER_MSVC)
-
-/// Helper class that needs to be put on the stack to enable flushing denormals to zero
-/// This can make floating point operations much faster when working with very small numbers
-class FPFlushDenormals : public FPControlWord<_DN_FLUSH, _MCW_DN> { };
-
-#elif defined(JPH_CPU_ARM)
-
-/// Flush denormals to zero bit
-static constexpr uint64 FP_FZ = 1 << 24;
-
-/// Helper class that needs to be put on the stack to enable flushing denormals to zero
-/// This can make floating point operations much faster when working with very small numbers
-class FPFlushDenormals : public FPControlWord<FP_FZ, FP_FZ> { };
-
-#else
-
-#error Unsupported CPU architecture
-
-#endif
-
-JPH_NAMESPACE_END

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

@@ -1,92 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Core/Factory.h>
-
-JPH_NAMESPACE_BEGIN
-
-Factory *Factory::sInstance = nullptr;
-
-void *Factory::CreateObject(const char *inName)
-{
-	const RTTI *ci = Find(inName);
-	return ci != nullptr? ci->CreateObject() : nullptr;
-}
-
-const RTTI *Factory::Find(const char *inName)
-{
-	ClassNameMap::iterator c = mClassNameMap.find(inName);
-	return c != mClassNameMap.end()? c->second : nullptr;
-}
-
-const RTTI *Factory::Find(uint32 inHash)
-{
-	ClassHashMap::iterator c = mClassHashMap.find(inHash);
-	return c != mClassHashMap.end()? c->second : nullptr;
-}
-
-bool Factory::Register(const RTTI *inRTTI)
-{
-	// Check if we already know the type
-	if (Find(inRTTI->GetName()) != nullptr)
-		return true;
-
-	// Insert this class by name
-	mClassNameMap.try_emplace(inRTTI->GetName(), inRTTI);
-
-	// Insert this class by hash
-	if (!mClassHashMap.try_emplace(inRTTI->GetHash(), inRTTI).second)
-	{
-		JPH_ASSERT(false, "Hash collision registering type!");
-		return false;
-	}
-
-	// Register base classes
-	for (int i = 0; i < inRTTI->GetBaseClassCount(); ++i)
-		if (!Register(inRTTI->GetBaseClass(i)))
-			return false;
-
-#ifdef JPH_OBJECT_STREAM
-	// Register attribute classes
-	for (int i = 0; i < inRTTI->GetAttributeCount(); ++i)
-	{
-		const RTTI *rtti = inRTTI->GetAttribute(i).GetMemberPrimitiveType();
-		if (rtti != nullptr && !Register(rtti))
-			return false;
-	}
-#endif // JPH_OBJECT_STREAM
-
-	return true;
-}
-
-bool Factory::Register(const RTTI **inRTTIs, uint inNumber)
-{
-	mClassHashMap.reserve(mClassHashMap.size() + inNumber);
-	mClassNameMap.reserve(mClassNameMap.size() + inNumber);
-
-	for (const RTTI **rtti = inRTTIs; rtti < inRTTIs + inNumber; ++rtti)
-		if (!Register(*rtti))
-			return false;
-
-	return true;
-}
-
-void Factory::Clear()
-{
-	mClassNameMap.clear();
-	mClassHashMap.clear();
-}
-
-Array<const RTTI *> Factory::GetAllClasses() const
-{
-	Array<const RTTI *> all_classes;
-	all_classes.reserve(mClassNameMap.size());
-	for (const ClassNameMap::value_type &c : mClassNameMap)
-		all_classes.push_back(c.second);
-	return all_classes;
-}
-
-JPH_NAMESPACE_END

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

@@ -1,54 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/RTTI.h>
-#include <Jolt/Core/UnorderedMap.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// This class is responsible for creating instances of classes based on their name or hash and is mainly used for deserialization of saved data.
-class JPH_EXPORT Factory
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Create an object
-	void *						CreateObject(const char *inName);
-
-	/// Find type info for a specific class by name
-	const RTTI *				Find(const char *inName);
-
-	/// Find type info for a specific class by hash
-	const RTTI *				Find(uint32 inHash);
-
-	/// Register an object with the factory. Returns false on failure.
-	bool						Register(const RTTI *inRTTI);
-
-	/// Register a list of objects with the factory. Returns false on failure.
-	bool						Register(const RTTI **inRTTIs, uint inNumber);
-
-	/// Unregisters all types
-	void						Clear();
-
-	/// Get all registered classes
-	Array<const RTTI *>			GetAllClasses() const;
-
-	/// Singleton factory instance
-	static Factory *			sInstance;
-
-private:
-	using ClassNameMap = UnorderedMap<string_view, const RTTI *>;
-
-	using ClassHashMap = UnorderedMap<uint32, const RTTI *>;
-
-	/// Map of class names to type info
-	ClassNameMap				mClassNameMap;
-
-	// Map of class hash to type info
-	ClassHashMap				mClassHashMap;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,122 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/NonCopyable.h>
-#include <Jolt/Core/Mutex.h>
-#include <Jolt/Core/Atomics.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Class that allows lock free creation / destruction of objects (unless a new page of objects needs to be allocated)
-/// It contains a fixed pool of objects and also allows batching up a lot of objects to be destroyed
-/// and doing the actual free in a single atomic operation
-template <typename Object>
-class FixedSizeFreeList : public NonCopyable
-{
-private:
-	/// Storage type for an Object
-	struct ObjectStorage
-	{
-		/// The object we're storing
-		Object				mObject;
-
-		/// When the object is freed (or in the process of being freed as a batch) this will contain the next free object
-		/// When an object is in use it will contain the object's index in the free list
-		atomic<uint32>		mNextFreeObject;
-	};
-
-	static_assert(alignof(ObjectStorage) == alignof(Object), "Object not properly aligned");
-
-	/// Access the object storage given the object index
-	const ObjectStorage &	GetStorage(uint32 inObjectIndex) const	{ return mPages[inObjectIndex >> mPageShift][inObjectIndex & mObjectMask]; }
-	ObjectStorage &			GetStorage(uint32 inObjectIndex)		{ return mPages[inObjectIndex >> mPageShift][inObjectIndex & mObjectMask]; }
-
-	/// Size (in objects) of a single page
-	uint32					mPageSize;
-
-	/// Number of bits to shift an object index to the right to get the page number
-	uint32					mPageShift;
-
-	/// Mask to and an object index with to get the page number
-	uint32					mObjectMask;
-
-	/// Total number of pages that are usable
-	uint32					mNumPages;
-
-	/// Total number of objects that have been allocated
-	uint32					mNumObjectsAllocated;
-
-	/// Array of pages of objects
-	ObjectStorage **		mPages = nullptr;
-
-	/// Mutex that is used to allocate a new page if the storage runs out
-	/// This variable is aligned to the cache line to prevent false sharing with
-	/// the constants used to index into the list via `Get()`.
-	alignas(JPH_CACHE_LINE_SIZE) Mutex mPageMutex;
-
-	/// Number of objects that we currently have in the free list / new pages
-#ifdef JPH_ENABLE_ASSERTS
-	atomic<uint32>			mNumFreeObjects;
-#endif // JPH_ENABLE_ASSERTS
-
-	/// Simple counter that makes the first free object pointer update with every CAS so that we don't suffer from the ABA problem
-	atomic<uint32>			mAllocationTag;
-
-	/// Index of first free object, the first 32 bits of an object are used to point to the next free object
-	atomic<uint64>			mFirstFreeObjectAndTag;
-
-	/// The first free object to use when the free list is empty (may need to allocate a new page)
-	atomic<uint32>			mFirstFreeObjectInNewPage;
-
-public:
-	/// Invalid index
-	static const uint32		cInvalidObjectIndex = 0xffffffff;
-
-	/// Size of an object + bookkeeping for the freelist
-	static const int		ObjectStorageSize = sizeof(ObjectStorage);
-
-	/// Destructor
-	inline					~FixedSizeFreeList();
-
-	/// Initialize the free list, up to inMaxObjects can be allocated
-	inline void				Init(uint inMaxObjects, uint inPageSize);
-
-	/// Lockless construct a new object, inParameters are passed on to the constructor
-	template <typename... Parameters>
-	inline uint32			ConstructObject(Parameters &&... inParameters);
-
-	/// Lockless destruct an object and return it to the free pool
-	inline void				DestructObject(uint32 inObjectIndex);
-
-	/// Lockless destruct an object and return it to the free pool
-	inline void				DestructObject(Object *inObject);
-
-	/// A batch of objects that can be destructed
-	struct Batch
-	{
-		uint32				mFirstObjectIndex = cInvalidObjectIndex;
-		uint32				mLastObjectIndex = cInvalidObjectIndex;
-		uint32				mNumObjects = 0;
-	};
-
-	/// Add a object to an existing batch to be destructed.
-	/// Adding objects to a batch does not destroy or modify the objects, this will merely link them
-	/// so that the entire batch can be returned to the free list in a single atomic operation
-	inline void				AddObjectToBatch(Batch &ioBatch, uint32 inObjectIndex);
-
-	/// Lockless destruct batch of objects
-	inline void				DestructObjectBatch(Batch &ioBatch);
-
-	/// Access an object by index.
-	inline Object &			Get(uint32 inObjectIndex)				{ return GetStorage(inObjectIndex).mObject; }
-
-	/// Access an object by index.
-	inline const Object &	Get(uint32 inObjectIndex) const			{ return GetStorage(inObjectIndex).mObject; }
-};
-
-JPH_NAMESPACE_END
-
-#include "FixedSizeFreeList.inl"