Made it possible to make a class outside the JPH namespace serializable (#1850)

See #1849

Docs/ReleaseNotes.md

@@ -2,6 +2,12 @@
 
 For breaking API changes see [this document](https://github.com/jrouwe/JoltPhysics/blob/master/Docs/APIChanges.md).
 
+## Unreleased changes
+
+### Bug Fixes
+
+* Made it possible to make a class outside the JPH namespace serializable.
+
 ## v5.5.0
 
 ### New functionality

Jolt/Core/RTTI.h

@@ -195,18 +195,18 @@ protected:
 #define JPH_DECLARE_RTTI_NON_VIRTUAL(linkage, class_name)															\
 public:																												\
 	JPH_OVERRIDE_NEW_DELETE																							\
-	friend linkage RTTI *		GetRTTIOfType(class_name *);														\
-	friend inline const RTTI *	GetRTTI([[maybe_unused]] const class_name *inObject) { return GetRTTIOfType(static_cast<class_name *>(nullptr)); }\
-	static void					sCreateRTTI(RTTI &inRTTI);															\
+	friend linkage JPH::RTTI *	GetRTTIOfType(class_name *);														\
+	friend inline const JPH::RTTI *GetRTTI([[maybe_unused]] const class_name *inObject) { return GetRTTIOfType(static_cast<class_name *>(nullptr)); } \
+	static void					sCreateRTTI(JPH::RTTI &inRTTI);														\
 
 // JPH_IMPLEMENT_RTTI_NON_VIRTUAL
 #define JPH_IMPLEMENT_RTTI_NON_VIRTUAL(class_name)																	\
-	RTTI *						GetRTTIOfType(class_name *)															\
+	JPH::RTTI *					GetRTTIOfType(class_name *)															\
 	{																												\
-		static RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
+		static JPH::RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
 		return &rtti;																								\
 	}																												\
-	void						class_name::sCreateRTTI(RTTI &inRTTI)												\
+	void						class_name::sCreateRTTI(JPH::RTTI &inRTTI)											\
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Same as above, but when you cannot insert the declaration in the class
@@ -215,18 +215,18 @@ public:																												\
 
 // JPH_DECLARE_RTTI_OUTSIDE_CLASS
 #define JPH_DECLARE_RTTI_OUTSIDE_CLASS(linkage, class_name)															\
-	linkage RTTI *				GetRTTIOfType(class_name *);														\
-	inline const RTTI *			GetRTTI(const class_name *inObject) { return GetRTTIOfType((class_name *)nullptr); }\
-	void						CreateRTTI##class_name(RTTI &inRTTI);												\
+	linkage JPH::RTTI *			GetRTTIOfType(class_name *);														\
+	inline const JPH::RTTI *	GetRTTI(const class_name *inObject) { return GetRTTIOfType((class_name *)nullptr); }\
+	void						CreateRTTI##class_name(JPH::RTTI &inRTTI);											\
 
 // JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS
 #define JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(class_name)																\
-	RTTI *						GetRTTIOfType(class_name *)															\
+	JPH::RTTI *					GetRTTIOfType(class_name *)															\
 	{																												\
-		static RTTI rtti((const char *)#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &CreateRTTI##class_name); \
+		static JPH::RTTI rtti((const char *)#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &CreateRTTI##class_name); \
 		return &rtti;																								\
 	}																												\
-	void						CreateRTTI##class_name(RTTI &inRTTI)
+	void						CreateRTTI##class_name(JPH::RTTI &inRTTI)
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Same as above, but for classes that have virtual functions
@@ -235,11 +235,11 @@ public:																												\
 #define JPH_DECLARE_RTTI_HELPER(linkage, class_name, modifier)														\
 public:																												\
 	JPH_OVERRIDE_NEW_DELETE																							\
-	friend linkage RTTI *		GetRTTIOfType(class_name *);														\
-	friend inline const RTTI *	GetRTTI(const class_name *inObject) { return inObject->GetRTTI(); }					\
-	virtual const RTTI *		GetRTTI() const modifier;															\
-	virtual const void *		CastTo(const RTTI *inRTTI) const modifier;											\
-	static void					sCreateRTTI(RTTI &inRTTI);															\
+	friend linkage JPH::RTTI *	GetRTTIOfType(class_name *);														\
+	friend inline const JPH::RTTI *GetRTTI(const class_name *inObject) { return inObject->GetRTTI(); }				\
+	virtual const JPH::RTTI *	GetRTTI() const modifier;															\
+	virtual const void *		CastTo(const JPH::RTTI *inRTTI) const modifier;										\
+	static void					sCreateRTTI(JPH::RTTI &inRTTI);														\
 
 // JPH_DECLARE_RTTI_VIRTUAL - for derived classes with RTTI
 #define JPH_DECLARE_RTTI_VIRTUAL(linkage, class_name)																\
@@ -247,20 +247,20 @@ public:																												\
 
 // JPH_IMPLEMENT_RTTI_VIRTUAL
 #define JPH_IMPLEMENT_RTTI_VIRTUAL(class_name)																		\
-	RTTI *			GetRTTIOfType(class_name *)																		\
+	JPH::RTTI *					GetRTTIOfType(class_name *)															\
 	{																												\
-		static RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
+		static JPH::RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
 		return &rtti;																								\
 	}																												\
-	const RTTI *				class_name::GetRTTI() const															\
+	const JPH::RTTI *			class_name::GetRTTI() const															\
 	{																												\
 		return JPH_RTTI(class_name);																				\
 	}																												\
-	const void *				class_name::CastTo(const RTTI *inRTTI) const										\
+	const void *				class_name::CastTo(const JPH::RTTI *inRTTI) const									\
 	{																												\
 		return JPH_RTTI(class_name)->CastTo((const void *)this, inRTTI);											\
 	}																												\
-	void						class_name::sCreateRTTI(RTTI &inRTTI)												\
+	void						class_name::sCreateRTTI(JPH::RTTI &inRTTI)											\
 
 // JPH_DECLARE_RTTI_VIRTUAL_BASE - for concrete base class that has RTTI
 #define JPH_DECLARE_RTTI_VIRTUAL_BASE(linkage, class_name)															\
@@ -276,20 +276,20 @@ public:																												\
 
 // JPH_IMPLEMENT_RTTI_ABSTRACT
 #define JPH_IMPLEMENT_RTTI_ABSTRACT(class_name)																		\
-	RTTI *						GetRTTIOfType(class_name *)															\
+	JPH::RTTI *					GetRTTIOfType(class_name *)															\
 	{																												\
-		static RTTI rtti(#class_name, sizeof(class_name), nullptr, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
+		static JPH::RTTI rtti(#class_name, sizeof(class_name), nullptr, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
 		return &rtti;																								\
 	}																												\
-	const RTTI *				class_name::GetRTTI() const															\
+	const JPH::RTTI *			class_name::GetRTTI() const															\
 	{																												\
 		return JPH_RTTI(class_name);																				\
 	}																												\
-	const void *				class_name::CastTo(const RTTI *inRTTI) const										\
+	const void *				class_name::CastTo(const JPH::RTTI *inRTTI) const									\
 	{																												\
 		return JPH_RTTI(class_name)->CastTo((const void *)this, inRTTI);											\
 	}																												\
-	void						class_name::sCreateRTTI(RTTI &inRTTI)												\
+	void						class_name::sCreateRTTI(JPH::RTTI &inRTTI)											\
 
 // JPH_DECLARE_RTTI_ABSTRACT_BASE - for abstract base class that has RTTI
 #define JPH_DECLARE_RTTI_ABSTRACT_BASE(linkage, class_name)															\
@@ -304,12 +304,12 @@ public:																												\
 //////////////////////////////////////////////////////////////////////////////////////////
 
 #define JPH_DECLARE_RTTI_FOR_FACTORY(linkage, class_name)															\
-	linkage RTTI *				GetRTTIOfType(class class_name *);
+	linkage JPH::RTTI *			GetRTTIOfType(class class_name *);
 
 #define JPH_DECLARE_RTTI_WITH_NAMESPACE_FOR_FACTORY(linkage, name_space, class_name)								\
 	namespace name_space {																							\
 		class class_name;																							\
-		linkage RTTI *			GetRTTIOfType(class class_name *);													\
+		linkage JPH::RTTI *		GetRTTIOfType(class class_name *);													\
 	}
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -335,7 +335,7 @@ public:																												\
 //////////////////////////////////////////////////////////////////////////////////////////
 
 /// Define very dirty macro to get the offset of a baseclass into a class
-#define JPH_BASE_CLASS_OFFSET(inClass, inBaseClass)	((int(uint64((inBaseClass *)((inClass *)0x10000))))-0x10000)
+#define JPH_BASE_CLASS_OFFSET(inClass, inBaseClass)	((int(JPH::uint64((inBaseClass *)((inClass *)0x10000))))-0x10000)
 
 // JPH_ADD_BASE_CLASS
 #define JPH_ADD_BASE_CLASS(class_name, base_class_name)																\

Jolt/ObjectStream/SerializableAttributeEnum.h

@@ -51,7 +51,7 @@ inline void AddSerializableAttributeEnum(RTTI &inRTTI, uint inOffset, const char
 
 // 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::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) \

Jolt/ObjectStream/SerializableAttributeTyped.h

@@ -44,7 +44,7 @@ inline void AddSerializableAttributeTyped(RTTI &inRTTI, uint inOffset, const cha
 
 // 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::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) \

Jolt/ObjectStream/SerializableObject.h

@@ -16,52 +16,52 @@ JPH_NAMESPACE_BEGIN
 
 // 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 **);
+	linkage prefix bool	OSReadData(JPH::IObjectStreamIn &ioStream, class_name &inInstance);							\
+	linkage prefix bool	OSReadData(JPH::IObjectStreamIn &ioStream, class_name *&inPointer);							\
+	linkage prefix bool	OSIsType(class_name *, int inArrayDepth, JPH::EOSDataType inDataType, const char *inClassName);	\
+	linkage prefix bool	OSIsType(class_name **, int inArrayDepth, JPH::EOSDataType inDataType, const char *inClassName); \
+	linkage prefix void	OSWriteData(JPH::IObjectStreamOut &ioStream, const class_name &inInstance);					\
+	linkage prefix void	OSWriteData(JPH::IObjectStreamOut &ioStream, class_name *const &inPointer);					\
+	linkage prefix void	OSWriteDataType(JPH::IObjectStreamOut &ioStream, class_name *);								\
+	linkage prefix void	OSWriteDataType(JPH::IObjectStreamOut &ioStream, class_name **);
 
 // JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS
 #define JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)															\
-	bool		OSReadData(IObjectStreamIn &ioStream, class_name &inInstance)										\
+	bool		OSReadData(JPH::IObjectStreamIn &ioStream, class_name &inInstance)									\
 	{																												\
 		return ioStream.ReadClassData(#class_name, (void *)&inInstance);											\
 	}																												\
-	bool		OSReadData(IObjectStreamIn &ioStream, class_name *&inPointer)										\
+	bool		OSReadData(JPH::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)			\
+	bool		OSIsType(class_name *, int inArrayDepth, JPH::EOSDataType inDataType, const char *inClassName)		\
 	{																												\
-		return inArrayDepth == 0 && inDataType == EOSDataType::Instance && strcmp(inClassName, #class_name) == 0;	\
+		return inArrayDepth == 0 && inDataType == JPH::EOSDataType::Instance && strcmp(inClassName, #class_name) == 0; \
 	}																												\
-	bool		OSIsType(class_name **, int inArrayDepth, EOSDataType inDataType, const char *inClassName)			\
+	bool		OSIsType(class_name **, int inArrayDepth, JPH::EOSDataType inDataType, const char *inClassName)		\
 	{																												\
-		return inArrayDepth == 0 && inDataType == EOSDataType::Pointer && strcmp(inClassName, #class_name) == 0;	\
+		return inArrayDepth == 0 && inDataType == JPH::EOSDataType::Pointer && strcmp(inClassName, #class_name) == 0; \
 	}																												\
-	void		OSWriteData(IObjectStreamOut &ioStream, const class_name &inInstance)								\
+	void		OSWriteData(JPH::IObjectStreamOut &ioStream, const class_name &inInstance)							\
 	{																												\
 		ioStream.WriteClassData(JPH_RTTI(class_name), (void *)&inInstance);											\
 	}																												\
-	void		OSWriteData(IObjectStreamOut &ioStream, class_name *const &inPointer)								\
+	void		OSWriteData(JPH::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 *)											\
+	void		OSWriteDataType(JPH::IObjectStreamOut &ioStream, class_name *)										\
 	{																												\
-		ioStream.WriteDataType(EOSDataType::Instance);																\
+		ioStream.WriteDataType(JPH::EOSDataType::Instance);															\
 		ioStream.WriteName(#class_name);																			\
 	}																												\
-	void		OSWriteDataType(IObjectStreamOut &ioStream, class_name **)											\
+	void		OSWriteDataType(JPH::IObjectStreamOut &ioStream, class_name **)										\
 	{																												\
-		ioStream.WriteDataType(EOSDataType::Pointer);																\
+		ioStream.WriteDataType(JPH::EOSDataType::Pointer);															\
 		ioStream.WriteName(#class_name);																			\
 	}