Updated ManagedMemoryBlock allocations

CamelotCore/Include/CmMaterialRTTI.h

@@ -356,10 +356,11 @@ namespace CamelotEngine
 
 		ManagedDataBlock getValue(MaterialStructParam* obj) 
 		{ 
-			UINT8* data = new UINT8[obj->value.size];
+			ManagedDataBlock returnValue(obj->value.size);
+
+			UINT8* data = returnValue.getData();
 			memcpy(data, obj->value.data.get(), obj->value.size);
 
-			ManagedDataBlock returnValue(data, obj->value.size, true);
 			return returnValue; 
 		}
 

CamelotCore/Include/CmMeshDataRTTI.h

@@ -11,7 +11,7 @@ namespace CamelotEngine
 	class CM_EXPORT VertexElementDataRTTI : public RTTIType<MeshData::VertexElementData, IReflectable, VertexElementDataRTTI>
 	{
 	private:
-		ManagedDataBlock getVertexData(MeshData::VertexElementData* obj) { return ManagedDataBlock(obj->data, obj->elementCount * obj->element.getSize(), false); }	
+		ManagedDataBlock getVertexData(MeshData::VertexElementData* obj) { return ManagedDataBlock(obj->data, obj->elementCount * obj->element.getSize()); }	
 		void setVertexData(MeshData::VertexElementData* obj, ManagedDataBlock val) { obj->data = val.getData(); } 
 
 		UINT32& getNumElements(MeshData::VertexElementData* obj) { return obj->elementCount; }
@@ -48,7 +48,7 @@ namespace CamelotEngine
 	class CM_EXPORT IndexElementDataRTTI : public RTTIType<MeshData::IndexElementData, IReflectable, IndexElementDataRTTI>
 	{
 	private:
-		ManagedDataBlock getIndexData(MeshData::IndexElementData* obj) { return ManagedDataBlock(obj->indices, obj->numIndices * obj->elementSize, false); }	
+		ManagedDataBlock getIndexData(MeshData::IndexElementData* obj) { return ManagedDataBlock(obj->indices, obj->numIndices * obj->elementSize); }	
 		void setIndexData(MeshData::IndexElementData* obj, ManagedDataBlock val) { obj->indices = val.getData(); } 
 
 		UINT32& getNumIndices(MeshData::IndexElementData* obj) { return obj->numIndices; }

CamelotUtility/Include/CmManagedDataBlock.h

@@ -14,24 +14,23 @@ namespace CamelotEngine
 		 * @brief	Constructor
 		 *
 		 * @param [in]	data		Array of bytes to store. Direct pointer to the provided
-		 * 							array will be stored, no copying will be done. Data won't be modified
-		 * 							unless "managed" is true.
+		 * 							array will be stored, no copying will be done. 
 		 * @param	size			Size of the array, in bytes.
-		 * @param	managed			If true then the provided data array will be deleted once
-		 * 							it is no longer being used. When serializing it is always faster to provide direct
-		 * 							pointer to the data, but sometimes you need to provide a copy of the data
-		 * 							instead (e.g. maybe it's needed in a different format). 
-		 * 							In that case set managed to true so it can be properly freed.
 		 */
-		ManagedDataBlock(UINT8* data, UINT32 size, bool managed);
-		ManagedDataBlock(const ManagedDataBlock& source);
-
-		~ManagedDataBlock();
+		ManagedDataBlock(UINT8* data, UINT32 size);
 
 		/**
-		 * @brief	Destroy underlying buffers for unmanaged data blocks.
+		 * @brief	Constructor that will automatically allocate an internal buffer of the specified size.
+		 * 			Copying ManagedDataBlock transfers ownership of the buffer to the copy of the buffer.
+		 * 			Buffer is deleted when the latest copy is deleted.
+		 *
+		 * @param	size	The size of the data in bytes.
 		 */
-		void destroy();
+		ManagedDataBlock(UINT32 size);
+
+		ManagedDataBlock(const ManagedDataBlock& source);
+
+		~ManagedDataBlock();
 
 		UINT8* getData() { return mData; }
 		UINT32 getSize() { return mData ? mSize : 0; }

CamelotUtility/Include/CmPixelDataRTTI.h

@@ -38,7 +38,7 @@ namespace CamelotEngine
 
 		ManagedDataBlock getData(PixelData* obj) 
 		{ 
-			ManagedDataBlock dataBlock((UINT8*)obj->data, obj->getConsecutiveSize(), false);
+			ManagedDataBlock dataBlock((UINT8*)obj->data, obj->getConsecutiveSize());
 			return dataBlock; 
 		}
 

CamelotUtility/Include/CmRTTIManagedDataBlockField.h

@@ -16,7 +16,7 @@ namespace CamelotEngine
 		UINT8* allocate(UINT32 bytes)
 		{
 			if(mCustomAllocator.empty())
-				return new UINT8[bytes];
+				return CM_NEW_BYTES(bytes, ScratchAlloc);
 			else
 				return mCustomAllocator(bytes);
 		}

CamelotUtility/Source/CmBinarySerializer.cpp

@@ -763,7 +763,7 @@ namespace CamelotEngine
 							UINT8* dataCopy = curField->allocate(dataBlockSize); // TODO - Low priority. I need to read files better, so I
 							memcpy(dataCopy, data, dataBlockSize);		//    can just pass the buffer pointer directly without copying (possibly large amounts of data)
 
-							ManagedDataBlock value(dataCopy, dataBlockSize, false); // Not managed because I assume the owner class will decide whether to delete the data or keep it
+							ManagedDataBlock value(dataCopy, dataBlockSize); // Not managed because I assume the owner class will decide whether to delete the data or keep it
 							curField->setValue(object.get(), value);
 						}
 

CamelotUtility/Source/CmManagedDataBlock.cpp

@@ -3,10 +3,16 @@
 
 namespace CamelotEngine
 {
-	ManagedDataBlock::ManagedDataBlock(UINT8* data, UINT32 size, bool managed)
-		:mData(data), mSize(size), mManaged(managed), mIsDataOwner(true)
+	ManagedDataBlock::ManagedDataBlock(UINT8* data, UINT32 size)
+		:mData(data), mSize(size), mManaged(false), mIsDataOwner(true)
 	{ }
 
+	ManagedDataBlock::ManagedDataBlock(UINT32 size)
+		:mSize(size), mManaged(true), mIsDataOwner(true)
+	{
+		mData = CM_NEW_BYTES(size, ScratchAlloc);
+	}
+
 	ManagedDataBlock::ManagedDataBlock(const ManagedDataBlock& source)
 	{
 		mData = source.mData;
@@ -20,18 +26,6 @@ namespace CamelotEngine
 	ManagedDataBlock::~ManagedDataBlock()
 	{
 		if(mManaged && mIsDataOwner)
-			delete[] mData;
-	}
-
-	void ManagedDataBlock::destroy()
-	{
-		if(mManaged)
-			CM_EXCEPT(InternalErrorException, "Trying to manually destroy managed data.");
-
-		if(mData != nullptr)
-			delete[] mData;
-
-		mSize = 0;
-		mData = nullptr;
+			CM_DELETE_BYTES(mData, ScratchAlloc);
 	}
 }