YoggieEngine/Editor/src/AssetManagement/AssetManager.h

#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;

	}
};