GameObjectMnaager stores game object handles instead of pointers

CamelotCore/Include/CmGameObject.h

@@ -14,6 +14,8 @@ namespace CamelotFramework
 		UINT64 getInstanceID() const { return mInstanceId; }
 
 	private:
+		friend class GameObjectHandleBase;
+
 		UINT64 mInstanceId;
 
 		/************************************************************************/

CamelotCore/Include/CmGameObjectHandle.h

@@ -2,6 +2,8 @@
 
 namespace CamelotFramework
 {
+	class GameObjectManager;
+
 	struct CM_EXPORT GameObjectHandleData
 	{
 		GameObjectHandleData()
@@ -30,6 +32,7 @@ namespace CamelotFramework
 	class CM_EXPORT GameObjectHandleBase
 	{
 	public:
+		GameObjectHandleBase();
 		GameObjectHandleBase(const std::shared_ptr<GameObjectHandleData> data);
 
 		/**
@@ -62,15 +65,18 @@ namespace CamelotFramework
 	protected:
 		friend SceneObject;
 
-		GameObjectHandleBase();
-
 		inline void throwIfDestroyed() const;
 		
 		void destroy()
 		{
+			unregisterWithManager(*this);
+
 			mData->mPtr = nullptr;
 		}
 
+		void registerWithManager(const GameObjectHandleBase& object);
+		void unregisterWithManager(const GameObjectHandleBase& object);
+
 		std::shared_ptr<GameObjectHandleData> mData;
 	};
 
@@ -145,6 +151,7 @@ namespace CamelotFramework
 			:GameObjectHandleBase()
 		{
 			mData = cm_shared_ptr<GameObjectHandleData, PoolAlloc>(std::static_pointer_cast<GameObject>(ptr));
+			registerWithManager(*this);
 		}
 	};
 

CamelotCore/Include/CmGameObjectManager.h

@@ -2,6 +2,7 @@
 
 #include "CmPrerequisites.h"
 #include "CmModule.h"
+#include "CmGameObjectHandle.h"
 
 namespace CamelotFramework
 {
@@ -11,14 +12,14 @@ namespace CamelotFramework
 		GameObjectManager();
 		~GameObjectManager();
 
-		UINT64 registerObject(GameObject* object);
-		void unregisterObject(GameObject* object);
+		UINT64 registerObject(const GameObjectHandleBase& object);
+		void unregisterObject(const GameObjectHandleBase& object);
 
-		GameObject* getObject(UINT64 id) const;
+		GameObjectHandleBase getObject(UINT64 id) const;
 		bool objectExists(UINT64 id) const;
 
 	private:
 		UINT64 mNextAvailableID; // 0 is not a valid ID
-		Map<UINT64, GameObject*>::type mObjects;
+		Map<UINT64, GameObjectHandleBase>::type mObjects;
 	};
 }

CamelotCore/Include/CmSceneObject.h

@@ -226,6 +226,7 @@ namespace CamelotFramework
 
 			GameObjectHandle<T> newComponent = GameObjectHandle<T>(
 				std::shared_ptr<T>(new (cm_alloc<T, PoolAlloc>()) T(mThisHandle), &cm_delete<PoolAlloc, T>, StdAlloc<PoolAlloc>()));
+
 			mComponents.push_back(newComponent);
 
 			gSceneManager().notifyComponentAdded(newComponent);

CamelotCore/Source/CmGameObject.cpp

@@ -6,14 +6,10 @@ namespace CamelotFramework
 {
 	GameObject::GameObject()
 		:mInstanceId(0)
-	{
-		mInstanceId = GameObjectManager::instance().registerObject(this);
-	}
+	{ }
 
 	GameObject::~GameObject()
-	{
-		GameObjectManager::instance().unregisterObject(this);
-	}
+	{ }
 	
 	RTTITypeBase* GameObject::getRTTIStatic()
 	{

CamelotCore/Source/CmGameObjectHandle.cpp

@@ -1,6 +1,7 @@
 #include "CmPrerequisites.h"
 #include "CmGameObject.h"
 #include "CmGameObjectHandle.h"
+#include "CmGameObjectManager.h"
 #include "CmException.h"
 
 namespace CamelotFramework
@@ -19,4 +20,14 @@ namespace CamelotFramework
 			CM_EXCEPT(InternalErrorException, "Trying to access an object that has been destroyed.");
 		}
 	}
+
+	void GameObjectHandleBase::registerWithManager(const GameObjectHandleBase& object)
+	{
+		object.get()->mInstanceId = GameObjectManager::instance().registerObject(object);
+	}
+
+	void GameObjectHandleBase::unregisterWithManager(const GameObjectHandleBase& object)
+	{
+		GameObjectManager::instance().unregisterObject(object);
+	}
 }

CamelotCore/Source/CmGameObjectManager.cpp

@@ -12,7 +12,7 @@ namespace CamelotFramework
 	GameObjectManager::~GameObjectManager()
 	{ }
 
-	GameObject* GameObjectManager::getObject(UINT64 id) const 
+	GameObjectHandleBase GameObjectManager::getObject(UINT64 id) const 
 	{ 
 		auto iterFind = mObjects.find(id);
 
@@ -27,19 +27,15 @@ namespace CamelotFramework
 		return mObjects.find(id) != mObjects.end(); 
 	}
 
-	UINT64 GameObjectManager::registerObject(GameObject* object)
+	UINT64 GameObjectManager::registerObject(const GameObjectHandleBase& object)
 	{
-		assert(object != nullptr);
-
 		mObjects[mNextAvailableID] = object;
 
 		return mNextAvailableID++;
 	}
 
-	void GameObjectManager::unregisterObject(GameObject* object)
+	void GameObjectManager::unregisterObject(const GameObjectHandleBase& object)
 	{
-		assert(object != nullptr);
-
 		mObjects.erase(object->getInstanceID());
 	}
 }

CamelotCore/Source/CmSceneObject.cpp

@@ -41,6 +41,7 @@ namespace CamelotFramework
 			&cm_delete<PoolAlloc, SceneObject>, StdAlloc<PoolAlloc>());
 
 		HSceneObject sceneObject = GameObjectHandle<SceneObject>(sceneObjectPtr);
+
 		sceneObject->mThisHandle = sceneObject;
 
 		return sceneObject;