@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Math/Vector.h

@@ -0,0 +1,211 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Templatized vector class
+template <uint Rows>
+class [[nodiscard]] Vector
+{
+public:
+	/// Constructor
+	inline						Vector() = default;
+	inline						Vector(const Vector &) = default;
+
+	/// Dimensions
+	inline uint					GetRows() const											{ return Rows; }
+
+	/// Vector with all zeros
+	inline void					SetZero()
+	{
+		for (uint r = 0; r < Rows; ++r)
+			mF32[r] = 0.0f;
+	}
+
+	inline static Vector		sZero()													{ Vector v; v.SetZero(); return v; }
+
+	/// Copy a (part) of another vector into this vector
+	template <class OtherVector>
+		void					CopyPart(const OtherVector &inV, uint inSourceRow, uint inNumRows, uint inDestRow)
+		{
+			for (uint r = 0; r < inNumRows; ++r)
+				mF32[inDestRow + r] = inV[inSourceRow + r];
+		}
+
+	/// Get float component by index
+	inline float				operator [] (uint inCoordinate) const
+	{
+		JPH_ASSERT(inCoordinate < Rows);
+		return mF32[inCoordinate];
+	}
+
+	inline float &				operator [] (uint inCoordinate)
+	{
+		JPH_ASSERT(inCoordinate < Rows);
+		return mF32[inCoordinate];
+	}
+
+	/// Comparison
+	inline bool					operator == (const Vector &inV2) const
+	{
+		for (uint r = 0; r < Rows; ++r)
+			if (mF32[r] != inV2.mF32[r])
+				return false;
+		return true;
+	}
+
+	inline bool					operator != (const Vector &inV2) const
+	{
+		for (uint r = 0; r < Rows; ++r)
+			if (mF32[r] != inV2.mF32[r])
+				return true;
+		return false;
+	}
+
+	/// Test if vector consists of all zeros
+	inline bool					IsZero() const
+	{
+		for (uint r = 0; r < Rows; ++r)
+			if (mF32[r] != 0.0f)
+				return false;
+		return true;
+	}
+
+	/// Test if two vectors are close to each other
+	inline bool					IsClose(const Vector &inV2, float inMaxDistSq = 1.0e-12f) const
+	{
+		return (inV2 - *this).LengthSq() <= inMaxDistSq;
+	}
+
+	/// Assignment
+	inline Vector &				operator = (const Vector &) = default;
+
+	/// Multiply vector with float
+	inline Vector				operator * (const float inV2) const
+	{
+		Vector v;
+		for (uint r = 0; r < Rows; ++r)
+			v.mF32[r] = mF32[r] * inV2;
+		return v;
+	}
+
+	inline Vector &				operator *= (const float inV2)
+	{
+		for (uint r = 0; r < Rows; ++r)
+			mF32[r] *= inV2;
+		return *this;
+	}
+
+	/// Multiply vector with float
+	inline friend Vector		operator * (const float inV1, const Vector &inV2)
+	{
+		return inV2 * inV1;
+	}
+
+	/// Divide vector by float
+	inline Vector				operator / (float inV2) const
+	{
+		Vector v;
+		for (uint r = 0; r < Rows; ++r)
+			v.mF32[r] = mF32[r] / inV2;
+		return v;
+	}
+
+	inline Vector &				operator /= (float inV2)
+	{
+		for (uint r = 0; r < Rows; ++r)
+			mF32[r] /= inV2;
+		return *this;
+	}
+
+	/// Add two float vectors (component wise)
+	inline Vector				operator + (const Vector &inV2) const
+	{
+		Vector v;
+		for (uint r = 0; r < Rows; ++r)
+			v.mF32[r] = mF32[r] + inV2.mF32[r];
+		return v;
+	}
+
+	inline Vector &				operator += (const Vector &inV2)
+	{
+		for (uint r = 0; r < Rows; ++r)
+			mF32[r] += inV2.mF32[r];
+		return *this;
+	}
+
+	/// Negate
+	inline Vector				operator - () const
+	{
+		Vector v;
+		for (uint r = 0; r < Rows; ++r)
+			v.mF32[r] = -mF32[r];
+		return v;
+	}
+
+	/// Subtract two float vectors (component wise)
+	inline Vector				operator - (const Vector &inV2) const
+	{
+		Vector v;
+		for (uint r = 0; r < Rows; ++r)
+			v.mF32[r] = mF32[r] - inV2.mF32[r];
+		return v;
+	}
+
+	inline Vector &				operator -= (const Vector &inV2)
+	{
+		for (uint r = 0; r < Rows; ++r)
+			mF32[r] -= inV2.mF32[r];
+		return *this;
+	}
+
+	/// Dot product
+	inline float				Dot(const Vector &inV2) const
+	{
+		float dot = 0.0f;
+		for (uint r = 0; r < Rows; ++r)
+			dot += mF32[r] * inV2.mF32[r];
+		return dot;
+	}
+
+	/// Squared length of vector
+	inline float				LengthSq() const
+	{
+		return Dot(*this);
+	}
+
+	/// Length of vector
+	inline float				Length() const
+	{
+		return sqrt(LengthSq());
+	}
+
+	/// Check if vector is normalized
+	inline bool					IsNormalized(float inToleranceSq = 1.0e-6f)
+	{
+		return abs(LengthSq() - 1.0f) <= inToleranceSq;
+	}
+
+	/// Normalize vector
+	inline Vector				Normalized() const
+	{
+		return *this / Length();
+	}
+
+	/// To String
+	friend ostream &			operator << (ostream &inStream, const Vector &inV)
+	{
+		inStream << "[";
+		for (uint i = 0; i < Rows - 1; ++i)
+			inStream << inV.mF32[i] << ", ";
+		inStream << inV.mF32[Rows - 1] << "]";
+		return inStream;
+	}
+
+	float						mF32[Rows];
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/ObjectStream/GetPrimitiveTypeOfType.h

@@ -0,0 +1,54 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/RTTI.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Helper functions to get the underlying RTTI type of a type (so e.g. Array<sometype> will return sometype)
+template <class T>
+const RTTI *GetPrimitiveTypeOfType(T *)
+{
+	return GetRTTIOfType((T *)nullptr);
+}
+
+template <class T>
+const RTTI *GetPrimitiveTypeOfType(T **)
+{
+	return GetRTTIOfType((T *)nullptr);
+}
+
+template <class T>
+const RTTI *GetPrimitiveTypeOfType(Ref<T> *)
+{
+	return GetRTTIOfType((T *)nullptr);
+}
+
+template <class T>
+const RTTI *GetPrimitiveTypeOfType(RefConst<T> *)
+{
+	return GetRTTIOfType((T *)nullptr);
+}
+
+template <class T, class A>
+const RTTI *GetPrimitiveTypeOfType(Array<T, A> *)
+{
+	return GetPrimitiveTypeOfType((T *)nullptr);
+}
+
+template <class T, uint N>
+const RTTI *GetPrimitiveTypeOfType(StaticArray<T, N> *)
+{
+	return GetPrimitiveTypeOfType((T *)nullptr);
+}
+
+template <class T, uint N>
+const RTTI *GetPrimitiveTypeOfType(T (*)[N])
+{
+	return GetPrimitiveTypeOfType((T *)nullptr);
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/ObjectStream/ObjectStream.cpp

@@ -0,0 +1,38 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/ObjectStream/ObjectStream.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+// Define macro to declare functions for a specific primitive type
+#define JPH_DECLARE_PRIMITIVE(name)																\
+	bool	OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName) \
+	{																							\
+		return inArrayDepth == 0 && inDataType == EOSDataType::T_##name;						\
+	}																							\
+	bool	OSReadData(IObjectStreamIn &ioStream, name &outPrimitive)							\
+	{																							\
+		return ioStream.ReadPrimitiveData(outPrimitive);										\
+	}																							\
+	void	OSWriteDataType(IObjectStreamOut &ioStream, name *)									\
+	{																							\
+		ioStream.WriteDataType(EOSDataType::T_##name);											\
+	}																							\
+	void	OSWriteData(IObjectStreamOut &ioStream, const name &inPrimitive)					\
+	{																							\
+		ioStream.HintNextItem();																\
+		ioStream.WritePrimitiveData(inPrimitive);												\
+	}
+
+// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
+#include <Jolt/ObjectStream/ObjectStreamTypes.h>
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

package/native/third_party/JoltPhysics/Jolt/ObjectStream/ObjectStream.h

@@ -0,0 +1,337 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/StaticArray.h>
+#include <Jolt/Core/Reference.h>
+#include <Jolt/Core/RTTI.h>
+#include <Jolt/Core/NonCopyable.h>
+#include <Jolt/ObjectStream/SerializableAttribute.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+/// Base class for object stream input and output streams.
+class JPH_EXPORT ObjectStream : public NonCopyable
+{
+public:
+	/// Stream type
+	enum class EStreamType
+	{
+		Text,
+		Binary,
+	};
+
+protected:
+	/// Destructor
+	virtual							~ObjectStream() = default;
+
+	/// Identifier for objects
+	using Identifier = uint32;
+
+	static constexpr int			sVersion = 1;
+	static constexpr int			sRevision = 0;
+	static constexpr Identifier		sNullIdentifier = 0;
+};
+
+/// Interface class for reading from an object stream
+class JPH_EXPORT IObjectStreamIn : public ObjectStream
+{
+public:
+	///@name Input type specific operations
+	virtual bool				ReadDataType(EOSDataType &outType) = 0;
+	virtual bool				ReadName(String &outName) = 0;
+	virtual bool				ReadIdentifier(Identifier &outIdentifier) = 0;
+	virtual bool				ReadCount(uint32 &outCount) = 0;
+
+	///@name Read primitives
+	virtual bool				ReadPrimitiveData(uint8 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(uint16 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(int &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(uint32 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(uint64 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(float &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(double &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(bool &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(String &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Float3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Float4 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Double3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Vec3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(DVec3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Vec4 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(UVec4 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Quat &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Mat44 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(DMat44 &outPrimitive) = 0;
+
+	///@name Read compounds
+	virtual bool				ReadClassData(const char *inClassName, void *inInstance) = 0;
+	virtual bool				ReadPointerData(const RTTI *inRTTI, void **inPointer, int inRefCountOffset = -1) = 0;
+};
+
+/// Interface class for writing to an object stream
+class JPH_EXPORT IObjectStreamOut : public ObjectStream
+{
+public:
+	///@name Output type specific operations
+	virtual void				WriteDataType(EOSDataType inType) = 0;
+	virtual void				WriteName(const char *inName) = 0;
+	virtual void				WriteIdentifier(Identifier inIdentifier) = 0;
+	virtual void				WriteCount(uint32 inCount) = 0;
+
+	///@name Write primitives
+	virtual void				WritePrimitiveData(const uint8 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const uint16 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const int &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const uint32 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const uint64 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const float &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const double &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const bool &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const String &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Float3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Float4 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Double3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Vec3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const DVec3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Vec4 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const UVec4 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Quat &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const DMat44 &inPrimitive) = 0;
+
+	///@name Write compounds
+	virtual void				WritePointerData(const RTTI *inRTTI, const void *inPointer) = 0;
+	virtual void				WriteClassData(const RTTI *inRTTI, const void *inInstance) = 0;
+
+	///@name Layout hints (for text output)
+	virtual void				HintNextItem()												{ /* Default is do nothing */ }
+	virtual void				HintIndentUp()												{ /* Default is do nothing */ }
+	virtual void				HintIndentDown()											{ /* Default is do nothing */ }
+};
+
+// Define macro to declare functions for a specific primitive type
+#define JPH_DECLARE_PRIMITIVE(name)																			\
+	JPH_EXPORT bool	OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
+	JPH_EXPORT bool	OSReadData(IObjectStreamIn &ioStream, name &outPrimitive);								\
+	JPH_EXPORT void	OSWriteDataType(IObjectStreamOut &ioStream, name *);									\
+	JPH_EXPORT void	OSWriteData(IObjectStreamOut &ioStream, const name &inPrimitive);
+
+// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
+#include <Jolt/ObjectStream/ObjectStreamTypes.h>
+
+// Define serialization templates
+template <class T, class A>
+bool OSIsType(Array<T, A> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+{
+	return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
+}
+
+template <class T, uint N>
+bool OSIsType(StaticArray<T, N> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+{
+	return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
+}
+
+template <class T, uint N>
+bool OSIsType(T (*)[N], int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+{
+	return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
+}
+
+template <class T>
+bool OSIsType(Ref<T> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+{
+	return OSIsType(static_cast<T *>(nullptr), inArrayDepth, inDataType, inClassName);
+}
+
+template <class T>
+bool OSIsType(RefConst<T> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+{
+	return OSIsType(static_cast<T *>(nullptr), inArrayDepth, inDataType, inClassName);
+}
+
+/// Define serialization templates for dynamic arrays
+template <class T, class A>
+bool OSReadData(IObjectStreamIn &ioStream, Array<T, A> &inArray)
+{
+	bool continue_reading = true;
+
+	// Read array length
+	uint32 array_length;
+	continue_reading = ioStream.ReadCount(array_length);
+
+	// Read array items
+	if (continue_reading)
+	{
+		inArray.clear();
+		inArray.resize(array_length);
+		for (uint32 el = 0; el < array_length && continue_reading; ++el)
+			continue_reading = OSReadData(ioStream, inArray[el]);
+	}
+
+	return continue_reading;
+}
+
+/// Define serialization templates for static arrays
+template <class T, uint N>
+bool OSReadData(IObjectStreamIn &ioStream, StaticArray<T, N> &inArray)
+{
+	bool continue_reading = true;
+
+	// Read array length
+	uint32 array_length;
+	continue_reading = ioStream.ReadCount(array_length);
+
+	// Check if we can fit this many elements
+	if (array_length > N)
+		return false;
+
+	// Read array items
+	if (continue_reading)
+	{
+		inArray.clear();
+		inArray.resize(array_length);
+		for (uint32 el = 0; el < array_length && continue_reading; ++el)
+			continue_reading = OSReadData(ioStream, inArray[el]);
+	}
+
+	return continue_reading;
+}
+
+/// Define serialization templates for C style arrays
+template <class T, uint N>
+bool OSReadData(IObjectStreamIn &ioStream, T (&inArray)[N])
+{
+	bool continue_reading = true;
+
+	// Read array length
+	uint32 array_length;
+	continue_reading = ioStream.ReadCount(array_length);
+	if (array_length != N)
+		return false;
+
+	// Read array items
+	for (uint32 el = 0; el < N && continue_reading; ++el)
+		continue_reading = OSReadData(ioStream, inArray[el]);
+
+	return continue_reading;
+}
+
+/// Define serialization templates for references
+template <class T>
+bool OSReadData(IObjectStreamIn &ioStream, Ref<T> &inRef)
+{
+	return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
+}
+
+template <class T>
+bool OSReadData(IObjectStreamIn &ioStream, RefConst<T> &inRef)
+{
+	return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
+}
+
+// Define serialization templates for dynamic arrays
+template <class T, class A>
+void OSWriteDataType(IObjectStreamOut &ioStream, Array<T, A> *)
+{
+	ioStream.WriteDataType(EOSDataType::Array);
+	OSWriteDataType(ioStream, static_cast<T *>(nullptr));
+}
+
+template <class T, class A>
+void OSWriteData(IObjectStreamOut &ioStream, const Array<T, A> &inArray)
+{
+	// Write size of array
+	ioStream.HintNextItem();
+	ioStream.WriteCount(static_cast<uint32>(inArray.size()));
+
+	// Write data in array
+	ioStream.HintIndentUp();
+	for (const T &v : inArray)
+		OSWriteData(ioStream, v);
+	ioStream.HintIndentDown();
+}
+
+/// Define serialization templates for static arrays
+template <class T, uint N>
+void OSWriteDataType(IObjectStreamOut &ioStream, StaticArray<T, N> *)
+{
+	ioStream.WriteDataType(EOSDataType::Array);
+	OSWriteDataType(ioStream, static_cast<T *>(nullptr));
+}
+
+template <class T, uint N>
+void OSWriteData(IObjectStreamOut &ioStream, const StaticArray<T, N> &inArray)
+{
+	// Write size of array
+	ioStream.HintNextItem();
+	ioStream.WriteCount(inArray.size());
+
+	// Write data in array
+	ioStream.HintIndentUp();
+	for (const typename StaticArray<T, N>::value_type &v : inArray)
+		OSWriteData(ioStream, v);
+	ioStream.HintIndentDown();
+}
+
+/// Define serialization templates for C style arrays
+template <class T, uint N>
+void OSWriteDataType(IObjectStreamOut &ioStream, T (*)[N])
+{
+	ioStream.WriteDataType(EOSDataType::Array);
+	OSWriteDataType(ioStream, static_cast<T *>(nullptr));
+}
+
+template <class T, uint N>
+void OSWriteData(IObjectStreamOut &ioStream, const T (&inArray)[N])
+{
+	// Write size of array
+	ioStream.HintNextItem();
+	ioStream.WriteCount(uint32(N));
+
+	// Write data in array
+	ioStream.HintIndentUp();
+	for (const T &v : inArray)
+		OSWriteData(ioStream, v);
+	ioStream.HintIndentDown();
+}
+
+/// Define serialization templates for references
+template <class T>
+void OSWriteDataType(IObjectStreamOut &ioStream, Ref<T> *)
+{
+	OSWriteDataType(ioStream, static_cast<T *>(nullptr));
+}
+
+template <class T>
+void OSWriteData(IObjectStreamOut &ioStream, const Ref<T> &inRef)
+{
+	if (inRef != nullptr)
+		ioStream.WritePointerData(GetRTTI(inRef.GetPtr()), inRef.GetPtr());
+	else
+		ioStream.WritePointerData(nullptr, nullptr);
+}
+
+template <class T>
+void OSWriteDataType(IObjectStreamOut &ioStream, RefConst<T> *)
+{
+	OSWriteDataType(ioStream, static_cast<T *>(nullptr));
+}
+
+template <class T>
+void OSWriteData(IObjectStreamOut &ioStream, const RefConst<T> &inRef)
+{
+	if (inRef != nullptr)
+		ioStream.WritePointerData(GetRTTI(inRef.GetPtr()), inRef.GetPtr());
+	else
+		ioStream.WritePointerData(nullptr, nullptr);
+}
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM