Import / Export Meshes

Editor/src/AssetManagement/AssetManager.h

@@ -0,0 +1,118 @@
+#pragma once
+#include <filesystem>
+#include <fstream>
+
+#include "../../../YoggieEngine/src/Graphics/Renderable.h"
+#include "../../../YoggieEngine/src/AssetManager/ModelImporter.h"
+#include <spdlog/spdlog.h>
+#include <iostream>
+
+class AssetManager {
+public:
+
+	static YoggieEngine::Mesh* LoadFromAssetFile(const std::filesystem::path assetPath )
+	{
+		YoggieEngine::Mesh imported;
+
+		std::ifstream AssetFile;
+		AssetFile.open(assetPath, std::ios::binary);
+		if (AssetFile.is_open()) {
+
+			char* Header = (char*) malloc(8);
+			unsigned long long  Vsize = 0;
+			uint32_t Vnum = 0;
+			uint32_t Enum = 0;
+
+			// Read header 
+			AssetFile.read(Header, 8);
+			AssetFile.read((char*)&Vsize, sizeof(unsigned long long ));
+			AssetFile.read((char*)&Vnum, sizeof(uint32_t));
+			AssetFile.read((char*)&Enum, sizeof(uint32_t));
+
+			// print Header info 
+			std::cout << "File has header: " << Header << std::endl;
+			std::cout << "Vertex size: " << Vsize << std::endl;
+			std::cout << "Number of Vertices: " << Vnum << std::endl;
+			std::cout << "Number of Elements: " << Enum << std::endl;
+			free(Header);
+
+			// Load Vertices (Vertex + UV )
+			imported.vertices = std::vector < YoggieEngine::Vertex>();
+			for (int i = 0; i < Vnum; i++) 
+			{
+				YoggieEngine::Vertex data = YoggieEngine::Vertex();
+				AssetFile.read((char*) & data, Vsize);
+
+				imported.vertices.push_back(data);
+			
+			}
+
+			// skip x bytes 
+			AssetFile.ignore(sizeof(char) * 3);
+
+			// Load Elements
+			imported.elements = std::vector<unsigned int>();
+			for (int i = 0; i < Enum; i++) {
+				unsigned int data = 0;
+				AssetFile.read((char*)&data, sizeof(unsigned int));
+				imported.elements.push_back(data);
+			}
+
+		}
+		else {
+			std::cout << "Failed ot open mesh " << std::endl;
+		}
+
+
+		return nullptr;
+
+
+	}
+
+	static YoggieEngine::Renderable* LoadFromSource(const std::filesystem::path srcPath , const std::filesystem::path assetFolder ) {
+		auto model = (YoggieEngine::ModelImporter()).Import(srcPath.string());
+		YoggieEngine::Mesh* exportMesh = model->renderable->mesh;
+		std::filesystem::path MeshFileName = assetFolder / srcPath.filename().replace_extension( ".mesh");
+		std::cout << "Save path: " << MeshFileName << std::endl;
+
+		std::ofstream meshAsset;
+		meshAsset.open(MeshFileName, std::ios::binary );
+		if (meshAsset.is_open()) {
+
+			// write a header
+			static const char* HEADER = "MESH";
+			meshAsset.write(HEADER, sizeof(HEADER));
+			auto Vsize = sizeof(YoggieEngine::Vertex);
+			std::cout << "size of vertex: " << Vsize << std::endl;
+			std::cout << "Addr of vSize: " << &Vsize << std::endl;
+			auto Vnum = exportMesh->vertices.size();
+			auto Enum = exportMesh->elements.size();
+
+			meshAsset.write((char*) & Vsize, sizeof(unsigned long long ) );
+			meshAsset.write((char*)&Vnum, sizeof(uint32_t));
+			meshAsset.write((char*)&Enum, sizeof(uint32_t));
+			// write all vertices 
+			for (auto vertice : exportMesh->vertices)
+			{
+				meshAsset.write((char*)&vertice, sizeof(vertice));
+			}
+
+			// write 3 x 0 byte
+			meshAsset.write((const char*)"\0\0\0", sizeof(char) * 3);
+
+			// write all indices 
+			for (auto index : exportMesh->elements) {
+				meshAsset.write((char*)&index, sizeof(index));
+			}
+
+
+			meshAsset.close();
+		}
+		else {
+			spdlog::error("Failed to create/open mesh file.");
+		}
+
+		return model->renderable;
+
+	}
+};