Build: Updated bsf version

Source/EditorCore/Private/RTTI/BsDockManagerLayoutRTTI.h

@@ -80,45 +80,43 @@ namespace bs
 	{	
 		enum { id = bs::TID_DockManagerLayoutEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const bs::DockManagerLayout::Entry& data, char* memory)
+		static uint32_t toMemory(const bs::DockManagerLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-			size += sizeof(UINT32);
-
-			memory = rttiWriteElem(data.isLeaf, memory, size);
-			memory = rttiWriteElem(data.horizontalSplit, memory, size);
-			memory = rttiWriteElem(data.splitPosition, memory, size);
-			memory = rttiWriteElem(data.widgetNames, memory, size);
-
-			if(!data.isLeaf)
+			return rtti_write_with_size_header(stream, [&data, &stream]()
 			{
-				memory = rttiWriteElem(*data.children[0], memory, size);
-				memory = rttiWriteElem(*data.children[1], memory, size);
-			}
+				uint32_t size = 0;
+				size += rttiWriteElem(data.isLeaf, stream);
+				size += rttiWriteElem(data.horizontalSplit, stream);
+				size += rttiWriteElem(data.splitPosition, stream);
+				size += rttiWriteElem(data.widgetNames, stream);
+
+				if (!data.isLeaf)
+				{
+					size += rttiWriteElem(*data.children[0], stream);
+					size += rttiWriteElem(*data.children[1], stream);
+				}
 
-			memcpy(memoryStart, &size, sizeof(UINT32));
+				return size;
+			});
 		}
 
-		static UINT32 fromMemory(bs::DockManagerLayout::Entry& data, char* memory)
+		static uint32_t fromMemory(bs::DockManagerLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
 
-			memory = rttiReadElem(data.isLeaf, memory);
-			memory = rttiReadElem(data.horizontalSplit, memory);
-			memory = rttiReadElem(data.splitPosition, memory);
-			memory = rttiReadElem(data.widgetNames, memory);
+			rttiReadElem(data.isLeaf, stream);
+			rttiReadElem(data.horizontalSplit, stream);
+			rttiReadElem(data.splitPosition, stream);
+			rttiReadElem(data.widgetNames, stream);
 
 			if(!data.isLeaf)
 			{
 				data.children[0] = bs_new<bs::DockManagerLayout::Entry>();
 				data.children[1] = bs_new<bs::DockManagerLayout::Entry>();
 
-				memory = rttiReadElem(*data.children[0], memory);
-				memory = rttiReadElem(*data.children[1], memory);
+				rttiReadElem(*data.children[0], stream);
+				rttiReadElem(*data.children[1], stream);
 				
 				data.children[0]->parent = &data;
 				data.children[1]->parent = &data;
@@ -127,9 +125,9 @@ namespace bs
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const bs::DockManagerLayout::Entry& data)	
+		static uint32_t getDynamicSize(const bs::DockManagerLayout::Entry& data)	
 		{ 
-			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.isLeaf) + rttiGetElemSize(data.horizontalSplit) + 
+			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.isLeaf) + rttiGetElemSize(data.horizontalSplit) + 
 				rttiGetElemSize(data.splitPosition) + rttiGetElemSize(data.widgetNames);
 
 			if(!data.isLeaf)
@@ -139,13 +137,13 @@ namespace bs
 			}
 
 #if BS_DEBUG_MODE
-			if(dataSize > std::numeric_limits<UINT32>::max())
+			if(dataSize > std::numeric_limits<uint32_t>::max())
 			{
 				__string_throwDataOverflowException();
 			}
 #endif
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}	
 	}; 
 

Source/EditorCore/Private/RTTI/BsEditorSettingsRTTI.h

@@ -68,43 +68,40 @@ namespace bs
 	{
 		enum { id = TID_RecentProject }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const RecentProject& data, char* memory)
+		static uint32_t toMemory(const RecentProject& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
-			UINT32 size = 0;
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-			size += sizeof(UINT32);
-
-			memory = rttiWriteElem(data.path, memory, size);
-			memory = rttiWriteElem(data.accessTimestamp, memory, size);
+			return rtti_write_with_size_header(stream, [&data, &stream]()
+			{
+				uint32_t size = 0;
+				size += rttiWriteElem(data.path, stream);
+				size += rttiWriteElem(data.accessTimestamp, stream);
 
-			memcpy(memoryStart, &size, sizeof(UINT32));
+				return size;
+			});
 		}
 
-		static UINT32 fromMemory(RecentProject& data, char* memory)
+		static uint32_t fromMemory(RecentProject& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
-
-			memory = rttiReadElem(data.path, memory);
-			memory = rttiReadElem(data.accessTimestamp, memory);
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
+			rttiReadElem(data.path, stream);
+			rttiReadElem(data.accessTimestamp, stream);
 
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const RecentProject& data)
+		static uint32_t getDynamicSize(const RecentProject& data)
 		{
-			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.path) + rttiGetElemSize(data.accessTimestamp);
+			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.path) + rttiGetElemSize(data.accessTimestamp);
 
 #if BS_DEBUG_MODE
-			if (dataSize > std::numeric_limits<UINT32>::max())
+			if (dataSize > std::numeric_limits<uint32_t>::max())
 			{
 				__string_throwDataOverflowException();
 			}
 #endif
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}
 	};
 

Source/EditorCore/Private/RTTI/BsEditorWidgetLayoutRTTI.h

@@ -62,52 +62,49 @@ namespace bs
 	{	
 		enum { id = bs::TID_EditorWidgetLayoutEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const bs::EditorWidgetLayout::Entry& data, char* memory)
+		static uint32_t toMemory(const bs::EditorWidgetLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-			size += sizeof(UINT32);
-
-			memory = rttiWriteElem(data.widgetNames, memory, size);
-			memory = rttiWriteElem(data.isDocked, memory, size);
-			memory = rttiWriteElem(data.x, memory, size);
-			memory = rttiWriteElem(data.y, memory, size);
-			memory = rttiWriteElem(data.width, memory, size);
-			memory = rttiWriteElem(data.height, memory, size);
-
-			memcpy(memoryStart, &size, sizeof(UINT32));
+			return rtti_write_with_size_header(stream, [&data, &stream]()
+			{
+				uint32_t size = 0;
+				size += rttiWriteElem(data.widgetNames, stream);
+				size += rttiWriteElem(data.isDocked, stream);
+				size += rttiWriteElem(data.x, stream);
+				size += rttiWriteElem(data.y, stream);
+				size += rttiWriteElem(data.width, stream);
+				size += rttiWriteElem(data.height, stream);
+
+				return size;
+			});
 		}
 
-		static UINT32 fromMemory(bs::EditorWidgetLayout::Entry& data, char* memory)
+		static uint32_t fromMemory(bs::EditorWidgetLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
-
-			memory = rttiReadElem(data.widgetNames, memory);
-			memory = rttiReadElem(data.isDocked, memory);
-			memory = rttiReadElem(data.x, memory);
-			memory = rttiReadElem(data.y, memory);
-			memory = rttiReadElem(data.width, memory);
-			memory = rttiReadElem(data.height, memory);
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
+			rttiReadElem(data.widgetNames, stream);
+			rttiReadElem(data.isDocked, stream);
+			rttiReadElem(data.x, stream);
+			rttiReadElem(data.y, stream);
+			rttiReadElem(data.width, stream);
+			rttiReadElem(data.height, stream);
 
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const bs::EditorWidgetLayout::Entry& data)	
+		static uint32_t getDynamicSize(const bs::EditorWidgetLayout::Entry& data)	
 		{ 
-			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.widgetNames) + rttiGetElemSize(data.isDocked) + 
+			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.widgetNames) + rttiGetElemSize(data.isDocked) + 
 				rttiGetElemSize(data.x) + rttiGetElemSize(data.y) + rttiGetElemSize(data.width) + rttiGetElemSize(data.height);
 
 #if BS_DEBUG_MODE
-			if(dataSize > std::numeric_limits<UINT32>::max())
+			if(dataSize > std::numeric_limits<uint32_t>::max())
 			{
 				__string_throwDataOverflowException();
 			}
 #endif
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}	
 	}; 
 

Source/EditorCore/Private/RTTI/BsProjectLibraryEntriesRTTI.h

@@ -55,62 +55,62 @@ namespace bs
 	{	
 		enum { id = TID_ProjectLibraryResEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const ProjectLibrary::FileEntry& data, char* memory)
+		static uint32_t toMemory(const ProjectLibrary::FileEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-			size += sizeof(UINT32);
+			return rtti_write_with_size_header(stream, [&data, &stream]()
+				{
+				uint32_t size = 0;
 
-			// For compatibility, encoding the name as a wide string
-			WString elemName = UTF8::toWide(data.elementName);
+				// For compatibility, encoding the name as a wide string
+				WString elemName = UTF8::toWide(data.elementName);
 
-			UINT32 type = (UINT32)data.type;
-			memory = rttiWriteElem(type, memory, size);
-			memory = rttiWriteElem(data.path, memory, size);
-			memory = rttiWriteElem(elemName, memory, size);
-			memory = rttiWriteElem(data.lastUpdateTime, memory, size);
+				auto type = (uint32_t)data.type;
+				size += rttiWriteElem(type, stream);
+				size += rttiWriteElem(data.path, stream);
+				size += rttiWriteElem(elemName, stream);
+				size += rttiWriteElem(data.lastUpdateTime, stream);
 
-			memcpy(memoryStart, &size, sizeof(UINT32));
+				return size;
+
+			});
 		}
 
-		static UINT32 fromMemory(ProjectLibrary::FileEntry& data, char* memory)
+		static uint32_t fromMemory(ProjectLibrary::FileEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
 
-			UINT32 type;
-			memory = rttiReadElem(type, memory);
+			uint32_t type;
+			rttiReadElem(type, stream);
 			data.type = (ProjectLibrary::LibraryEntryType)type;
 
-			memory = rttiReadElem(data.path, memory);
+			rttiReadElem(data.path, stream);
 
 			WString elemName;
-			memory = rttiReadElem(elemName, memory);
+			rttiReadElem(elemName, stream);
 			data.elementName = UTF8::fromWide(elemName);
 			data.elementNameHash = bs_hash(UTF8::toLower(data.elementName));
 
-			memory = rttiReadElem(data.lastUpdateTime, memory);
+			rttiReadElem(data.lastUpdateTime, stream);
 
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const ProjectLibrary::FileEntry& data)	
+		static uint32_t getDynamicSize(const ProjectLibrary::FileEntry& data)	
 		{ 
 			WString elemName = UTF8::toWide(data.elementName);
 
-			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
+			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
 				rttiGetElemSize(elemName) + rttiGetElemSize(data.lastUpdateTime);
 
 #if BS_DEBUG_MODE
-			if(dataSize > std::numeric_limits<UINT32>::max())
+			if(dataSize > std::numeric_limits<uint32_t>::max())
 			{
 				__string_throwDataOverflowException();
 			}
 #endif
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}	
 	}; 
 
@@ -118,67 +118,70 @@ namespace bs
 	{	
 		enum { id = TID_ProjectLibraryDirEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const ProjectLibrary::DirectoryEntry& data, char* memory)
+		static uint32_t toMemory(const ProjectLibrary::DirectoryEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
-			UINT32 size = 0;
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-			size += sizeof(UINT32);
+			return rtti_write_with_size_header(stream, [&data, &stream]()
+			{
+				uint32_t size = 0;
 
-			// For compatibility, encoding the name as a wide string
-			WString elemName = UTF8::toWide(data.elementName);
+				// For compatibility, encoding the name as a wide string
+				WString elemName = UTF8::toWide(data.elementName);
 
-			memory = rttiWriteElem(data.type, memory, size);
-			memory = rttiWriteElem(data.path, memory, size);
-			memory = rttiWriteElem(elemName, memory, size);
+				size += rttiWriteElem(data.type, stream);
+				size += rttiWriteElem(data.path, stream);
+				size += rttiWriteElem(elemName, stream);
 
-			UINT32 numChildren = (UINT32)data.mChildren.size();
-			memory = rttiWriteElem(numChildren, memory, size);
+				uint32_t numChildren = (UINT32)data.mChildren.size();
+				size += rttiWriteElem(numChildren, stream);
 
-			for(auto& child : data.mChildren)
-			{
-				if(child->type == ProjectLibrary::LibraryEntryType::File)
-				{
-					auto* childResEntry = static_cast<ProjectLibrary::FileEntry*>(child.get());
-					memory = rttiWriteElem(*childResEntry, memory, size);
-				}
-				else if(child->type == ProjectLibrary::LibraryEntryType::Directory)
+				for(auto& child : data.mChildren)
 				{
-					auto* childDirEntry = static_cast<ProjectLibrary::DirectoryEntry*>(child.get());
-					memory = rttiWriteElem(*childDirEntry, memory, size);
+					if(child->type == ProjectLibrary::LibraryEntryType::File)
+					{
+						auto* childResEntry = static_cast<ProjectLibrary::FileEntry*>(child.get());
+						size = rttiWriteElem(*childResEntry, stream);
+					}
+					else if(child->type == ProjectLibrary::LibraryEntryType::Directory)
+					{
+						auto* childDirEntry = static_cast<ProjectLibrary::DirectoryEntry*>(child.get());
+						size += rttiWriteElem(*childDirEntry, stream);
+					}
 				}
-			}
 
-			memcpy(memoryStart, &size, sizeof(UINT32));
+				return size;
+			});
 		}
 
-		static UINT32 fromMemory(ProjectLibrary::DirectoryEntry& data, char* memory)
+		static uint32_t fromMemory(ProjectLibrary::DirectoryEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
 
-			memory = rttiReadElem(data.type, memory);
-			memory = rttiReadElem(data.path, memory);
+			rttiReadElem(data.type, stream);
+			rttiReadElem(data.path, stream);
 
 			WString elemName;
-			memory = rttiReadElem(elemName, memory);
+			rttiReadElem(elemName, stream);
 			data.elementName = UTF8::fromWide(elemName);
 			data.elementNameHash = bs_hash(UTF8::toLower(data.elementName));
 
 			UINT32 numChildren = 0;
-			memory = rttiReadElem(numChildren, memory);
+			rttiReadElem(numChildren, stream);
 
 			for (UINT32 i = 0; i < numChildren; i++)
 			{
 				ProjectLibrary::LibraryEntryType childType = ProjectLibrary::LibraryEntryType::File;
-				rttiReadElem(childType, memory + sizeof(UINT32)); // Skip ahead to get type
+
+				uint32_t prevLoc = stream.tell();
+				stream.skipBytes(sizeof(uint32_t)); // Skip ahead to get the type
+				rttiReadElem(childType, stream);
+				stream.seek(prevLoc);
 
 				if (childType == ProjectLibrary::LibraryEntryType::File)
 				{
 					USPtr<ProjectLibrary::FileEntry> childResEntry = bs_ushared_ptr_new<ProjectLibrary::FileEntry>();
 					// Note: Assumes that ProjectLibrary takes care of the cleanup
-					memory = rttiReadElem(*childResEntry, memory);
+					rttiReadElem(*childResEntry, stream);
 
 					childResEntry->parent = &data;
 					data.mChildren.push_back(childResEntry);
@@ -187,7 +190,7 @@ namespace bs
 				{
 					USPtr<ProjectLibrary::DirectoryEntry> childDirEntry = bs_ushared_ptr_new<ProjectLibrary::DirectoryEntry>();
 					// Note: Assumes that ProjectLibrary takes care of the cleanup
-					memory = rttiReadElem(*childDirEntry, memory);
+					rttiReadElem(*childDirEntry, stream);
 
 					childDirEntry->parent = &data;
 					data.mChildren.push_back(childDirEntry);
@@ -197,13 +200,13 @@ namespace bs
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const ProjectLibrary::DirectoryEntry& data)
+		static uint32_t getDynamicSize(const ProjectLibrary::DirectoryEntry& data)
 		{ 
 			WString elemName = UTF8::toWide(data.elementName);
-			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
+			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
 				rttiGetElemSize(elemName);
 
-			dataSize += sizeof(UINT32);
+			dataSize += sizeof(uint32_t);
 
 			for(auto& child : data.mChildren)
 			{
@@ -220,13 +223,13 @@ namespace bs
 			}
 
 #if BS_DEBUG_MODE
-			if(dataSize > std::numeric_limits<UINT32>::max())
+			if(dataSize > std::numeric_limits<uint32_t>::max())
 			{
 				__string_throwDataOverflowException();
 			}
 #endif
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}	
 	};
 

Source/EditorCore/Private/RTTI/BsSettingsRTTI.h

@@ -31,53 +31,39 @@ namespace bs
 		enum { id = TID_SettingsValue }; enum { hasDynamicSize = 1 };
 
 		/** @copydoc RTTIPlainType::toMemory */
-		static void toMemory(const TSettingsValue<T>& data, char* memory)
+		static uint32_t toMemory(const TSettingsValue<T>& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
-			UINT32 size = sizeof(UINT32);
-			char* memoryStart = memory;
-			memory += sizeof(UINT32);
-
-			UINT32 keySize = rttiGetElemSize(data.key);
-			RTTIPlainType<String>::toMemory(data.key, memory);
-
-			memory += keySize;
-			size += keySize;
-
-			UINT32 valueSize = rttiGetElemSize(data.value);
-			RTTIPlainType<T>::toMemory(data.value, memory);
-
-			memory += valueSize;
-			size += valueSize;
+			return rtti_write_with_size_header(stream, [&data, &stream]()
+			{
+				uint32_t size = 0;
+				size += rttiWriteElem(data.key, stream);
+				size += rttiWriteElem(data.value, stream);
 
-			memcpy(memoryStart, &size, sizeof(UINT32));
+				return size;
+			});
 		}
 
 		/** @copydoc RTTIPlainType::fromMemory */
-		static UINT32 fromMemory(TSettingsValue<T>& data, char* memory)
+		static uint32_t fromMemory(TSettingsValue<T>& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
-			UINT32 size = 0;
-			memcpy(&size, memory, sizeof(UINT32));
-			memory += sizeof(UINT32);
-
-			UINT32 keySize = RTTIPlainType<String>::fromMemory(data.key, memory);
-			memory += keySize;
-
-			UINT32 secondSize = RTTIPlainType<T>::fromMemory(data.value, memory);
-			memory += secondSize;
+			uint32_t size = 0;
+			rttiReadElem(size, stream);
+			rttiReadElem(data.key, stream);
+			rttiReadElem(data.value, stream);
 
 			return size;
 		}
 
 		/** @copydoc RTTIPlainType::getDynamicSize */
-		static UINT32 getDynamicSize(const TSettingsValue<T>& data)
+		static uint32_t getDynamicSize(const TSettingsValue<T>& data)
 		{
-			UINT64 dataSize = sizeof(UINT32);
+			uint64_t dataSize = sizeof(uint32_t);
 			dataSize += rttiGetElemSize(data.key);
 			dataSize += rttiGetElemSize(data.value);
 
-			assert(dataSize <= std::numeric_limits<UINT32>::max());
+			assert(dataSize <= std::numeric_limits<uint32_t>::max());
 
-			return (UINT32)dataSize;
+			return (uint32_t)dataSize;
 		}
 	};
 

Source/bsf

@@ -1 +1 @@
-Subproject commit e0141f6a8539c43f61e9c248a30924388f3c1d96
+Subproject commit 791f8afcd306977873b362b84fa8624ed035208f