@bloomengine/engine 0.4.0 → 0.4.1

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

@@ -1,329 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/HashCombine.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Simple variable length array backed by a fixed size buffer
-template <class T, uint N>
-class [[nodiscard]] StaticArray
-{
-public:
-	using value_type = T;
-
-	using size_type = uint;
-
-	static constexpr uint Capacity = N;
-
-	/// Default constructor
-						StaticArray() = default;
-
-	/// Constructor from initializer list
-	explicit			StaticArray(std::initializer_list<T> inList)
-	{
-		JPH_ASSERT(inList.size() <= N);
-		for (const T &v : inList)
-			new (reinterpret_cast<T *>(&mElements[mSize++])) T(v);
-	}
-
-	/// Copy constructor
-						StaticArray(const StaticArray<T, N> &inRHS)
-	{
-		while (mSize < inRHS.mSize)
-		{
-			new (&mElements[mSize]) T(inRHS[mSize]);
-			++mSize;
-		}
-	}
-
-	/// Destruct all elements
-						~StaticArray()
-	{
-		if constexpr (!std::is_trivially_destructible<T>())
-			for (T *e = reinterpret_cast<T *>(mElements), *end = e + mSize; e < end; ++e)
-				e->~T();
-	}
-
-	/// Destruct all elements and set length to zero
-	void				clear()
-	{
-		if constexpr (!std::is_trivially_destructible<T>())
-			for (T *e = reinterpret_cast<T *>(mElements), *end = e + mSize; e < end; ++e)
-				e->~T();
-		mSize = 0;
-	}
-
-	/// Add element to the back of the array
-	void				push_back(const T &inElement)
-	{
-		JPH_ASSERT(mSize < N);
-		new (&mElements[mSize++]) T(inElement);
-	}
-
-	/// Construct element at the back of the array
-	template <class... A>
-	void				emplace_back(A &&... inElement)
-	{
-		JPH_ASSERT(mSize < N);
-		new (&mElements[mSize++]) T(std::forward<A>(inElement)...);
-	}
-
-	/// Remove element from the back of the array
-	void				pop_back()
-	{
-		JPH_ASSERT(mSize > 0);
-		reinterpret_cast<T &>(mElements[--mSize]).~T();
-	}
-
-	/// Returns true if there are no elements in the array
-	bool				empty() const
-	{
-		return mSize == 0;
-	}
-
-	/// Returns amount of elements in the array
-	size_type			size() const
-	{
-		return mSize;
-	}
-
-	/// Returns maximum amount of elements the array can hold
-	size_type			capacity() const
-	{
-		return N;
-	}
-
-	/// Resize array to new length
-	void				resize(size_type inNewSize)
-	{
-		JPH_ASSERT(inNewSize <= N);
-		if constexpr (!std::is_trivially_constructible<T>())
-			for (T *element = reinterpret_cast<T *>(mElements) + mSize, *element_end = reinterpret_cast<T *>(mElements) + inNewSize; element < element_end; ++element)
-				new (element) T;
-		if constexpr (!std::is_trivially_destructible<T>())
-			for (T *element = reinterpret_cast<T *>(mElements) + inNewSize, *element_end = reinterpret_cast<T *>(mElements) + mSize; element < element_end; ++element)
-				element->~T();
-		mSize = inNewSize;
-	}
-
-	using const_iterator = const T *;
-
-	/// Iterators
-	const_iterator		begin() const
-	{
-		return reinterpret_cast<const T *>(mElements);
-	}
-
-	const_iterator		end() const
-	{
-		return reinterpret_cast<const T *>(mElements + mSize);
-	}
-
-	using iterator = T *;
-
-	iterator			begin()
-	{
-		return reinterpret_cast<T *>(mElements);
-	}
-
-	iterator			end()
-	{
-		return reinterpret_cast<T *>(mElements + mSize);
-	}
-
-	const T *			data() const
-	{
-		return reinterpret_cast<const T *>(mElements);
-	}
-
-	T *					data()
-	{
-		return reinterpret_cast<T *>(mElements);
-	}
-
-	/// Access element
-	T &					operator [] (size_type inIdx)
-	{
-		JPH_ASSERT(inIdx < mSize);
-		return reinterpret_cast<T &>(mElements[inIdx]);
-	}
-
-	const T &			operator [] (size_type inIdx) const
-	{
-		JPH_ASSERT(inIdx < mSize);
-		return reinterpret_cast<const T &>(mElements[inIdx]);
-	}
-
-	/// Access element
-	T &					at(size_type inIdx)
-	{
-		JPH_ASSERT(inIdx < mSize);
-		return reinterpret_cast<T &>(mElements[inIdx]);
-	}
-
-	const T &			at(size_type inIdx) const
-	{
-		JPH_ASSERT(inIdx < mSize);
-		return reinterpret_cast<const T &>(mElements[inIdx]);
-	}
-
-	/// First element in the array
-	const T &			front() const
-	{
-		JPH_ASSERT(mSize > 0);
-		return reinterpret_cast<const T &>(mElements[0]);
-	}
-
-	T &					front()
-	{
-		JPH_ASSERT(mSize > 0);
-		return reinterpret_cast<T &>(mElements[0]);
-	}
-
-	/// Last element in the array
-	const T &			back() const
-	{
-		JPH_ASSERT(mSize > 0);
-		return reinterpret_cast<const T &>(mElements[mSize - 1]);
-	}
-
-	T &					back()
-	{
-		JPH_ASSERT(mSize > 0);
-		return reinterpret_cast<T &>(mElements[mSize - 1]);
-	}
-
-	/// Remove one element from the array
-	void				erase(const_iterator inIter)
-	{
-		size_type p = size_type(inIter - begin());
-		JPH_ASSERT(p < mSize);
-		reinterpret_cast<T &>(mElements[p]).~T();
-		if (p + 1 < mSize)
-			memmove(mElements + p, mElements + p + 1, (mSize - p - 1) * sizeof(T));
-		--mSize;
-	}
-
-	/// Remove multiple element from the array
-	void				erase(const_iterator inBegin, const_iterator inEnd)
-	{
-		size_type p = size_type(inBegin - begin());
-		size_type n = size_type(inEnd - inBegin);
-		JPH_ASSERT(inEnd <= end());
-		for (size_type i = 0; i < n; ++i)
-			reinterpret_cast<T &>(mElements[p + i]).~T();
-		if (p + n < mSize)
-			memmove(mElements + p, mElements + p + n, (mSize - p - n) * sizeof(T));
-		mSize -= n;
-	}
-
-	/// Assignment operator
-	StaticArray<T, N> &	operator = (const StaticArray<T, N> &inRHS)
-	{
-		size_type rhs_size = inRHS.size();
-
-		if (static_cast<const void *>(this) != static_cast<const void *>(&inRHS))
-		{
-			clear();
-
-			while (mSize < rhs_size)
-			{
-				new (&mElements[mSize]) T(inRHS[mSize]);
-				++mSize;
-			}
-		}
-
-		return *this;
-	}
-
-	/// Assignment operator with static array of different max length
-	template <uint M>
-	StaticArray<T, N> &	operator = (const StaticArray<T, M> &inRHS)
-	{
-		size_type rhs_size = inRHS.size();
-		JPH_ASSERT(rhs_size <= N);
-
-		if (static_cast<const void *>(this) != static_cast<const void *>(&inRHS))
-		{
-			clear();
-
-			while (mSize < rhs_size)
-			{
-				new (&mElements[mSize]) T(inRHS[mSize]);
-				++mSize;
-			}
-		}
-
-		return *this;
-	}
-
-	/// Comparing arrays
-	bool				operator == (const StaticArray<T, N> &inRHS) const
-	{
-		if (mSize != inRHS.mSize)
-			return false;
-		for (size_type i = 0; i < mSize; ++i)
-			if (!(reinterpret_cast<const T &>(mElements[i]) == reinterpret_cast<const T &>(inRHS.mElements[i])))
-				return false;
-		return true;
-	}
-
-	bool				operator != (const StaticArray<T, N> &inRHS) const
-	{
-		if (mSize != inRHS.mSize)
-			return true;
-		for (size_type i = 0; i < mSize; ++i)
-			if (reinterpret_cast<const T &>(mElements[i]) != reinterpret_cast<const T &>(inRHS.mElements[i]))
-				return true;
-		return false;
-	}
-
-	/// Get hash for this array
-	uint64					GetHash() const
-	{
-		// Hash length first
-		uint64 ret = Hash<uint32> { } (uint32(size()));
-
-		// Then hash elements
-		for (const T *element = reinterpret_cast<const T *>(mElements), *element_end = reinterpret_cast<const T *>(mElements) + mSize; element < element_end; ++element)
-			HashCombine(ret, *element);
-
-		return ret;
-	}
-
-protected:
-	struct alignas(T) Storage
-	{
-		uint8			mData[sizeof(T)];
-	};
-
-	static_assert(sizeof(T) == sizeof(Storage), "Mismatch in size");
-	static_assert(alignof(T) == alignof(Storage), "Mismatch in alignment");
-
-	size_type			mSize = 0;
-	Storage				mElements[N];
-};
-
-JPH_NAMESPACE_END
-
-JPH_SUPPRESS_WARNING_PUSH
-JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
-
-namespace std
-{
-	/// Declare std::hash for StaticArray
-	template <class T, JPH::uint N>
-	struct hash<JPH::StaticArray<T, N>>
-	{
-		size_t operator () (const JPH::StaticArray<T, N> &inRHS) const
-		{
-			return std::size_t(inRHS.GetHash());
-		}
-	};
-}
-
-JPH_SUPPRESS_WARNING_POP

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

@@ -1,120 +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
-
-/// Simple binary input stream
-class JPH_EXPORT StreamIn : public NonCopyable
-{
-public:
-	/// Virtual destructor
-	virtual				~StreamIn() = default;
-
-	/// Read a string of bytes from the binary stream
-	virtual void		ReadBytes(void *outData, size_t inNumBytes) = 0;
-
-	/// Returns true when an attempt has been made to read past the end of the file.
-	/// Note that this follows the convention of std::basic_ios::eof which only returns true when an attempt is made to read past the end, not when the read pointer is at the end.
-	virtual bool		IsEOF() const = 0;
-
-	/// Returns true if there was an IO failure
-	virtual bool		IsFailed() const = 0;
-
-	/// Read a primitive (e.g. float, int, etc.) from the binary stream
-	template <class T, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
-	void				Read(T &outT)
-	{
-		ReadBytes(&outT, sizeof(outT));
-	}
-
-	/// Read a vector of primitives from the binary stream
-	template <class T, class A, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
-	void				Read(Array<T, A> &outT)
-	{
-		uint32 len = uint32(outT.size()); // Initialize to previous array size, this is used for validation in the StateRecorder class
-		Read(len);
-		if (!IsEOF() && !IsFailed())
-		{
-			outT.resize(len);
-			if constexpr (std::is_same_v<T, Vec3> || std::is_same_v<T, DVec3> || std::is_same_v<T, DMat44>)
-			{
-				// These types have unused components that we don't want to read
-				for (typename Array<T, A>::size_type i = 0; i < len; ++i)
-					Read(outT[i]);
-			}
-			else
-			{
-				// Read all elements at once
-				ReadBytes(outT.data(), len * sizeof(T));
-			}
-		}
-		else
-			outT.clear();
-	}
-
-	/// Read a string from the binary stream (reads the number of characters and then the characters)
-	template <class Type, class Traits, class Allocator>
-	void				Read(std::basic_string<Type, Traits, Allocator> &outString)
-	{
-		uint32 len = 0;
-		Read(len);
-		if (!IsEOF() && !IsFailed())
-		{
-			outString.resize(len);
-			ReadBytes(outString.data(), len * sizeof(Type));
-		}
-		else
-			outString.clear();
-	}
-
-	/// Read a vector of primitives from the binary stream using a custom function to read the elements
-	template <class T, class A, typename F>
-	void				Read(Array<T, A> &outT, const F &inReadElement)
-	{
-		uint32 len = uint32(outT.size()); // Initialize to previous array size, this is used for validation in the StateRecorder class
-		Read(len);
-		if (!IsEOF() && !IsFailed())
-		{
-			outT.resize(len);
-			for (typename Array<T, A>::size_type i = 0; i < len; ++i)
-				inReadElement(*this, outT[i]);
-		}
-		else
-			outT.clear();
-	}
-
-	/// Read a Vec3 (don't read W)
-	void				Read(Vec3 &outVec)
-	{
-		ReadBytes(&outVec, 3 * sizeof(float));
-		outVec = Vec3::sFixW(outVec.mValue);
-	}
-
-	/// Read a DVec3 (don't read W)
-	void				Read(DVec3 &outVec)
-	{
-		ReadBytes(&outVec, 3 * sizeof(double));
-		outVec = DVec3::sFixW(outVec.mValue);
-	}
-
-	/// Read a DMat44 (don't read W component of translation)
-	void				Read(DMat44 &outVec)
-	{
-		Vec4 x, y, z;
-		Read(x);
-		Read(y);
-		Read(z);
-
-		DVec3 t;
-		Read(t);
-
-		outVec = DMat44(x, y, z, t);
-	}
-};
-
-JPH_NAMESPACE_END

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

@@ -1,97 +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
-
-/// Simple binary output stream
-class JPH_EXPORT StreamOut : public NonCopyable
-{
-public:
-	/// Virtual destructor
-	virtual				~StreamOut() = default;
-
-	/// Write a string of bytes to the binary stream
-	virtual void		WriteBytes(const void *inData, size_t inNumBytes) = 0;
-
-	/// Returns true if there was an IO failure
-	virtual bool		IsFailed() const = 0;
-
-	/// Write a primitive (e.g. float, int, etc.) to the binary stream
-	template <class T, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
-	void				Write(const T &inT)
-	{
-		WriteBytes(&inT, sizeof(inT));
-	}
-
-	/// Write a vector of primitives to the binary stream
-	template <class T, class A, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
-	void				Write(const Array<T, A> &inT)
-	{
-		uint32 len = uint32(inT.size());
-		Write(len);
-		if (!IsFailed())
-		{
-			if constexpr (std::is_same_v<T, Vec3> || std::is_same_v<T, DVec3> || std::is_same_v<T, DMat44>)
-			{
-				// These types have unused components that we don't want to write
-				for (typename Array<T, A>::size_type i = 0; i < len; ++i)
-					Write(inT[i]);
-			}
-			else
-			{
-				// Write all elements at once
-				WriteBytes(inT.data(), len * sizeof(T));
-			}
-		}
-	}
-
-	/// Write a string to the binary stream (writes the number of characters and then the characters)
-	template <class Type, class Traits, class Allocator>
-	void				Write(const std::basic_string<Type, Traits, Allocator> &inString)
-	{
-		uint32 len = uint32(inString.size());
-		Write(len);
-		if (!IsFailed())
-			WriteBytes(inString.data(), len * sizeof(Type));
-	}
-
-	/// Write a vector of primitives to the binary stream using a custom write function
-	template <class T, class A, typename F>
-	void				Write(const Array<T, A> &inT, const F &inWriteElement)
-	{
-		uint32 len = uint32(inT.size());
-		Write(len);
-		if (!IsFailed())
-			for (typename Array<T, A>::size_type i = 0; i < len; ++i)
-				inWriteElement(inT[i], *this);
-	}
-
-	/// Write a Vec3 (don't write W)
-	void				Write(const Vec3 &inVec)
-	{
-		WriteBytes(&inVec, 3 * sizeof(float));
-	}
-
-	/// Write a DVec3 (don't write W)
-	void				Write(const DVec3 &inVec)
-	{
-		WriteBytes(&inVec, 3 * sizeof(double));
-	}
-
-	/// Write a DMat44 (don't write W component of translation)
-	void				Write(const DMat44 &inVec)
-	{
-		Write(inVec.GetColumn4(0));
-		Write(inVec.GetColumn4(1));
-		Write(inVec.GetColumn4(2));
-
-		Write(inVec.GetTranslation());
-	}
-};
-
-JPH_NAMESPACE_END

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

@@ -1,168 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/Result.h>
-#include <Jolt/Core/StreamIn.h>
-#include <Jolt/Core/StreamOut.h>
-#include <Jolt/Core/UnorderedMap.h>
-#include <Jolt/Core/Factory.h>
-
-JPH_NAMESPACE_BEGIN
-
-namespace StreamUtils {
-
-template <class Type>
-using ObjectToIDMap = UnorderedMap<const Type *, uint32>;
-
-template <class Type>
-using IDToObjectMap = Array<Ref<Type>>;
-
-// Restore a single object by reading the hash of the type, constructing it and then calling the restore function
-template <class Type>
-Result<Ref<Type>>	RestoreObject(StreamIn &inStream, void (Type::*inRestoreBinaryStateFunction)(StreamIn &))
-{
-	Result<Ref<Type>> result;
-
-	// Read the hash of the type
-	uint32 hash;
-	inStream.Read(hash);
-	if (inStream.IsEOF() || inStream.IsFailed())
-	{
-		result.SetError("Failed to read type hash");
-		return result;
-	}
-
-	// Get the RTTI for the type
-	const RTTI *rtti = Factory::sInstance->Find(hash);
-	if (rtti == nullptr)
-	{
-		result.SetError("Failed to create instance of type");
-		return result;
-	}
-
-	// Construct and read the data of the type
-	Ref<Type> object = reinterpret_cast<Type *>(rtti->CreateObject());
-	(object->*inRestoreBinaryStateFunction)(inStream);
-	if (inStream.IsEOF() || inStream.IsFailed())
-	{
-		result.SetError("Failed to restore object");
-		return result;
-	}
-
-	result.Set(object);
-	return result;
-}
-
-/// Save an object reference to a stream. Uses a map to map objects to IDs which is also used to prevent writing duplicates.
-template <class Type>
-void				SaveObjectReference(StreamOut &inStream, const Type *inObject, ObjectToIDMap<Type> *ioObjectToIDMap)
-{
-	if (ioObjectToIDMap == nullptr || inObject == nullptr)
-	{
-		// Write null ID
-		inStream.Write(~uint32(0));
-	}
-	else
-	{
-		typename ObjectToIDMap<Type>::const_iterator id = ioObjectToIDMap->find(inObject);
-		if (id != ioObjectToIDMap->end())
-		{
-			// Existing object, write ID
-			inStream.Write(id->second);
-		}
-		else
-		{
-			// New object, write the ID
-			uint32 new_id = uint32(ioObjectToIDMap->size());
-			(*ioObjectToIDMap)[inObject] = new_id;
-			inStream.Write(new_id);
-
-			// Write the object
-			inObject->SaveBinaryState(inStream);
-		}
-	}
-}
-
-/// Restore an object reference from stream.
-template <class Type>
-Result<Ref<Type>>	RestoreObjectReference(StreamIn &inStream, IDToObjectMap<Type> &ioIDToObjectMap)
-{
-	Result<Ref<Type>> result;
-
-	// Read id
-	uint32 id = ~uint32(0);
-	inStream.Read(id);
-
-	// Check null
-	if (id == ~uint32(0))
-	{
-		result.Set(nullptr);
-		return result;
-	}
-
-	// Check if it already exists
-	if (id >= ioIDToObjectMap.size())
-	{
-		// New object, restore it
-		result = Type::sRestoreFromBinaryState(inStream);
-		if (result.HasError())
-			return result;
-		JPH_ASSERT(id == ioIDToObjectMap.size());
-		ioIDToObjectMap.push_back(result.Get());
-	}
-	else
-	{
-		// Existing object filter
-		result.Set(ioIDToObjectMap[id].GetPtr());
-	}
-
-	return result;
-}
-
-// Save an array of objects to a stream.
-template <class ArrayType, class ValueType>
-void				SaveObjectArray(StreamOut &inStream, const ArrayType &inArray, ObjectToIDMap<ValueType> *ioObjectToIDMap)
-{
-	uint32 len = uint32(inArray.size());
-	inStream.Write(len);
-	for (const ValueType *value: inArray)
-		SaveObjectReference(inStream, value, ioObjectToIDMap);
-}
-
-// Restore an array of objects from a stream.
-template <class ArrayType, class ValueType>
-Result<ArrayType>	RestoreObjectArray(StreamIn &inStream, IDToObjectMap<ValueType> &ioIDToObjectMap)
-{
-	Result<ArrayType> result;
-
-	uint32 len;
-	inStream.Read(len);
-	if (inStream.IsEOF() || inStream.IsFailed())
-	{
-		result.SetError("Failed to read stream");
-		return result;
-	}
-
-	ArrayType values;
-	values.reserve(len);
-	for (size_t i = 0; i < len; ++i)
-	{
-		Result value = RestoreObjectReference(inStream, ioIDToObjectMap);
-		if (value.HasError())
-		{
-			result.SetError(value.GetError());
-			return result;
-		}
-		values.push_back(std::move(value.Get()));
-	}
-
-	result.Set(values);
-	return result;
-}
-
-} // StreamUtils
-
-JPH_NAMESPACE_END