@bloomengine/engine 0.3.1

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

@@ -0,0 +1,62 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/ObjectStreamOut.h>
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+/// Implementation of ObjectStream text output stream.
+class JPH_EXPORT ObjectStreamTextOut : public ObjectStreamOut
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor and destructor
+	explicit					ObjectStreamTextOut(ostream &inStream);
+
+	///@name Output type specific operations
+	virtual void				WriteDataType(EOSDataType inType) override;
+	virtual void				WriteName(const char *inName) override;
+	virtual void				WriteIdentifier(Identifier inIdentifier) override;
+	virtual void				WriteCount(uint32 inCount) override;
+
+	virtual void				WritePrimitiveData(const uint8 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint16 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const int &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint32 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const uint64 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const float &inPrimitive) override;
+	virtual void				WritePrimitiveData(const double &inPrimitive) override;
+	virtual void				WritePrimitiveData(const bool &inPrimitive) override;
+	virtual void				WritePrimitiveData(const String &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Float3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Float4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Double3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Vec3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const DVec3 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Vec4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const UVec4 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Quat &inPrimitive) override;
+	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) override;
+	virtual void				WritePrimitiveData(const DMat44 &inPrimitive) override;
+
+	///@name Layout hints (for text output)
+	virtual void				HintNextItem() override;
+	virtual void				HintIndentUp() override;
+	virtual void				HintIndentDown() override;
+
+private:
+	void						WriteChar(char inChar);
+	void						WriteWord(const string_view &inWord);
+
+	int							mIndentation = 0;
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,26 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+// Note: Order is important, an enum is created and its value is stored in a binary stream!
+JPH_DECLARE_PRIMITIVE(uint8)
+JPH_DECLARE_PRIMITIVE(uint16)
+JPH_DECLARE_PRIMITIVE(int)
+JPH_DECLARE_PRIMITIVE(uint32)
+JPH_DECLARE_PRIMITIVE(uint64)
+JPH_DECLARE_PRIMITIVE(float)
+JPH_DECLARE_PRIMITIVE(bool)
+JPH_DECLARE_PRIMITIVE(String)
+JPH_DECLARE_PRIMITIVE(Float3)
+JPH_DECLARE_PRIMITIVE(Vec3)
+JPH_DECLARE_PRIMITIVE(Vec4)
+JPH_DECLARE_PRIMITIVE(Quat)
+JPH_DECLARE_PRIMITIVE(Mat44)
+JPH_DECLARE_PRIMITIVE(double)
+JPH_DECLARE_PRIMITIVE(DVec3)
+JPH_DECLARE_PRIMITIVE(DMat44)
+JPH_DECLARE_PRIMITIVE(Double3)
+JPH_DECLARE_PRIMITIVE(Float4)
+JPH_DECLARE_PRIMITIVE(UVec4)
+
+#undef JPH_DECLARE_PRIMITIVE

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

@@ -0,0 +1,111 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifdef JPH_OBJECT_STREAM
+
+JPH_NAMESPACE_BEGIN
+
+class RTTI;
+class IObjectStreamIn;
+class IObjectStreamOut;
+
+/// Data type
+enum class EOSDataType
+{
+	/// Control codes
+	Declare,																		///< Used to declare the attributes of a new object type
+	Object,																			///< Start of a new object
+	Instance,																		///< Used in attribute declaration, indicates that an object is an instanced attribute (no pointer)
+	Pointer,																		///< Used in attribute declaration, indicates that an object is a pointer attribute
+	Array,																			///< Used in attribute declaration, indicates that this is an array of objects
+
+	// Basic types (primitives)
+	#define JPH_DECLARE_PRIMITIVE(name)	T_##name,
+
+	// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
+	#include <Jolt/ObjectStream/ObjectStreamTypes.h>
+
+	// Error values for read functions
+	Invalid,																		///< Next token on the stream was not a valid data type
+};
+
+/// Attributes are members of classes that need to be serialized.
+class SerializableAttribute
+{
+public:
+	///@ Serialization functions
+	using pGetMemberPrimitiveType = const RTTI * (*)();
+	using pIsType = bool (*)(int inArrayDepth, EOSDataType inDataType, const char *inClassName);
+	using pReadData = bool (*)(IObjectStreamIn &ioStream, void *inObject);
+	using pWriteData = void (*)(IObjectStreamOut &ioStream, const void *inObject);
+	using pWriteDataType = void (*)(IObjectStreamOut &ioStream);
+
+	/// Constructor
+								SerializableAttribute(const char *inName, uint inMemberOffset, pGetMemberPrimitiveType inGetMemberPrimitiveType, pIsType inIsType, pReadData inReadData, pWriteData inWriteData, pWriteDataType inWriteDataType) : mName(inName), mMemberOffset(inMemberOffset), mGetMemberPrimitiveType(inGetMemberPrimitiveType), mIsType(inIsType), mReadData(inReadData), mWriteData(inWriteData), mWriteDataType(inWriteDataType) { }
+
+	/// Construct from other attribute with base class offset
+								SerializableAttribute(const SerializableAttribute &inOther, int inBaseOffset) : mName(inOther.mName), mMemberOffset(inOther.mMemberOffset + inBaseOffset), mGetMemberPrimitiveType(inOther.mGetMemberPrimitiveType), mIsType(inOther.mIsType), mReadData(inOther.mReadData), mWriteData(inOther.mWriteData), mWriteDataType(inOther.mWriteDataType) { }
+
+	/// Name of the attribute
+	void						SetName(const char *inName)							{ mName = inName; }
+	const char *				GetName() const										{ return mName; }
+
+	/// Access to the memory location that contains the member
+	template <class T>
+	inline T *					GetMemberPointer(void *inObject) const				{ return reinterpret_cast<T *>(reinterpret_cast<uint8 *>(inObject) + mMemberOffset); }
+	template <class T>
+	inline const T *			GetMemberPointer(const void *inObject) const		{ return reinterpret_cast<const T *>(reinterpret_cast<const uint8 *>(inObject) + mMemberOffset); }
+
+	/// In case this attribute contains an RTTI type, return it (note that a Array<sometype> will return the rtti of sometype)
+	const RTTI *				GetMemberPrimitiveType() const
+	{
+		return mGetMemberPrimitiveType();
+	}
+
+	/// Check if this attribute is of a specific type
+	bool						IsType(int inArrayDepth, EOSDataType inDataType, const char *inClassName) const
+	{
+		return mIsType(inArrayDepth, inDataType, inClassName);
+	}
+
+	/// Read the data for this attribute into attribute containing class inObject
+	bool						ReadData(IObjectStreamIn &ioStream, void *inObject) const
+	{
+		return mReadData(ioStream, GetMemberPointer<void>(inObject));
+	}
+
+	/// Write the data for this attribute from attribute containing class inObject
+	void						WriteData(IObjectStreamOut &ioStream, const void *inObject) const
+	{
+		mWriteData(ioStream, GetMemberPointer<void>(inObject));
+	}
+
+	/// Write the data type of this attribute to a stream
+	void						WriteDataType(IObjectStreamOut &ioStream) const
+	{
+		mWriteDataType(ioStream);
+	}
+
+private:
+	// Name of the attribute
+	const char *				mName;
+
+	// Offset of the member relative to the class
+	uint						mMemberOffset;
+
+	// In case this attribute contains an RTTI type, return it (note that a Array<sometype> will return the rtti of sometype)
+	pGetMemberPrimitiveType		mGetMemberPrimitiveType;
+
+	// Serialization operations
+	pIsType						mIsType;
+	pReadData					mReadData;
+	pWriteData					mWriteData;
+	pWriteDataType				mWriteDataType;
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,67 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifdef JPH_OBJECT_STREAM
+
+#include <Jolt/ObjectStream/SerializableAttribute.h>
+#include <Jolt/ObjectStream/ObjectStream.h>
+
+JPH_NAMESPACE_BEGIN
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Macros to add properties to be serialized
+//////////////////////////////////////////////////////////////////////////////////////////
+
+template <class MemberType>
+inline void AddSerializableAttributeEnum(RTTI &inRTTI, uint inOffset, const char *inName)
+{
+	inRTTI.AddAttribute(SerializableAttribute(inName, inOffset,
+		[]() -> const RTTI *
+		{
+			return nullptr;
+		},
+		[](int inArrayDepth, EOSDataType inDataType, [[maybe_unused]] const char *inClassName)
+		{
+			return inArrayDepth == 0 && inDataType == EOSDataType::T_uint32;
+		},
+		[](IObjectStreamIn &ioStream, void *inObject)
+		{
+			uint32 temporary;
+			if (OSReadData(ioStream, temporary))
+			{
+				*reinterpret_cast<MemberType *>(inObject) = static_cast<MemberType>(temporary);
+				return true;
+			}
+			return false;
+		},
+		[](IObjectStreamOut &ioStream, const void *inObject)
+		{
+			static_assert(sizeof(MemberType) <= sizeof(uint32));
+			uint32 temporary = uint32(*reinterpret_cast<const MemberType *>(inObject));
+			OSWriteData(ioStream, temporary);
+		},
+		[](IObjectStreamOut &ioStream)
+		{
+			ioStream.WriteDataType(EOSDataType::T_uint32);
+		}));
+}
+
+// JPH_ADD_ENUM_ATTRIBUTE_WITH_ALIAS
+#define JPH_ADD_ENUM_ATTRIBUTE_WITH_ALIAS(class_name, member_name, alias_name) \
+	AddSerializableAttributeEnum<decltype(class_name::member_name)>(inRTTI, offsetof(class_name, member_name), alias_name);
+
+// JPH_ADD_ENUM_ATTRIBUTE
+#define JPH_ADD_ENUM_ATTRIBUTE(class_name, member_name) \
+	JPH_ADD_ENUM_ATTRIBUTE_WITH_ALIAS(class_name, member_name, #member_name);
+
+JPH_NAMESPACE_END
+
+#else
+
+#define JPH_ADD_ENUM_ATTRIBUTE_WITH_ALIAS(...)
+#define JPH_ADD_ENUM_ATTRIBUTE(...)
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,60 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifdef JPH_OBJECT_STREAM
+
+#include <Jolt/ObjectStream/SerializableAttribute.h>
+#include <Jolt/ObjectStream/GetPrimitiveTypeOfType.h>
+#include <Jolt/ObjectStream/ObjectStream.h>
+
+JPH_NAMESPACE_BEGIN
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Macros to add properties to be serialized
+//////////////////////////////////////////////////////////////////////////////////////////
+
+template <class MemberType>
+inline void AddSerializableAttributeTyped(RTTI &inRTTI, uint inOffset, const char *inName)
+{
+	inRTTI.AddAttribute(SerializableAttribute(inName, inOffset,
+		[]()
+		{
+			return GetPrimitiveTypeOfType((MemberType *)nullptr);
+		},
+		[](int inArrayDepth, EOSDataType inDataType, const char *inClassName)
+		{
+			return OSIsType((MemberType *)nullptr, inArrayDepth, inDataType, inClassName);
+		},
+		[](IObjectStreamIn &ioStream, void *inObject)
+		{
+			return OSReadData(ioStream, *reinterpret_cast<MemberType *>(inObject));
+		},
+		[](IObjectStreamOut &ioStream, const void *inObject)
+		{
+			OSWriteData(ioStream, *reinterpret_cast<const MemberType *>(inObject));
+		},
+		[](IObjectStreamOut &ioStream)
+		{
+			OSWriteDataType(ioStream, (MemberType *)nullptr);
+		}));
+}
+
+// JPH_ADD_ATTRIBUTE
+#define JPH_ADD_ATTRIBUTE_WITH_ALIAS(class_name, member_name, alias_name) \
+	AddSerializableAttributeTyped<decltype(class_name::member_name)>(inRTTI, offsetof(class_name, member_name), alias_name);
+
+// JPH_ADD_ATTRIBUTE
+#define JPH_ADD_ATTRIBUTE(class_name, member_name) \
+	JPH_ADD_ATTRIBUTE_WITH_ALIAS(class_name, member_name, #member_name)
+
+JPH_NAMESPACE_END
+
+#else
+
+#define JPH_ADD_ATTRIBUTE_WITH_ALIAS(...)
+#define JPH_ADD_ATTRIBUTE(...)
+
+#endif // JPH_OBJECT_STREAM

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

@@ -0,0 +1,15 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/ObjectStream/SerializableObject.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(SerializableObject)
+{
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,170 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/ObjectStream.h>
+
+JPH_NAMESPACE_BEGIN
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Helper macros
+//////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef JPH_OBJECT_STREAM
+
+// JPH_DECLARE_SERIALIZATION_FUNCTIONS
+#define JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, prefix, class_name)											\
+	linkage prefix bool	OSReadData(IObjectStreamIn &ioStream, class_name &inInstance);								\
+	linkage prefix bool	OSReadData(IObjectStreamIn &ioStream, class_name *&inPointer);								\
+	linkage prefix bool	OSIsType(class_name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
+	linkage prefix bool	OSIsType(class_name **, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
+	linkage prefix void	OSWriteData(IObjectStreamOut &ioStream, const class_name &inInstance);						\
+	linkage prefix void	OSWriteData(IObjectStreamOut &ioStream, class_name *const &inPointer);						\
+	linkage prefix void	OSWriteDataType(IObjectStreamOut &ioStream, class_name *);									\
+	linkage prefix void	OSWriteDataType(IObjectStreamOut &ioStream, class_name **);
+
+// JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS
+#define JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)															\
+	bool		OSReadData(IObjectStreamIn &ioStream, class_name &inInstance)										\
+	{																												\
+		return ioStream.ReadClassData(#class_name, (void *)&inInstance);											\
+	}																												\
+	bool		OSReadData(IObjectStreamIn &ioStream, class_name *&inPointer)										\
+	{																												\
+		return ioStream.ReadPointerData(JPH_RTTI(class_name), (void **)&inPointer);									\
+	}																												\
+	bool		OSIsType(class_name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)			\
+	{																												\
+		return inArrayDepth == 0 && inDataType == EOSDataType::Instance && strcmp(inClassName, #class_name) == 0;	\
+	}																												\
+	bool		OSIsType(class_name **, int inArrayDepth, EOSDataType inDataType, const char *inClassName)			\
+	{																												\
+		return inArrayDepth == 0 && inDataType == EOSDataType::Pointer && strcmp(inClassName, #class_name) == 0;	\
+	}																												\
+	void		OSWriteData(IObjectStreamOut &ioStream, const class_name &inInstance)								\
+	{																												\
+		ioStream.WriteClassData(JPH_RTTI(class_name), (void *)&inInstance);											\
+	}																												\
+	void		OSWriteData(IObjectStreamOut &ioStream, class_name *const &inPointer)								\
+	{																												\
+		if (inPointer)																								\
+			ioStream.WritePointerData(GetRTTI(inPointer), (void *)inPointer);										\
+		else																										\
+			ioStream.WritePointerData(nullptr, nullptr);															\
+	}																												\
+	void		OSWriteDataType(IObjectStreamOut &ioStream, class_name *)											\
+	{																												\
+		ioStream.WriteDataType(EOSDataType::Instance);																\
+		ioStream.WriteName(#class_name);																			\
+	}																												\
+	void		OSWriteDataType(IObjectStreamOut &ioStream, class_name **)											\
+	{																												\
+		ioStream.WriteDataType(EOSDataType::Pointer);																\
+		ioStream.WriteName(#class_name);																			\
+	}
+
+#else
+
+#define JPH_DECLARE_SERIALIZATION_FUNCTIONS(...)
+#define JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(...)
+
+#endif // JPH_OBJECT_STREAM
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Use these macros on non-virtual objects to make them serializable
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL
+#define JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(linkage, class_name)													\
+public:																												\
+	JPH_DECLARE_RTTI_NON_VIRTUAL(linkage, class_name)																\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, friend, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL
+#define JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(class_name)															\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_NON_VIRTUAL(class_name)																		\
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Same as above, but when you cannot insert the declaration in the class itself
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS
+#define JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(linkage, class_name)													\
+	JPH_DECLARE_RTTI_OUTSIDE_CLASS(linkage, class_name)																\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, extern, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS
+#define JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(class_name)														\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(class_name)																	\
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// Same as above, but for classes that have virtual functions
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// JPH_DECLARE_SERIALIZABLE_VIRTUAL - Use for concrete, non-base classes
+#define JPH_DECLARE_SERIALIZABLE_VIRTUAL(linkage, class_name)														\
+public:																												\
+	JPH_DECLARE_RTTI_VIRTUAL(linkage, class_name)																	\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, friend, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL
+#define JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(class_name)																\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_VIRTUAL(class_name)																			\
+
+// JPH_DECLARE_SERIALIZABLE_ABSTRACT - Use for abstract, non-base classes
+#define JPH_DECLARE_SERIALIZABLE_ABSTRACT(linkage, class_name)														\
+public:																												\
+	JPH_DECLARE_RTTI_ABSTRACT(linkage, class_name)																	\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, friend, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT
+#define JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(class_name)																\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_ABSTRACT(class_name)																			\
+
+// JPH_DECLARE_SERIALIZABLE_VIRTUAL_BASE - Use for concrete base classes
+#define JPH_DECLARE_SERIALIZABLE_VIRTUAL_BASE(linkage, class_name)													\
+public:																												\
+	JPH_DECLARE_RTTI_VIRTUAL_BASE(linkage, class_name)																\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, friend, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL_BASE
+#define JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL_BASE(class_name)															\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_VIRTUAL_BASE(class_name)																		\
+
+// JPH_DECLARE_SERIALIZABLE_ABSTRACT_BASE - Use for abstract base class
+#define JPH_DECLARE_SERIALIZABLE_ABSTRACT_BASE(linkage, class_name)													\
+public:																												\
+	JPH_DECLARE_RTTI_ABSTRACT_BASE(linkage, class_name)																\
+	JPH_DECLARE_SERIALIZATION_FUNCTIONS(linkage, friend, class_name)												\
+
+// JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT_BASE
+#define JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT_BASE(class_name)														\
+	JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)																\
+	JPH_IMPLEMENT_RTTI_ABSTRACT_BASE(class_name)
+
+/// Classes must be derived from SerializableObject if you want to be able to save pointers or
+/// reference counting pointers to objects of this or derived classes. The type will automatically
+/// be determined during serialization and upon deserialization it will be restored correctly.
+class JPH_EXPORT SerializableObject
+{
+	JPH_DECLARE_SERIALIZABLE_ABSTRACT_BASE(JPH_EXPORT, SerializableObject)
+
+public:
+	/// Destructor
+	virtual						~SerializableObject() = default;
+
+protected:
+	/// Don't allow (copy) constructing this base class, but allow derived classes to (copy) construct themselves
+								SerializableObject() = default;
+								SerializableObject(const SerializableObject &) = default;
+	SerializableObject &		operator = (const SerializableObject &) = default;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,70 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(uint8)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(uint16)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(int)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(uint32)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(uint64)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(float)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(double)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(bool)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(String)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Float3)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Float4)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Double3)		{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Vec3)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(DVec3)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Vec4)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(UVec4)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Quat)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(Mat44)			{ }
+JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(DMat44)		{ }
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(Color)
+{
+	JPH_ADD_ATTRIBUTE(Color, r)
+	JPH_ADD_ATTRIBUTE(Color, g)
+	JPH_ADD_ATTRIBUTE(Color, b)
+	JPH_ADD_ATTRIBUTE(Color, a)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(AABox)
+{
+	JPH_ADD_ATTRIBUTE(AABox, mMin)
+	JPH_ADD_ATTRIBUTE(AABox, mMax)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(Triangle)
+{
+	JPH_ADD_ATTRIBUTE(Triangle, mV)
+	JPH_ADD_ATTRIBUTE(Triangle, mMaterialIndex)
+	JPH_ADD_ATTRIBUTE(Triangle, mUserData)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(IndexedTriangleNoMaterial)
+{
+	JPH_ADD_ATTRIBUTE(IndexedTriangleNoMaterial, mIdx)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(IndexedTriangle)
+{
+	JPH_ADD_BASE_CLASS(IndexedTriangle, IndexedTriangleNoMaterial)
+
+	JPH_ADD_ATTRIBUTE(IndexedTriangle, mMaterialIndex)
+	JPH_ADD_ATTRIBUTE(IndexedTriangle, mUserData)
+}
+
+JPH_IMPLEMENT_SERIALIZABLE_OUTSIDE_CLASS(Plane)
+{
+	JPH_ADD_ATTRIBUTE(Plane, mNormalAndConstant)
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,45 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/SerializableObject.h>
+#include <Jolt/Core/Color.h>
+#include <Jolt/Geometry/AABox.h>
+#include <Jolt/Geometry/Triangle.h>
+#include <Jolt/Geometry/IndexedTriangle.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, uint8);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, uint16);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, int);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, uint32);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, uint64);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, float);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, double);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, bool);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, String);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Float3);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Float4);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Double3);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Vec3);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, DVec3);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Vec4);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, UVec4);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Quat);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, Mat44);
+JPH_DECLARE_RTTI_OUTSIDE_CLASS(JPH_EXPORT, DMat44);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, Color);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, AABox);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, Triangle);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, IndexedTriangleNoMaterial);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, IndexedTriangle);
+JPH_DECLARE_SERIALIZABLE_OUTSIDE_CLASS(JPH_EXPORT, Plane);
+
+JPH_NAMESPACE_END
+
+// These need to be added after all types have been registered or else clang under linux will not find GetRTTIOfType for the type
+#include <Jolt/ObjectStream/SerializableAttributeTyped.h>
+#include <Jolt/ObjectStream/SerializableAttributeEnum.h>