Fixed a serious issue with serialization where Reflectable object size wasn't being calculated properly

Material can now be properly loaded/unloaded

CamelotClient/CamelotClient.cpp

@@ -205,9 +205,11 @@ int CALLBACK WinMain(
 	dbgMeshRef = static_resource_cast<Mesh>(gResources().load("C:\\ExportMesh.mesh"));
 
 	testMaterial->setTexture("tex", testTexRef);
-	//gResources().create(testMaterial, "C:\\ExportMaterial.mat", true);
+	gResources().create(testMaterial, "C:\\ExportMaterial.mat", true);
 
-	//testMaterial = gResources().load("C:\\ExportMaterial.mat");
+	gResources().unload(testMaterial);
+
+	testMaterial = gResources().load("C:\\ExportMaterial.mat");
 
 	//_ASSERT(_CrtCheckMemory());
 
@@ -224,13 +226,14 @@ int CALLBACK WinMain(
 	// Release everything before shutdown
 	
 	//testMaterial->destroy();
-	testMaterial.reset();
 
 	gResources().unload(testTexRef);
 	gResources().unload(dbgMeshRef);
 	gResources().unload(fragProgRef);
 	gResources().unload(vertProgRef);
+	gResources().unload(testMaterial);
 
+	testMaterial.reset();
 	testTexRef.reset();
 	dbgMeshRef.reset();
 	fragProgRef.reset();

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -962,6 +962,12 @@ namespace CamelotEngine
 			return;
 		}
 
+		if(mActiveVertexShader == nullptr)
+		{
+			LOGWRN("Cannot apply input layout without a vertex shader. Set vertex shader before calling this method.");
+			return;
+		}
+
 		ID3D11InputLayout* ia = mIAManager->retrieveInputLayout(mActiveVertexShader->getInputDeclaration(), mActiveVertexDeclaration, *mActiveVertexShader);
 
 		mDevice->getImmediateContext()->IASetInputLayout(ia);

CamelotRenderer/Include/CmResourceHandle.h

@@ -7,7 +7,7 @@ namespace CamelotEngine
 	template <typename T>
 	class ResourceHandle;
 
-	struct CM_EXPORT ResourceHandleData : public IReflectable
+	struct CM_EXPORT ResourceHandleData
 	{
 		ResourceHandleData()
 			:mIsCreated(false)
@@ -15,15 +15,7 @@ namespace CamelotEngine
 
 		std::shared_ptr<Resource> mPtr;
 		String mUUID;
-		bool mIsCreated;
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-	public:
-		friend class ResourceHandleDataRTTI;
-		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const;		
+		bool mIsCreated;	
 	};
 
 	class CM_EXPORT ResourceHandleBase : public IReflectable

CamelotRenderer/Include/CmResourceHandleRTTI.h

@@ -7,46 +7,15 @@
 
 namespace CamelotEngine
 {
-	class CM_EXPORT ResourceHandleDataRTTI : public RTTIType<ResourceHandleData, IReflectable, ResourceHandleDataRTTI>
-	{
-	private:
-		String& getUUID(ResourceHandleData* obj) { return obj->mUUID; }
-		void setUUID(ResourceHandleData* obj, String& uuid) 
-		{ 
-			obj->mUUID = uuid; 
-		} 
-	public:
-		ResourceHandleDataRTTI()
-		{
-			addPlainField("mUUID", 0, &ResourceHandleDataRTTI::getUUID, &ResourceHandleDataRTTI::setUUID);
-		}
-
-		virtual const String& getRTTIName()
-		{
-			static String name = "ResourceHandleData";
-			return name;
-		}
-
-		virtual UINT32 getRTTIId()
-		{
-			return TID_ResourceHandleData;
-		}
-
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
-		{
-			return std::shared_ptr<ResourceHandleData>(new ResourceHandleData());
-		}
-	};
-
 	class CM_EXPORT ResourceHandleRTTI : public RTTIType<ResourceHandleBase, IReflectable, ResourceHandleRTTI>
 	{
 	private:
-		std::shared_ptr<ResourceHandleData> getResData(ResourceHandleBase* obj) { return obj->mData; }
-		void setResData(ResourceHandleBase* obj, std::shared_ptr<ResourceHandleData> val) { obj->mData = val; }
+		String& getUUID(ResourceHandleBase* obj) { return obj->mData->mUUID; }
+		void setUUID(ResourceHandleBase* obj, String& uuid) { obj->mData->mUUID = uuid; } 
 	public:
 		ResourceHandleRTTI()
 		{
-			addReflectablePtrField("mData", 0, &ResourceHandleRTTI::getResData, &ResourceHandleRTTI::setResData);
+			addPlainField("mUUID", 0, &ResourceHandleRTTI::getUUID, &ResourceHandleRTTI::setUUID);
 		}
 
 		void onDeserializationEnded(IReflectable* obj)

CamelotRenderer/Source/CmMaterialRTTI.cpp

@@ -142,12 +142,16 @@ namespace CamelotEngine
 						MaterialSamplerStateParam param;
 						param.name = iter->first;
 						param.value = material->getSamplerState(iter->first);
+
+						//params->samplerStateParams.push_back(param);
 					}
 					else if(Shader::isTexture(paramDesc.type))
 					{
 						MaterialTextureParam param;
 						param.name = iter->first;
 						param.value = material->getTexture(iter->first);
+
+						params->textureParams.push_back(param);
 					}
 					else if(Shader::isBuffer(paramDesc.type))
 					{

CamelotRenderer/Source/CmResourceHandle.cpp

@@ -9,16 +9,6 @@ namespace CamelotEngine
 	CM_STATIC_THREAD_SYNCHRONISER_CLASS_INSTANCE(mResourceCreatedCondition, ResourceHandleBase)
 	CM_STATIC_MUTEX_CLASS_INSTANCE(mResourceCreatedMutex, ResourceHandleBase)
 
-	RTTITypeBase* ResourceHandleData::getRTTIStatic()
-	{
-		return ResourceHandleDataRTTI::instance();
-	}
-
-	RTTITypeBase* ResourceHandleData::getRTTI() const
-	{
-		return ResourceHandleData::getRTTIStatic();
-	}
-
 	ResourceHandleBase::ResourceHandleBase()
 	{
 		mData = std::shared_ptr<ResourceHandleData>(new ResourceHandleData());

CamelotUtility/Source/CmBinarySerializer.cpp

@@ -821,6 +821,7 @@ namespace CamelotEngine
 								for(UINT32 arrIdx = 0; arrIdx < arrayNumElems; arrIdx++)
 								{
 									IReflectable& childObject = curField->getArrayValue(object, arrIdx);
+									objectSize += sizeof(UINT32); // Complex type size
 									objectSize += getObjectSize(&childObject);
 								}
 
@@ -861,6 +862,8 @@ namespace CamelotEngine
 						{
 							RTTIReflectableFieldBase* curField = static_cast<RTTIReflectableFieldBase*>(curGenericField);
 							IReflectable& childObject = curField->getValue(object);
+
+							objectSize += sizeof(UINT32); // Complex type size
 							objectSize += getObjectSize(&childObject);
 
 							break;