Better dealing with ResourceRef and ResourceRef RTTI

CamelotRenderer/Include/CmPrerequisites.h

@@ -156,7 +156,8 @@ namespace CamelotEngine
 		TID_Camera = 1007,
 		TID_Renderable = 1008,
 		TID_ResourceRef = 1009,
-		TID_GpuProgram = 1010
+		TID_GpuProgram = 1010,
+		TID_ResourceRefData = 1011
 	};
 }
 

CamelotRenderer/Include/CmResourceRef.h

@@ -7,10 +7,9 @@ namespace CamelotEngine
 	template <typename T>
 	class ResourceRef;
 
-	class CM_EXPORT ResourceRefBase : public IReflectable
+	struct CM_EXPORT ResourceRefData : public IReflectable
 	{
-	protected:
-		ResourceRefBase()
+		ResourceRefData()
 			:mUUIDSet(false)
 		{ }
 
@@ -18,13 +17,25 @@ namespace CamelotEngine
 		String mUUID;
 		bool mUUIDSet;
 
+		friend class ResourceRefDataRTTI;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
+	};
+
+	class CM_EXPORT ResourceRefBase : public IReflectable
+	{
+	protected:
+		ResourceRefBase();
+
+		std::shared_ptr<ResourceRefData> mData;
+
 		void init(Resource* ptr);
 		void init(std::shared_ptr<Resource> ptr);
 
 		template <typename T1>
 		void init(const ResourceRef<T1>& ptr)
 		{
-			init(std::static_pointer_cast<Resource>(ptr.mPtr));
+			init(std::static_pointer_cast<Resource>(ptr.mData->mPtr));
 		}
 
 		/************************************************************************/
@@ -65,18 +76,18 @@ namespace CamelotEngine
 
 		operator ResourceRef<Resource>() 
 		{
-			return ResourceRef<Resource>(this->mPtr); 
+			return ResourceRef<Resource>(mData->mPtr); 
 		}
 
-		const T* get() const { return static_cast<T*>(mPtr.get()); }
+		const T* get() const { return static_cast<T*>(mData->mPtr.get()); }
 		const T* operator-> () const { return get(); }
 		const T& operator* () const { return *get(); }
 
-		T* get() { return static_cast<T*>(mPtr.get()); }
+		T* get() { return static_cast<T*>(mData->mPtr.get()); }
 		T* operator-> () { return get(); }
 		T& operator* () { return *get(); }
 
-		std::shared_ptr<T> getInternalPtr() { return std::static_pointer_cast<T>(mPtr); }
+		std::shared_ptr<T> getInternalPtr() { return std::static_pointer_cast<T>(mData->mPtr); }
 	};
 
 	template<class _Ty1, class _Ty2>

CamelotRenderer/Include/CmResourceRefRTTI.h

@@ -6,19 +6,60 @@
 
 namespace CamelotEngine
 {
-	class CM_EXPORT ResourceRefRTTI : public RTTIType<ResourceRefBase, IReflectable, ResourceRefRTTI>
+	class CM_EXPORT ResourceRefDataRTTI : public RTTIType<ResourceRefData, IReflectable, ResourceRefDataRTTI>
 	{
 	private:
+		String& getUUID(ResourceRefData* obj) { return obj->mUUID; }
+		void setUUID(ResourceRefData* obj, String& uuid) 
+		{ 
+			obj->mUUID = uuid; 
 
+			if(uuid != "")
+			{
+				obj->mUUIDSet = true;
+				// TODO - I probably want to load the resource here
+				//   - Important: consider that user might just want to load the level meta data and not the actual resources
+				//     (Maybe he wants to stream them in as player goes through the world?)
+				//       - Although this should probably be handled on a higher level. Here we just load.
+			}
+		} 
 	public:
-		ResourceRefRTTI()
+		ResourceRefDataRTTI()
+		{
+			addPlainField("mUUID", 0, &ResourceRefDataRTTI::getUUID, &ResourceRefDataRTTI::setUUID);
+		}
+
+		virtual const String& getRTTIName()
 		{
+			static String name = "ResourceRefData";
+			return name;
+		}
+
+		virtual UINT32 getRTTIId()
+		{
+			return TID_ResourceRefData;
+		}
 
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		{
+			return std::shared_ptr<ResourceRefData>(new ResourceRefData());
+		}
+	};
+
+	class CM_EXPORT ResourceRefRTTI : public RTTIType<ResourceRefBase, IReflectable, ResourceRefRTTI>
+	{
+	private:
+		std::shared_ptr<ResourceRefData> getResData(ResourceRefBase* obj) { return obj->mData; }
+		void setResData(ResourceRefBase* obj, std::shared_ptr<ResourceRefData> val) { obj->mData = val; }
+	public:
+		ResourceRefRTTI()
+		{
+			addReflectablePtrField("mData", 0, &ResourceRefRTTI::getResData, &ResourceRefRTTI::setResData);
 		}
 
 		virtual const String& getRTTIName()
 		{
-			static String name = "ResourceRef";
+			static String name = "ResourceRefBase";
 			return name;
 		}
 

CamelotRenderer/Source/CmResourceRef.cpp

@@ -5,6 +5,22 @@
 
 namespace CamelotEngine
 {
+	RTTITypeBase* ResourceRefData::getRTTIStatic()
+	{
+		return ResourceRefDataRTTI::instance();
+	}
+
+	RTTITypeBase* ResourceRefData::getRTTI() const
+	{
+		return ResourceRefData::getRTTIStatic();
+	}
+
+	ResourceRefBase::ResourceRefBase()
+	{
+		mData = std::shared_ptr<ResourceRefData>(new ResourceRefData());
+		mData->mUUIDSet = false;
+	}
+
 	void ResourceRefBase::init(Resource* ptr)
 	{
 		init(std::shared_ptr<Resource>(ptr));
@@ -12,12 +28,12 @@ namespace CamelotEngine
 
 	void ResourceRefBase::init(std::shared_ptr<Resource> ptr)
 	{
-		mPtr = ptr;
+		mData->mPtr = ptr;
 
-		if(mPtr)
+		if(mData->mPtr)
 		{
-			mUUID = mPtr->getUUID();
-			mUUIDSet = true;
+			mData->mUUID = mData->mPtr->getUUID();
+			mData->mUUIDSet = true;
 		}
 	}