Build: Updated 'bsf' version

Source/EditorCore/Private/RTTI/BsDockManagerLayoutRTTI.h

@@ -85,15 +85,15 @@ namespace bs
 			return rtti_write_with_size_header(stream, [&data, &stream]()
 			{
 				uint32_t size = 0;
-				size += rttiWriteElem(data.isLeaf, stream);
-				size += rttiWriteElem(data.horizontalSplit, stream);
-				size += rttiWriteElem(data.splitPosition, stream);
-				size += rttiWriteElem(data.widgetNames, stream);
+				size += rtti_write(data.isLeaf, stream);
+				size += rtti_write(data.horizontalSplit, stream);
+				size += rtti_write(data.splitPosition, stream);
+				size += rtti_write(data.widgetNames, stream);
 
 				if (!data.isLeaf)
 				{
-					size += rttiWriteElem(*data.children[0], stream);
-					size += rttiWriteElem(*data.children[1], stream);
+					size += rtti_write(*data.children[0], stream);
+					size += rtti_write(*data.children[1], stream);
 				}
 
 				return size;
@@ -103,20 +103,20 @@ namespace bs
 		static uint32_t fromMemory(bs::DockManagerLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
 			uint32_t size = 0;
-			rttiReadElem(size, stream);
+			rtti_read(size, stream);
 
-			rttiReadElem(data.isLeaf, stream);
-			rttiReadElem(data.horizontalSplit, stream);
-			rttiReadElem(data.splitPosition, stream);
-			rttiReadElem(data.widgetNames, stream);
+			rtti_read(data.isLeaf, stream);
+			rtti_read(data.horizontalSplit, stream);
+			rtti_read(data.splitPosition, stream);
+			rtti_read(data.widgetNames, stream);
 
 			if(!data.isLeaf)
 			{
 				data.children[0] = bs_new<bs::DockManagerLayout::Entry>();
 				data.children[1] = bs_new<bs::DockManagerLayout::Entry>();
 
-				rttiReadElem(*data.children[0], stream);
-				rttiReadElem(*data.children[1], stream);
+				rtti_read(*data.children[0], stream);
+				rtti_read(*data.children[1], stream);
 				
 				data.children[0]->parent = &data;
 				data.children[1]->parent = &data;
@@ -127,13 +127,13 @@ namespace bs
 
 		static uint32_t getDynamicSize(const bs::DockManagerLayout::Entry& data)	
 		{ 
-			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.isLeaf) + rttiGetElemSize(data.horizontalSplit) + 
-				rttiGetElemSize(data.splitPosition) + rttiGetElemSize(data.widgetNames);
+			uint64_t dataSize = sizeof(uint32_t) + rtti_size(data.isLeaf) + rtti_size(data.horizontalSplit) + 
+				rtti_size(data.splitPosition) + rtti_size(data.widgetNames);
 
 			if(!data.isLeaf)
 			{
-				dataSize += rttiGetElemSize(*data.children[0]);
-				dataSize += rttiGetElemSize(*data.children[1]);
+				dataSize += rtti_size(*data.children[0]);
+				dataSize += rtti_size(*data.children[1]);
 			}
 
 #if BS_DEBUG_MODE

Source/EditorCore/Private/RTTI/BsEditorSettingsRTTI.h

@@ -73,8 +73,8 @@ namespace bs
 			return rtti_write_with_size_header(stream, [&data, &stream]()
 			{
 				uint32_t size = 0;
-				size += rttiWriteElem(data.path, stream);
-				size += rttiWriteElem(data.accessTimestamp, stream);
+				size += rtti_write(data.path, stream);
+				size += rtti_write(data.accessTimestamp, stream);
 
 				return size;
 			});
@@ -83,16 +83,16 @@ namespace bs
 		static uint32_t fromMemory(RecentProject& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
 			uint32_t size = 0;
-			rttiReadElem(size, stream);
-			rttiReadElem(data.path, stream);
-			rttiReadElem(data.accessTimestamp, stream);
+			rtti_read(size, stream);
+			rtti_read(data.path, stream);
+			rtti_read(data.accessTimestamp, stream);
 
 			return size;
 		}
 
 		static uint32_t getDynamicSize(const RecentProject& data)
 		{
-			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.path) + rttiGetElemSize(data.accessTimestamp);
+			uint64_t dataSize = sizeof(uint32_t) + rtti_size(data.path) + rtti_size(data.accessTimestamp);
 
 #if BS_DEBUG_MODE
 			if (dataSize > std::numeric_limits<uint32_t>::max())

Source/EditorCore/Private/RTTI/BsEditorWidgetLayoutRTTI.h

@@ -67,12 +67,12 @@ namespace bs
 			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);
+				size += rtti_write(data.widgetNames, stream);
+				size += rtti_write(data.isDocked, stream);
+				size += rtti_write(data.x, stream);
+				size += rtti_write(data.y, stream);
+				size += rtti_write(data.width, stream);
+				size += rtti_write(data.height, stream);
 
 				return size;
 			});
@@ -81,21 +81,21 @@ namespace bs
 		static uint32_t fromMemory(bs::EditorWidgetLayout::Entry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
 			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);
+			rtti_read(size, stream);
+			rtti_read(data.widgetNames, stream);
+			rtti_read(data.isDocked, stream);
+			rtti_read(data.x, stream);
+			rtti_read(data.y, stream);
+			rtti_read(data.width, stream);
+			rtti_read(data.height, stream);
 
 			return size;
 		}
 
 		static uint32_t getDynamicSize(const bs::EditorWidgetLayout::Entry& data)	
 		{ 
-			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.widgetNames) + rttiGetElemSize(data.isDocked) + 
-				rttiGetElemSize(data.x) + rttiGetElemSize(data.y) + rttiGetElemSize(data.width) + rttiGetElemSize(data.height);
+			uint64_t dataSize = sizeof(uint32_t) + rtti_size(data.widgetNames) + rtti_size(data.isDocked) + 
+				rtti_size(data.x) + rtti_size(data.y) + rtti_size(data.width) + rtti_size(data.height);
 
 #if BS_DEBUG_MODE
 			if(dataSize > std::numeric_limits<uint32_t>::max())

Source/EditorCore/Private/RTTI/BsProjectLibraryEntriesRTTI.h

@@ -65,10 +65,10 @@ namespace bs
 				WString elemName = UTF8::toWide(data.elementName);
 
 				auto type = (uint32_t)data.type;
-				size += rttiWriteElem(type, stream);
-				size += rttiWriteElem(data.path, stream);
-				size += rttiWriteElem(elemName, stream);
-				size += rttiWriteElem(data.lastUpdateTime, stream);
+				size += rtti_write(type, stream);
+				size += rtti_write(data.path, stream);
+				size += rtti_write(elemName, stream);
+				size += rtti_write(data.lastUpdateTime, stream);
 
 				return size;
 
@@ -78,20 +78,20 @@ namespace bs
 		static uint32_t fromMemory(ProjectLibrary::FileEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{ 
 			uint32_t size = 0;
-			rttiReadElem(size, stream);
+			rtti_read(size, stream);
 
 			uint32_t type;
-			rttiReadElem(type, stream);
+			rtti_read(type, stream);
 			data.type = (ProjectLibrary::LibraryEntryType)type;
 
-			rttiReadElem(data.path, stream);
+			rtti_read(data.path, stream);
 
 			WString elemName;
-			rttiReadElem(elemName, stream);
+			rtti_read(elemName, stream);
 			data.elementName = UTF8::fromWide(elemName);
 			data.elementNameHash = bs_hash(UTF8::toLower(data.elementName));
 
-			rttiReadElem(data.lastUpdateTime, stream);
+			rtti_read(data.lastUpdateTime, stream);
 
 			return size;
 		}
@@ -100,8 +100,8 @@ namespace bs
 		{ 
 			WString elemName = UTF8::toWide(data.elementName);
 
-			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
-				rttiGetElemSize(elemName) + rttiGetElemSize(data.lastUpdateTime);
+			uint64_t dataSize = sizeof(uint32_t) + rtti_size(data.type) + rtti_size(data.path) + 
+				rtti_size(elemName) + rtti_size(data.lastUpdateTime);
 
 #if BS_DEBUG_MODE
 			if(dataSize > std::numeric_limits<uint32_t>::max())
@@ -127,24 +127,24 @@ namespace bs
 				// For compatibility, encoding the name as a wide string
 				WString elemName = UTF8::toWide(data.elementName);
 
-				size += rttiWriteElem(data.type, stream);
-				size += rttiWriteElem(data.path, stream);
-				size += rttiWriteElem(elemName, stream);
+				size += rtti_write(data.type, stream);
+				size += rtti_write(data.path, stream);
+				size += rtti_write(elemName, stream);
 
 				uint32_t numChildren = (UINT32)data.mChildren.size();
-				size += rttiWriteElem(numChildren, stream);
+				size += rtti_write(numChildren, stream);
 
 				for(auto& child : data.mChildren)
 				{
 					if(child->type == ProjectLibrary::LibraryEntryType::File)
 					{
 						auto* childResEntry = static_cast<ProjectLibrary::FileEntry*>(child.get());
-						size = rttiWriteElem(*childResEntry, stream);
+						size = rtti_write(*childResEntry, stream);
 					}
 					else if(child->type == ProjectLibrary::LibraryEntryType::Directory)
 					{
 						auto* childDirEntry = static_cast<ProjectLibrary::DirectoryEntry*>(child.get());
-						size += rttiWriteElem(*childDirEntry, stream);
+						size += rtti_write(*childDirEntry, stream);
 					}
 				}
 
@@ -155,18 +155,18 @@ namespace bs
 		static uint32_t fromMemory(ProjectLibrary::DirectoryEntry& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
 			uint32_t size = 0;
-			rttiReadElem(size, stream);
+			rtti_read(size, stream);
 
-			rttiReadElem(data.type, stream);
-			rttiReadElem(data.path, stream);
+			rtti_read(data.type, stream);
+			rtti_read(data.path, stream);
 
 			WString elemName;
-			rttiReadElem(elemName, stream);
+			rtti_read(elemName, stream);
 			data.elementName = UTF8::fromWide(elemName);
 			data.elementNameHash = bs_hash(UTF8::toLower(data.elementName));
 
 			UINT32 numChildren = 0;
-			rttiReadElem(numChildren, stream);
+			rtti_read(numChildren, stream);
 
 			for (UINT32 i = 0; i < numChildren; i++)
 			{
@@ -174,14 +174,14 @@ namespace bs
 
 				uint32_t prevLoc = stream.tell();
 				stream.skipBytes(sizeof(uint32_t)); // Skip ahead to get the type
-				rttiReadElem(childType, stream);
+				rtti_read(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
-					rttiReadElem(*childResEntry, stream);
+					rtti_read(*childResEntry, stream);
 
 					childResEntry->parent = &data;
 					data.mChildren.push_back(childResEntry);
@@ -190,7 +190,7 @@ namespace bs
 				{
 					USPtr<ProjectLibrary::DirectoryEntry> childDirEntry = bs_ushared_ptr_new<ProjectLibrary::DirectoryEntry>();
 					// Note: Assumes that ProjectLibrary takes care of the cleanup
-					rttiReadElem(*childDirEntry, stream);
+					rtti_read(*childDirEntry, stream);
 
 					childDirEntry->parent = &data;
 					data.mChildren.push_back(childDirEntry);
@@ -203,8 +203,8 @@ namespace bs
 		static uint32_t getDynamicSize(const ProjectLibrary::DirectoryEntry& data)
 		{ 
 			WString elemName = UTF8::toWide(data.elementName);
-			uint64_t dataSize = sizeof(uint32_t) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + 
-				rttiGetElemSize(elemName);
+			uint64_t dataSize = sizeof(uint32_t) + rtti_size(data.type) + rtti_size(data.path) + 
+				rtti_size(elemName);
 
 			dataSize += sizeof(uint32_t);
 
@@ -213,12 +213,12 @@ namespace bs
 				if(child->type == ProjectLibrary::LibraryEntryType::File)
 				{
 					ProjectLibrary::FileEntry* childResEntry = static_cast<ProjectLibrary::FileEntry*>(child.get());
-					dataSize += rttiGetElemSize(*childResEntry);
+					dataSize += rtti_size(*childResEntry);
 				}
 				else if(child->type == ProjectLibrary::LibraryEntryType::Directory)
 				{
 					ProjectLibrary::DirectoryEntry* childDirEntry = static_cast<ProjectLibrary::DirectoryEntry*>(child.get());
-					dataSize += rttiGetElemSize(*childDirEntry);
+					dataSize += rtti_size(*childDirEntry);
 				}
 			}
 

Source/EditorCore/Private/RTTI/BsSettingsRTTI.h

@@ -36,8 +36,8 @@ namespace bs
 			return rtti_write_with_size_header(stream, [&data, &stream]()
 			{
 				uint32_t size = 0;
-				size += rttiWriteElem(data.key, stream);
-				size += rttiWriteElem(data.value, stream);
+				size += rtti_write(data.key, stream);
+				size += rtti_write(data.value, stream);
 
 				return size;
 			});
@@ -47,9 +47,9 @@ namespace bs
 		static uint32_t fromMemory(TSettingsValue<T>& data, Bitstream& stream, const RTTIFieldInfo& info)
 		{
 			uint32_t size = 0;
-			rttiReadElem(size, stream);
-			rttiReadElem(data.key, stream);
-			rttiReadElem(data.value, stream);
+			rtti_read(size, stream);
+			rtti_read(data.key, stream);
+			rtti_read(data.value, stream);
 
 			return size;
 		}
@@ -58,8 +58,8 @@ namespace bs
 		static uint32_t getDynamicSize(const TSettingsValue<T>& data)
 		{
 			uint64_t dataSize = sizeof(uint32_t);
-			dataSize += rttiGetElemSize(data.key);
-			dataSize += rttiGetElemSize(data.value);
+			dataSize += rtti_size(data.key);
+			dataSize += rtti_size(data.value);
 
 			assert(dataSize <= std::numeric_limits<uint32_t>::max());