Maybe, just maybe I have solved material deserialization crash?

CamelotRenderer/Include/CmMaterial.h

@@ -84,6 +84,8 @@ namespace CamelotEngine
 			}
 		}
 
+		void initBestTechnique();
+
 		/************************************************************************/
 		/* 								RTTI		                     		*/
 		/************************************************************************/

CamelotRenderer/Include/CmMaterialRTTI.h

@@ -92,7 +92,7 @@ namespace CamelotEngine
 			TexParamKVPRTTI()
 			{
 				addPlainField("mKey", 0, &TexParamKVPRTTI::getKey, &TexParamKVPRTTI::setKey);
-				addPlainField("mValue", 1, &TexParamKVPRTTI::getValue, &TexParamKVPRTTI::setValue);
+				addReflectableField("mValue", 1, &TexParamKVPRTTI::getValue, &TexParamKVPRTTI::setValue);
 			}
 
 		public:
@@ -225,7 +225,7 @@ namespace CamelotEngine
 					&MaterialParamsRTTI::setFloatParam, &MaterialParamsRTTI::setNumFloatParams);
 				addReflectablePtrArrayField("mTexParams", 1, &MaterialParamsRTTI::getTexParam, &MaterialParamsRTTI::getNumTexParams, 
 					&MaterialParamsRTTI::setTexParam, &MaterialParamsRTTI::setNumTexParams);
-				addDataBlockField("mFloatBuffer", 2, &MaterialParamsRTTI::getFloatBuffer, &MaterialParamsRTTI::setFloatBuffer);
+				//addDataBlockField("mFloatBuffer", 2, &MaterialParamsRTTI::getFloatBuffer, &MaterialParamsRTTI::setFloatBuffer);
 			}
 
 			virtual const String& getRTTIName()
@@ -247,29 +247,27 @@ namespace CamelotEngine
 
 		ShaderPtr getShader(Material* obj)
 		{
-			return obj->getShader();
+			return obj->mShader;
 		}
 
 		void setShader(Material* obj,  ShaderPtr val)
 		{
-			obj->setShader(val);
+			obj->mShader = val;
 		}
 
 		std::shared_ptr<MaterialParams> getMaterialParams(Material* obj)
 		{
+			if(obj->mRTTIData.empty())
+				return nullptr;
+
 			return boost::any_cast<std::shared_ptr<MaterialParams>>(obj->mRTTIData);
 		}
 
 		void setMaterialParams(Material* obj, std::shared_ptr<MaterialParams> value)
 		{
-			obj->mRTTIData = value;
+			//obj->mRTTIData = value;
 		}
 
-		virtual void onSerializationStarted(IReflectable* obj);
-		virtual void onSerializationEnded(IReflectable* obj);
-		virtual void onDeserializationStarted(IReflectable* obj);
-		virtual void onDeserializationEnded(IReflectable* obj);
-
 	public:
 		MaterialRTTI()
 		{
@@ -277,6 +275,11 @@ namespace CamelotEngine
 			addReflectablePtrField("mMaterialParams", 1, &MaterialRTTI::getMaterialParams, &MaterialRTTI::setMaterialParams);
 		}
 
+		virtual void onSerializationStarted(IReflectable* obj);
+		virtual void onSerializationEnded(IReflectable* obj);
+		virtual void onDeserializationStarted(IReflectable* obj);
+		virtual void onDeserializationEnded(IReflectable* obj);
+
 		virtual const String& getRTTIName()
 		{
 			static String name = "Material";

CamelotRenderer/Include/CmResourceRef.h

@@ -109,7 +109,13 @@ namespace CamelotEngine
 		}
 
 		// TODO Low priority - User can currently try to access these even if resource ptr is not resolved
-		T* get() const { if(!isResolved()) return nullptr; return static_cast<T*>(mData->mPtr.get()); }
+		T* get() const 
+		{ 
+			if(!isResolved()) 
+				return nullptr; 
+			
+			return static_cast<T*>(mData->mPtr.get()); 
+		}
 		T* operator->() const { return get(); }
 		T& operator*() const { return *get(); }
 

CamelotRenderer/Source/CmApplication.cpp

@@ -170,16 +170,33 @@ namespace CamelotEngine
 		mDbgMesh = static_resource_cast<Mesh>(Importer::instance().import("C:\\X_Arena_Tower.FBX"));
 		//mDbgMesh = std::static_pointer_cast<Mesh>(Importer::instance().import("C:\\BarrelMesh.fbx"));
 
+		//// Get current flag
+		//int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
+		//tmpFlag |= _CRTDBG_CHECK_ALWAYS_DF;
+		//// Set flag to the new value.
+		//_CrtSetDbgFlag( tmpFlag );
+
 		gResources().create(testTex, "C:\\ExportTest.tex", true);
 		gResources().create(mDbgMesh, "C:\\ExportMesh.mesh", true);
 
-		mDbgTexture = static_resource_cast<Texture>(gResources().loadAsync("C:\\ExportTest.tex"));
-		mDbgMesh = static_resource_cast<Mesh>(gResources().loadAsync("C:\\ExportMesh.mesh"));
+		mDbgTexture = static_resource_cast<Texture>(gResources().load("C:\\ExportTest.tex"));
+		mDbgMesh = static_resource_cast<Mesh>(gResources().load("C:\\ExportMesh.mesh"));
 
-		mTestMaterial->setTexture("tex", mDbgTexture);
+		//mTestMaterial->setTexture("tex", mDbgTexture);
 		gResources().create(mTestMaterial, "C:\\ExportMaterial.mat", true);
 
-		mTestMaterial = gResources().load("C:\\ExportMaterial.mat");
+		//if(!_CrtCheckMemory())
+		//{
+		//	assert(false);
+		//}
+
+		MaterialRef newMat = gResources().load("C:\\ExportMaterial.mat");
+//		mTestMaterial = gResources().load("C:\\ExportMaterial.mat");
+
+		//if(!_CrtCheckMemory())
+		//{
+		//	assert(false);
+		//}
 
 		loadPlugin("CamelotOISInput"); // TODO - Load this automatically somehow
 	}

CamelotRenderer/Source/CmMaterial.cpp

@@ -15,12 +15,17 @@ namespace CamelotEngine
 	{
 		mShader = shader;
 
+		initBestTechnique();
+	}
+
+	void Material::initBestTechnique()
+	{
 		mBestTechnique = nullptr;
 		mParameters.clear();
 
-		if(shader)
+		if(mShader)
 		{
-			mBestTechnique = shader->getBestTechnique();
+			mBestTechnique = mShader->getBestTechnique();
 
 			if(mBestTechnique)
 			{

CamelotRenderer/Source/CmMaterialRTTI.cpp

@@ -99,61 +99,63 @@ namespace CamelotEngine
 	void MaterialRTTI::onDeserializationEnded(IReflectable* obj)
 	{
 		Material* material = static_cast<Material*>(obj);
-		std::shared_ptr<MaterialParams> params = boost::any_cast<std::shared_ptr<MaterialParams>>(material->mRTTIData);
+		//std::shared_ptr<MaterialParams> params = boost::any_cast<std::shared_ptr<MaterialParams>>(material->mRTTIData);
 
-		vector<GpuProgramParametersPtr>::type allParams;
-		for(size_t i = 0; i < material->mParameters.size(); i++)
-		{
-			if(material->mParameters[i].mFragParams != nullptr)
-				allParams.push_back(material->mParameters[i].mFragParams);
+		//vector<GpuProgramParametersPtr>::type allParams;
+		//for(size_t i = 0; i < material->mParameters.size(); i++)
+		//{
+		//	if(material->mParameters[i].mFragParams != nullptr)
+		//		allParams.push_back(material->mParameters[i].mFragParams);
 
-			if(material->mParameters[i].mVertParams != nullptr)
-				allParams.push_back(material->mParameters[i].mVertParams);
+		//	if(material->mParameters[i].mVertParams != nullptr)
+		//		allParams.push_back(material->mParameters[i].mVertParams);
 
-			if(material->mParameters[i].mGeomParams != nullptr)
-				allParams.push_back(material->mParameters[i].mGeomParams);
-		}
+		//	if(material->mParameters[i].mGeomParams != nullptr)
+		//		allParams.push_back(material->mParameters[i].mGeomParams);
+		//}
 
-		for(size_t i = 0; i < allParams.size(); i++)
-		{
-			const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
+		//for(size_t i = 0; i < allParams.size(); i++)
+		//{
+		//	const GpuNamedConstants& namedConstants = allParams[i]->getConstantDefinitions();
 
-			float tempValue[16];
-			for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
-			{
-				const GpuConstantDefinition& def = iter->second;
+		//	float tempValue[16];
+		//	for(auto iter = namedConstants.map.begin(); iter != namedConstants.map.end(); ++iter)
+		//	{
+		//		const GpuConstantDefinition& def = iter->second;
 
-				if(def.constType == GCT_SAMPLER2D)
-				{
-					auto iterFind = params->mTextureParams.find(iter->first);
+		//		if(def.constType == GCT_SAMPLER2D)
+		//		{
+		//			auto iterFind = params->mTextureParams.find(iter->first);
 
-					if(iterFind != params->mTextureParams.end())
-						allParams[i]->setNamedConstant(iter->first, iterFind->second);
-				}
-				else
-				{
-					auto iterFind = params->mFloatParams.find(iter->first);
+		//			if(iterFind != params->mTextureParams.end())
+		//				allParams[i]->setNamedConstant(iter->first, iterFind->second);
+		//		}
+		//		else
+		//		{
+		//			auto iterFind = params->mFloatParams.find(iter->first);
 
-					if(iterFind != params->mFloatParams.end() && iterFind->second.mType == def.constType)
-					{
-						FloatParam param = iterFind->second;
-						UINT32 fieldSize = def.getElementSize(def.constType, false);
+		//			if(iterFind != params->mFloatParams.end() && iterFind->second.mType == def.constType)
+		//			{
+		//				FloatParam param = iterFind->second;
+		//				UINT32 fieldSize = def.getElementSize(def.constType, false);
 
-						if(fieldSize != param.mCount)
-							CM_EXCEPT(InternalErrorException, "Deserializing material parameter but field sizes don't match.");
+		//				if(fieldSize != param.mCount)
+		//					CM_EXCEPT(InternalErrorException, "Deserializing material parameter but field sizes don't match.");
 
-						if(fieldSize > 16)
-							CM_EXCEPT(InternalErrorException, "Field size larger than the supported size.");
+		//				if(fieldSize > 16)
+		//					CM_EXCEPT(InternalErrorException, "Field size larger than the supported size.");
 
-						for(size_t j = 0; j < fieldSize; j++)
-							tempValue[j] = params->mFloatBuffer[param.mBufferIdx + j];
+		//				for(size_t j = 0; j < fieldSize; j++)
+		//					tempValue[j] = params->mFloatBuffer[param.mBufferIdx + j];
 
-						allParams[i]->_writeRawConstants(def.physicalIndex, tempValue, fieldSize);
-					}
-				}
-			}
-		}
+		//				allParams[i]->_writeRawConstants(def.physicalIndex, tempValue, fieldSize);
+		//			}
+		//		}
+		//	}
+		//}
 
 		material->mRTTIData = nullptr; // This will delete temporary data as it's stored in a unique ptr
+
+		//material->initBestTechnique();
 	}
 }

CamelotUtility/Include/CmKeyValuepair.h

@@ -6,15 +6,12 @@
 
 namespace CamelotEngine
 {
-	template <typename Key, typename Value, typename RTTIType>
-	class KeyValuePairRTTI;
-
-	template <typename Key, typename Value>
-	class KeyValuePairBase : public IReflectable
+	template <typename Key, typename Value, typename RTTIClass>
+	class KeyValuePair : public IReflectable
 	{
 	public:
-		KeyValuePairBase() {}
-		KeyValuePairBase(const Key& key, const Value& value)
+		KeyValuePair() {}
+		KeyValuePair(const Key& key, const Value& value)
 			:mKey(key), mValue(value)
 		{ }
 
@@ -25,66 +22,6 @@ namespace CamelotEngine
 		/* 								RTTI		                     		*/
 		/************************************************************************/
 
-	public:
-		static RTTITypeBase* getRTTIStatic()
-		{
-			return nullptr;
-		}
-
-		RTTITypeBase* getRTTI() const
-		{
-			return nullptr;
-		}
-	};
-
-	//template <typename Key, typename Value, typename MyType>
-	//class KeyValuePairRTTI : public RTTIType<MyType, IReflectable, KeyValuePairRTTI<Key, Value, MyType>>
-	//{
-	//private:
-	//	Key& getKey(KeyValuePairBase<Key, Value>* obj) { return obj->mKey; }
-	//	void setKey(KeyValuePairBase<Key, Value>* obj,  Key& val) { obj->mKey = val; }
-
-	//	Value& getValue(KeyValuePairBase<Key, Value>* obj) { return obj->mValue; }
-	//	void setValue(KeyValuePairBase<Key, Value>* obj,  Value& val) { obj->mValue = val; }
-
-	//public:
-	//	KeyValuePairRTTI()
-	//	{
-	//		addPlainField("mKey", 0, &KeyValuePairRTTI::getKey, &KeyValuePairRTTI::setKey);
-	//		addPlainField("mValue", 1, &KeyValuePairRTTI::getValue, &KeyValuePairRTTI::setValue);
-	//	}
-
-	//public:
-	//	virtual const String& getRTTIName()
-	//	{
-	//		static String name = "Abstract";
-	//		return name;
-	//	}
-
-	//	virtual UINT32 getRTTIId()
-	//	{
-	//		return TID_Abstract;
-	//	}
-
-	//	virtual std::shared_ptr<IReflectable> newRTTIObject()
-	//	{
-	//		CM_EXCEPT(InternalErrorException, "Cannot instantiate abstract class.");
-	//	}
-	//};
-
-	template <typename Key, typename Value, typename RTTIClass>
-	class KeyValuePair : public KeyValuePairBase<Key, Value>
-	{
-	public:
-		KeyValuePair() {}
-		KeyValuePair(const Key& key, const Value& value)
-			:KeyValuePairBase<Key, Value>(key, value)
-		{ }
-
-		/************************************************************************/
-		/* 								RTTI		                     		*/
-		/************************************************************************/
-
 	public:
 		static RTTITypeBase* getRTTIStatic()
 		{

CamelotUtility/Include/CmRTTIType.h

@@ -437,7 +437,10 @@ namespace CamelotEngine
 			void (InterfaceType::*setter)(ObjectType*, DataType&) = nullptr)
 		{
 			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::RTTIType<Type, BaseType, MyRTTIType>, InterfaceType>::value), 
-				"Class with the get/set methods must derive from CamelotEngine::SerializationInterface.");
+				"Class with the get/set methods must derive from CamelotEngine::RTTIType.");
+
+			BOOST_STATIC_ASSERT_MSG(!(boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
+				"Data type derives from IReflectable but it is being added as a plain field.");
 
 			addPlainField<ObjectType, DataType>(name, uniqueId, 
 				boost::function<DataType&(ObjectType*)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1)), 
@@ -471,6 +474,12 @@ namespace CamelotEngine
 			void (InterfaceType::*setter)(ObjectType*, UINT32, DataType&) = nullptr, 
 			void(InterfaceType::*setSize)(ObjectType*, UINT32) = nullptr)
 		{
+			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::RTTIType<Type, BaseType, MyRTTIType>, InterfaceType>::value), 
+				"Class with the get/set methods must derive from CamelotEngine::RTTIType.");
+
+			BOOST_STATIC_ASSERT_MSG(!(boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
+				"Data type derives from IReflectable but it is being added as a plain field.");
+
 			addPlainArrayField<ObjectType, DataType>(name, uniqueId, 
 				boost::function<DataType&(ObjectType*, UINT32)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1, _2)), 
 				boost::function<UINT32(ObjectType*)>(boost::bind(getSize, static_cast<InterfaceType*>(this), _1)), 

CamelotUtility/Source/CmBinarySerializer.cpp

@@ -101,6 +101,9 @@ namespace CamelotEngine
 		}
 
 		*bytesWritten = mTotalBytesWritten;
+
+		mObjectsToEncode.clear();
+		mObjectAddrToId.clear();
 	}
 
 	std::shared_ptr<IReflectable> BinarySerializer::decode(UINT8* data, UINT32 dataLength)
@@ -203,16 +206,24 @@ namespace CamelotEngine
 
 			if(resolvedObject != nullptr)
 			{
-				RTTITypeBase* si = object->getRTTI();
+				RTTITypeBase* si = resolvedObject->getRTTI();
 
 				while(si != nullptr)
 				{
-					si->onDeserializationEnded(object.get());
+					si->onDeserializationEnded(resolvedObject.get());
 					si = si->getBaseClass();
 				}
 			}
 		}
 
+		mPtrsToResolve.clear();
+		//mDecodedObjects.clear();
+
+		while(mDecodedObjects.size() > 0)
+		{
+			mDecodedObjects.erase(mDecodedObjects.begin());
+		}
+
 		return rootObject;
 	}