working at loading and saving data

Pika/core/sharedRuntime/baseContainer.h

@@ -180,7 +180,7 @@ struct RequestedContainerInfo
 
 		if (!getFileSizeBinary(name, s)) { return 0; }
 
-		data.reserve(s);
+		data.resize(s);
 
 		return readEntireFileBinary(name, data.data(), s);
 	}

Pika/core/sharedRuntime/pushNotification/pushNotification.cpp

@@ -120,7 +120,7 @@ void pika::PushNotificationManager::update(bool &open)
 
 
 }
-
+//todo reimplement with a custom deque so we don't allocate memory
 void pika::PushNotificationManager::pushNotification(const char *content, int logType)
 {
 	notificationQue.push_back

Pika/pluggins/pluggins/sushiViewer/sushiViewer.cpp

@@ -283,6 +283,42 @@ bool SushiViewer::update(pika::Input input, pika::WindowState windowState, Reque
 
 	ImGui::Begin("Sushi editor");
 	{
+
+		if (img.fileSelector.run(9000325))
+		{
+
+		};
+
+		if (ImGui::Button("Load"))
+		{
+			sushi::SushyBinaryFormat data;
+
+			if (requestedInfo.readEntireFileBinary(img.fileSelector.file, data.data))
+			{
+				if (!sushiContext.load(data))
+				{
+					requestedInfo.consoleWrite("Couldn't parse file");
+				}
+			}
+			else
+			{
+				requestedInfo.consoleWrite("Couldn't open file");
+			}
+		}
+
+		else if (ImGui::Button("Save"))
+		{
+
+			if (img.fileSelector.file[0] != 0)
+			{
+				auto rez = sushiContext.save();
+
+				requestedInfo.writeEntireFileBinary(img.fileSelector.file, rez.data.data(),
+					rez.data.size() * sizeof(rez.data[0]));
+			}
+
+		}
+
 		ImGui::Text("Current selected id: %u", img.elementId);
 
 		auto &c = sushiContext;

Pika/pluggins/pluggins/sushiViewer/sushiViewer.h

@@ -7,7 +7,7 @@
 #include <pikaSizes.h>
 #include <imgui_spinner.h>
 #include <sushi/sushi.h>
-
+#include <pikaImgui/pikaImgui.h>
 
 struct SushiViewer: public Container
 {
@@ -30,10 +30,10 @@ struct SushiViewer: public Container
 	{
 		unsigned int elementId = 0;
 
-
 		bool dragging = 0;
 		glm::vec2 dragBegin = {};
 		glm::vec2 originalPos = {};
+		pika::pikaImgui::FileSelector fileSelector{"Selected File", PIKA_RESOURCES_PATH, {".sushi"}};
 		
 	}img;
 

Pika/resources/logs.txt

@@ -1 +1 @@
-#2023-09-07 11:27:13: Created container: SushiViewer
+#2023-09-07 15:05:17: Created container: SushiViewer

Pika/thirdparty/sushi/CMakeLists.txt

@@ -5,6 +5,8 @@ add_library(sushi)
 
 file(GLOB_RECURSE SUSHI_SRCS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
 
+set_property(TARGET sushi PROPERTY CXX_STANDARD 17)
+
 target_sources(sushi PRIVATE "${SUSHI_SRCS}")
 target_include_directories(sushi PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
 target_link_libraries(sushi PUBLIC glm glad stb_image stb_truetype gl2d)

Pika/thirdparty/sushi/include/sushi/sushi.h

@@ -145,13 +145,17 @@ namespace sushi
 
 	struct SushyBinaryFormat
 	{
-		std::vector<unsigned char> data;
+		std::vector<char> data;
 
 		void addUiElementInternal(sushi::SushiUiElement &el);
 
 		void addPieceInternal(sushi::Transform &transform);
 
 		void addPieceInternal(sushi::Background &background);
+		
+		void addParentPieceInternal(sushi::SushiParent &el);
+
+		void addMainParentInternal(sushi::SushiParent &el);
 
 		void addParentInternal(sushi::SushiParent &el);
 
@@ -164,6 +168,8 @@ namespace sushi
 		bool save(SushiElement element);
 
 		void traverseAddInternal(SushiParent &parent);
+
+		void traverseAddInternalMainParent(SushiParent &parent);
 	};
 
 	//this is a sushi context. Holds all the windows and manages stuff
@@ -199,8 +205,10 @@ namespace sushi
 
 		void signalElementToCacheToRemoveInternal(SushiElement el);
 
+		//can't search for root
 		SushiElement genUniqueElement(std::string name);
 
+		//can't search for root
 		std::pair<std::unordered_multimap<std::string, SushiElement>::iterator,
 			std::unordered_multimap<std::string, SushiElement>::iterator> getElements(std::string name);
 
@@ -210,6 +218,7 @@ namespace sushi
 
 		bool load(SushyBinaryFormat &data);
 
+		
 	};
 
 

Pika/thirdparty/sushi/src/sushi.cpp

@@ -1,5 +1,7 @@
 #include <sushi/sushi.h>
 #include <cstring>
+#include <optional>
+#include <unordered_set>
 
 namespace sushi
 {
@@ -10,7 +12,8 @@ namespace sushi
 	{
 		markerUiElement = 1,
 		markerParent,
-		markerChildrenIdList
+		markerChildrenIdList,
+		markerMainParent,
 	};
 
 	void SushyBinaryFormat::addPieceInternal(sushi::Transform &transform)
@@ -36,9 +39,8 @@ namespace sushi
 		addBinaryDataInternal(arr.data(), s * sizeof(unsigned int));
 	}
 
-	void SushyBinaryFormat::addParentInternal(sushi::SushiParent &el)
+	void SushyBinaryFormat::addParentPieceInternal(sushi::SushiParent &el)
 	{
-		addMarkerInternal(markerParent);
 		addPieceInternal(el.transform);
 		addPieceInternal(el.background);
 		addBinaryDataInternal(el.name, sizeof(el.name));
@@ -49,6 +51,18 @@ namespace sushi
 		addUIntArrayPieceInternal(el.orderedElementsIds);
 	}
 
+	void SushyBinaryFormat::addMainParentInternal(sushi::SushiParent &el)
+	{
+		addMarkerInternal(markerMainParent);
+		addParentPieceInternal(el);
+	}
+
+	void SushyBinaryFormat::addParentInternal(sushi::SushiParent &el)
+	{
+		addMarkerInternal(markerParent);
+		addParentPieceInternal(el);
+	}
+
 	void SushyBinaryFormat::addMarkerInternal(int marker)
 	{
 		addBinaryDataInternal(&marker, sizeof(marker));
@@ -81,6 +95,24 @@ namespace sushi
 		}
 	}
 
+	void SushyBinaryFormat::traverseAddInternalMainParent(SushiParent &parent)
+	{
+		addMainParentInternal(parent);
+
+		auto &ui = parent.allUiElements;
+		for (auto &e : ui)
+		{
+			addUiElementInternal(e);
+		}
+
+		auto &parents = parent.parents;
+		for (auto &e : parents)
+		{
+			traverseAddInternal(e);
+		}
+	}
+
+
 	bool SushyBinaryFormat::save(SushiElement element)
 	{
 		data.clear();
@@ -423,15 +455,21 @@ namespace sushi
 		SushyBinaryFormat rez;
 
 		//todo print errors or something?
-		rez.save(&root);
-
+		rez.traverseAddInternalMainParent(root);
 		return rez;
 	}
 
-	bool SushyContext::load(SushyBinaryFormat &data)
+	struct LoadeData
 	{
-		*this = {};
+		std::vector<SushiUiElement> elements;
+		std::vector<SushiParent> parents;
+		std::optional<SushiParent> mainParent = std::nullopt;
+	};
 
+	bool loadAllData(SushyBinaryFormat &data, LoadeData &rezult)
+	{
+		rezult = {};
+			
 		size_t cursorPos = 0;
 
 		auto readBinaryData = [&](void *buffer, size_t size) -> bool
@@ -459,26 +497,217 @@ namespace sushi
 			return readBinaryData(buff, sizeof(SushiUiElement));
 		};
 
-		int firstM = getNextMarker();
+		auto getNextTransformPiece = [&](Transform *buff) -> bool
+		{
+			return readBinaryData(buff, sizeof(Transform));
+		};
 
-		if (firstM == markerUiElement)
+		auto getNextBackgroundPiece = [&](Background *buff) -> bool
 		{
-			this->createBasicSchene();
+			return readBinaryData(buff, sizeof(Background));
+		};
 
-			SushiUiElement el;
+		auto getNextUnsignedIntVector = [&](std::vector<unsigned int> &vec) -> bool
+		{
+			vec.clear();
+			size_t elements = 0;
+			if (!readBinaryData(&elements, sizeof(elements))) { return 0; }
 
-			if (!getNextUiElementPiece(&el)) { return 0; }
+			if (elements > 10'000'000) { return 0; } //probably corupted data
 
-			this->addElement(root, el.name, el.transform, el.background);
-		}
-		else if (firstM == markerParent)
+			vec.resize(elements);
+
+			if (!readBinaryData(vec.data(), elements * sizeof(unsigned int))) { vec.clear(); return 0; }
+			
+			return 1;
+		};
+
+		auto getNextParentPiece = [&](SushiParent &parent) -> bool
 		{
+			if (!getNextTransformPiece(&parent.transform)) { return 0; }
+			if (!getNextBackgroundPiece(&parent.background)) { return 0; }
 
+			if (!readBinaryData(parent.name, sizeof(parent.name))) { return 0; }
+			if (!readBinaryData(&parent.id, sizeof(parent.id))) { return 0; }
+			if (!readBinaryData(&parent.layoutType, sizeof(parent.layoutType))) { return 0; }
+
+			if (getNextMarker() != markerChildrenIdList) { return 0; }
+			if (!getNextUnsignedIntVector(parent.orderedElementsIds)) { return 0; }
+
+			return true;
+		};
+
+		while (cursorPos < data.data.size())
+		{
+			int firstM = getNextMarker();
+
+			if (firstM == markerUiElement)
+			{
+				SushiUiElement el;
+				if (!getNextUiElementPiece(&el)) { return 0; }
+				rezult.elements.push_back(el);
+			}
+			else if (firstM == markerParent)
+			{
+				SushiParent el;
+				if (!getNextParentPiece(el)) { return 0; }
+				rezult.parents.push_back(el);
+			}
+			else if (firstM == markerMainParent)
+			{
+				if (rezult.mainParent.has_value()) { return 0; }
+
+				SushiParent el;
+				if (!getNextParentPiece(el)) { return 0; }
+				rezult.mainParent = el;
+			}
+			else
+			{
+				return 0;
+			}
 		}
-		else
+		return 1;
+	}
+
+	bool SushyContext::load(SushyBinaryFormat &data)
+	{
+		*this = {};
+
+		LoadeData loaded;
+
+		if (!loadAllData(data, loaded)) { return 0; }
+
+		if (loaded.mainParent)
 		{
-			return 0;
+			unsigned int oldId = root.id;
+			root = *loaded.mainParent;
+			root.id = oldId;
 		}
+
+		SushiParent *parentToAddTo = &root;
+		
+		//todo if no loaded.mainParent we will make the first found parent root
+
+		{
+			//no parents, we can just add the elements here
+			if (loaded.parents.empty())
+			{
+				for (auto &e : loaded.elements)
+				{
+					addElement(*parentToAddTo, e.name, e.transform, e.background);
+				}
+			}
+			else
+			{
+			#pragma region find first parent
+				SushiParent *firstParent = 0;
+				if (loaded.mainParent)
+				{
+					firstParent = &(*loaded.mainParent);
+				}
+				else
+				{
+					//determine the main parent
+					std::unordered_set<unsigned int> allparentsids;
+					for (auto &p : loaded.parents)
+					{
+						if (allparentsids.find(p.id) != allparentsids.end())
+						{
+							return 0;
+						}
+						allparentsids.insert(p.id);
+					}
+
+					for (auto &p : loaded.parents)
+					{
+						for (auto &id : p.orderedElementsIds)
+						{
+							auto f = allparentsids.find(id);
+							if (f != allparentsids.end())
+							{
+								allparentsids.erase(f);
+							}
+						}
+					}
+
+					//we found the main parent id
+					if (allparentsids.size() == 1)
+					{
+						unsigned int id = *allparentsids.begin();
+
+						for (auto &p : loaded.parents)
+						{
+							if (p.id == id)
+							{
+								firstParent = &p;
+							}
+						}
+					}
+					else
+					{
+						return 0;
+					}
+
+				}
+			#pragma endregion
+
+				if (!firstParent) { return 0; }
+
+				struct ParentPair
+				{
+					SushiParent *element = 0;
+					SushiParent *parentToAddTo = 0;
+				};
+
+				std::vector<ParentPair> parentsToAdd;
+				parentsToAdd.push_back({firstParent, parentToAddTo});
+
+				while (parentsToAdd.size())
+				{
+					auto currentP = *parentsToAdd.begin();
+					parentsToAdd.erase(parentsToAdd.begin());
+
+					addParent(*currentP.parentToAddTo, currentP.element->name, currentP.element->transform,
+						currentP.element->background);
+
+					bool found = 0;
+					for (auto &id : currentP.element->orderedElementsIds)
+					{
+						for (auto &e : loaded.elements)
+						{
+							if (e.id == id)
+							{
+								addElement(*currentP.element, e.name, e.transform, e.background);
+								found = true;
+								break;
+							}
+						}
+
+						if (!found)
+						{
+							for (auto &e : loaded.parents)
+							{
+								if (e.id == id)
+								{
+									parentsToAdd.push_back({&e,currentP.element});
+									found = true;
+									break;
+								}
+							}
+						}
+						if (found) { break; }
+					}
+
+					if (!found) { return 0; }
+
+				}
+
+			}
+
+		};
+		
+		
+		return 1;
 	}
 
 #pragma endregion