@bloomengine/engine 0.4.0 → 0.4.2

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

@@ -1,62 +0,0 @@
-// 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

@@ -1,26 +0,0 @@
-// 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

@@ -1,111 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-// 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

@@ -1,60 +0,0 @@
-// 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

@@ -1,15 +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/ObjectStream/SerializableObject.h>
-
-JPH_NAMESPACE_BEGIN
-
-JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(SerializableObject)
-{
-}
-
-JPH_NAMESPACE_END

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

@@ -1,170 +0,0 @@
-// 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

@@ -1,70 +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/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

@@ -1,45 +0,0 @@
-// 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>