Big clean up, getting ready for new AssetManagement

* Removing Old EventSystem
* Removing Assets from Editor project
* Clean up of EditorLayer.h
* Moving primitives of renderer out of their subfolder

.gitattributes

@@ -1,3 +1,4 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 *.xcf filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

Editor/premake5.lua

@@ -6,7 +6,6 @@ buildmessage "Building editor ..."
 links{
   "YoggieEngine",
   "ImGuizmo",
-  "yaml-cpp",
   "nfd"
 }
 

Editor/src/AssetManagement/Asset.h

@@ -1,56 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include <filesystem>
-#include <string>
-#include "uuid.h"
-
-enum class ASSET_TYPE {
-	Unknown = -1,
-	Mesh,
-	Texture,
-	Material,
-	Shader,
-	Model,
-	File
-};
-
-class Asset {
-public:
-	Asset(const char* name):  name(name) {}
-
-	virtual ASSET_TYPE GetType() { return detectAssetType(); }
-	
-	const char* GetName() const { return name.c_str(); }
-	void setName(std::string& name) { name = name.c_str(); }
-	void setFilPath(std::string& path) { file = std::filesystem::path(path); }
-
-	std::string getId() { return Id.String(); }
-
-	
-protected:
-	uuid::v4::UUID Id = uuid::v4::UUID::New();
-
-	std::string name;
-	std::filesystem::path file;
-	
-
-
-	ASSET_TYPE detectAssetType() {
-		auto ext = (file.extension()).string();
-		if (ext == ".obj" || ext == ".gltf" || ext == ".fbx" || ext == ".stl") {
-			return ASSET_TYPE::Model;
-		}
-		else if (ext == ".yproj") {
-			return ASSET_TYPE::File;
-		}
-		else if (ext == ".vs" || ext == ".fs") {
-			return ASSET_TYPE::File;
-		}
-		else {
-			spdlog::warn("unknown file!");
-			return ASSET_TYPE::Unknown;
-		}
-	}
-
-
-};

Editor/src/AssetManagement/AssetFinder.h

@@ -1,105 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-#include "AssetRegistry.h"
-
-const char* hidden_extensions [] {
-    ".exe",
-    ".pdb",
-    ".idb",
-    ".dll",
-    ".ini"
-};
-
-class AssetFinder : public EditorWindow {
-public:
-    AssetFinder () : EditorWindow("Assets") {}
-    AssetFinder(const std::filesystem::path& projectdirectory) : EditorWindow("Assets")
-    {
-        assetIcon = YoggieEngine::Texture("rsc/AssetIcon.png");
-
-        spdlog::info("asset iconID: {0}", assetIcon.GetID());
-
-        for (auto& dir_entry : std::filesystem::directory_iterator(projectdirectory)) {
-            auto filepath = dir_entry.path();
-
-            if (dir_entry.is_directory() || dir_entry.is_symlink() || dir_entry.is_socket())
-                continue;
-
-            bool has_hidden_extension = false;
-            for (auto hide : hidden_extensions) {
-                if (filepath.extension() == hide)
-                {
-                    has_hidden_extension = true;
-                    break;
-                }
-            }
-
-            if (has_hidden_extension)
-                continue;
-
-            Asset asset(filepath.filename().string().c_str());
-
-            auto filepathStr = filepath.string();
-            asset.setFilPath(filepathStr);
-            spdlog::info("Created asset: {0}", asset.GetName());
-            files.push_back(asset);
-
-        
-        }
-
-    }
-
-    void Draw() override {
-
-        ImGui::DragInt("IconSize", &iconSize, 1, 30, 90);
-        ImGui::DragInt("Maximum Columns", &maxColumns, 1, 1, 6);
-        if (ImGui::BeginTable("##resources", 3))
-        {
-            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.f, 0.f, 0.f, 0.f));
-            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.f, 1.f, 1.f, 0.2f));
-
-
-            
-            int row = 0;
-            int column = 0;
-            for (auto& asset : files ) {
-                if (column % 3 == 0) {
-                    ImGui::TableNextRow();
-                    column = 0;
-                    row++;
-                }
-
-                ImGui::TableSetColumnIndex(column);
-
-                ImGui::ImageButton(
-                    (ImTextureID)assetIcon.GetID(),
-                    ImVec2{ (float)iconSize, (float)iconSize });
-                ImGui::Text(asset.GetName(), row);
-
-
-
-                column++;
-            }
-            
-
-            
-            ImGui::PopStyleColor(3);
-            ImGui::EndTable();
-            
-
-        }
-    }
-
-private:
-    std::vector <Asset> files = std::vector<Asset>();
-
-    int iconSize = 60;
-    int maxColumns = 3;
-
-    YoggieEngine::Texture folderIcon;
-    YoggieEngine::Texture assetIcon;
-
-};
-

Editor/src/AssetManagement/AssetLoaders/AssetLoader.h

@@ -1,9 +0,0 @@
-#pragma once
-#include <filesystem>
-#include "../Asset.h"
-class AssetLoader {
-public:
-	virtual Asset LoadAsset(std::filesystem::path& path) = 0;
-	// virtual void PackageAsset(Asset& asset ) = 0; 
-
-};

Editor/src/AssetManagement/AssetLoaders/ModelLoader.cpp

@@ -1,109 +0,0 @@
-#include "ModelLoader.h"
-#include <assimp/Importer.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-
-
-
-void ProcessVertices(aiMesh* mesh, std::vector<YoggieEngine::Vertex>& out_vertices) {
-	for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
-		YoggieEngine::Vertex v{};
-
-		glm::vec3 vector;
-		vector.x = mesh->mVertices[i].x;
-		vector.y = mesh->mVertices[i].y;
-		vector.z = mesh->mVertices[i].z;
-
-		v.vertices = vector;
-
-		if (mesh->mTextureCoords[0]) {
-			glm::vec2 texCoord;
-
-			texCoord.x = mesh->mTextureCoords[0][i].x;
-			texCoord.y = mesh->mTextureCoords[0][i].y;
-
-			v.uv = texCoord;
-
-		}
-
-		out_vertices.push_back(v);
-	}
-}
-
-
-void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices) {
-	for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
-		aiFace face = mesh->mFaces[i];
-		if (face.mNumIndices < 3)
-			continue;
-		for (unsigned int j = 0; j < face.mNumIndices; j++) {
-			out_indices.push_back(face.mIndices[j]);
-		}
-	}
-}
-
-
-
-YoggieEngine::Mesh processMesh(aiMesh* mesh, const aiScene* scene) {
-	std::vector<unsigned int> indices;
-	std::vector<YoggieEngine::Vertex> vertices;
-
-	ProcessVertices(mesh, vertices);
-	ProcessIndices(mesh, indices);
-
-	YoggieEngine::Mesh result;
-	result.vertices = vertices;
-	result.elements = indices;
-
-	return result;
-
-}
-
-std::vector<YoggieEngine::Mesh> processNode(aiNode* node, const aiScene* scene) {
-
-	std::vector<YoggieEngine::Mesh> meshes = std::vector<YoggieEngine::Mesh>();
-
-	for (unsigned int i = 0; i < node->mNumMeshes; i++) {
-		aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
-		meshes.push_back(processMesh(mesh, scene));
-	}
-
-
-
-	for (unsigned int i = 0; i < node->mNumChildren; i++) {
-		auto m2 = processNode(node->mChildren[i], scene);
-
-		for (auto m : m2) {
-			meshes.push_back(m);
-		}
-	}
-
-	return meshes;
-
-
-}
-
-Asset ModelLoader::LoadAsset(std::filesystem::path& path) {
-
-
-
-	Assimp::Importer importer;
-
-	const aiScene* scene = importer.ReadFile(path.string(), aiProcess_Triangulate | aiProcess_FlipUVs);
-
-	aiNode* currentNode = scene->mRootNode;
-
-	
-	spdlog::info("Loading meshes!" );
-
-	auto meshes = processNode(currentNode, scene);
-
-	spdlog::info("Model file contained {0} meshes", meshes.size() );
-
-
-
-	return Asset("Mesh");
-
-
-
-}

Editor/src/AssetManagement/AssetLoaders/ModelLoader.h

@@ -1,8 +0,0 @@
-#pragma once
-#include "AssetLoader.h"
-
-class  ModelLoader : AssetLoader {
-public:
-	Asset LoadAsset(std::filesystem::path& path);
-
-};

Editor/src/AssetManagement/AssetRegistry.cpp

@@ -1,140 +0,0 @@
-#include "AssetRegistry.h"
-
-#include <iostream>
-#include <fstream>
-#include <spdlog/spdlog.h>
-/*
-* this is still a very naive approach to the asset manager
-*/
-
-AssetRegistry::AssetRegistry() 
-{
-}
-
-
-void AssetRegistry::RegisterAsset(Asset& asset) 
-{
-	Assets.try_emplace(asset.getId() , asset);
-}
-
-
-void AssetRegistry::UnregisterAsset(Asset& asset) {
-	Assets.erase(asset.getId());
-}
-
-
-
-
-YoggieEngine::Mesh* AssetRegistry::LoadFromAssetFile(const std::filesystem::path assetPath)
-{
-	YoggieEngine::Mesh* imported = nullptr;
-
-	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 
-		spdlog::info("File has header: {0}", Header);
-		spdlog::info ( "Vertex size: {0}", Vsize );
-		spdlog::info("Number of Vertices: {0}" ,Vnum );
-		spdlog::info ("Number of Elements: " , Enum );
-		free(Header);
-
-
-		imported = new YoggieEngine::Mesh();
-		// 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 {
-		spdlog::error( "Failed ot open mesh " );
-	}
-
-	return imported;
-
-
-}
-/*
-
-
-YoggieEngine::Renderable* AssetRegistry::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");
-	spdlog::info( "Save path: {0}" , MeshFileName );
-
-	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);
-		spdlog::info( "size of vertex: {0}" ,Vsize );
-		spdlog::info("Addr of vSize: {0}" , &Vsize );
-		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;
-
-	return nullptr;
-}
-	*/

Editor/src/AssetManagement/AssetRegistry.h

@@ -1,26 +0,0 @@
-#pragma once
-#include <vector>
-#include "Asset.h"
-#include "uuid.h"
-
-class AssetRegistry {
-public:
-
-	AssetRegistry();
-	//AssetRegistry(AssetPack);
-
-	void RegisterAsset(Asset& asset);
-	void UnregisterAsset(Asset& asset);
-
-
-
-	void Update();
-
-
-	static YoggieEngine::Mesh* LoadFromAssetFile(const std::filesystem::path assetPath);
-//	static YoggieEngine::Renderable* LoadFromSource(const std::filesystem::path srcPath, const std::filesystem::path assetFolder);
-	
-private: 
-	int unique_number = 0;
-	std::map<std::string , Asset> Assets = std::map<std::string, Asset> ();
-};

Editor/src/EditorLayer.h

@@ -1,31 +1,16 @@
 #pragma once
 #include <iostream>
 #include <mini/ini.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#include <glm/gtc/matrix_transform.hpp>
 #include <nfd.h>
-
-#include "AssetManagement/SceneSerializer.h"
-#include "AssetManagement/AssetFinder.h"
-#include "PropertyPanels/Inspector.h"
-#include "AssetManagement/uuid.h"
-#include "Project/Settings.h"
-#include "Console.h"
-#include "AssetManagement/AssetLoaders/ModelLoader.h"
-#include "IconsMaterialDesign.h"
-#include "Project/Project.h"
 #include <ImGuizmo.h>
-#include "EditorCamera.h"
-#include "../../YoggieEngine/src/Graphics/Memory/VertexArray.h"
-#include "../../YoggieEngine/src/Graphics/Memory/Buffer.h"
 
+#include "Inspector.h"
+#include "Console.h"
+#include "IconsMaterialDesign.h"
+#include "Project.h"
+#include "EditorCamera.h"
 using namespace YoggieEngine;
 
-const float movement_speed = 0.1f;
-static float lastX = 400, lastY = 300;
-const float sensitivity = 0.1;
-static bool firstMouse = true;
 
 class EditorLayer : public Layer {
 
@@ -33,129 +18,31 @@ class EditorLayer : public Layer {
 public:
     EditorLayer() : 
         Layer(),
-        Logo("rsc/Yoggie.png"),
         inspector(Selected),
         scene(),
         renderer()
     {
 
-        spdlog::info("Colour attachment id: {0}", renderer.getCurrentFrameBuffer().GetColourAttachment());
+        Logo.Load("rsc/Yoggie.png");
-
-        Selected = YoggieEngine::Entity((entt::entity)-1, &scene);
-
-        AssetRegistry assetManager = AssetRegistry();
-       // ModelLoader modelLoader = ModelLoader();
-
         spdlog::info("{0}", project.GetProjectDirectory().string());
-
+        Selected = YoggieEngine::Entity((entt::entity)-1, &scene);
-        //auto latern = modelLoader.LoadAsset(std::filesystem::path("build/debug/Models/Latern.gltf"));
-        //spdlog::info("Loaded mesh: {0}", latern.GetName());
         
     }
 
 	void OnStartup() override {
         std::string path = (std::filesystem::current_path()).string();
         project.setProjectDirectory(path);
-        assetsView = AssetFinder(project.GetProjectDirectory());
         LoadLastOrEmptyProject();
-
-
-        auto cubePath = std::filesystem::path("build/debug/Models/cube.obj");
-
-        cube = (ModelLoader()).LoadAsset(cubePath);
-        //Settings settings = Settings();
         //Console console = Console();
        
 	}
 
 	void OnUpdate() override {
         scene.Update();
-
-        auto components = scene.getReg().view<Render3DComponent>();
-        for(auto component : components){
-            auto& renderComponent = YoggieEngine::Entity(component, &scene).GetComponent<Render3DComponent>();
-
-            renderComponent.mesh = cube;
-
-            if (renderComponent.VAO == 0 || renderComponent.IBO == 0) {
-                VertexArray va = VertexArray();
-                Buffer vertexBuffer = Buffer();
-                Buffer elementBuffer = Buffer();
-
-                va.Create();
-                va.Bind();
-
-                vertexBuffer.createBuffer();
-                vertexBuffer.Bind(false);
-                vertexBuffer.setBufferData((void*)&renderComponent.mesh.vertices[0], renderComponent.mesh.vertices.size() * sizeof(Vertex), false);
-
-                elementBuffer.createBuffer();
-                elementBuffer.Bind(true);
-                elementBuffer.setBufferData((void*)&renderComponent.mesh.elements[0], renderComponent.mesh.elements.size() * sizeof(unsigned int), true);
-
-                va.AttachAttribute(0, 3, sizeof(Vertex));
-
-                glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
-                glEnableVertexAttribArray(0);
-                glEnableVertexAttribArray(1);
-
-                va.Unbind();
-                vertexBuffer.Unbind(false);
-                elementBuffer.Unbind(true);
-
-                renderComponent.VAO = va.getID();
-                renderComponent.IBO = elementBuffer.getBufferID();
-
-            }
-
-
-
-
-        }
-
-
-      
         renderer.Render(scene, *camera);
-
-
 	}
 
-    bool OnKey(int key, int mode) override {
 
-        if (SceneisFocused) {
-            if (key == YOGGIE_KEY_UP)
-                camera->Rotation.x += movement_speed;
-
-            if (key == YOGGIE_KEY_DOWN)
-                camera->Rotation.x -= movement_speed;
-
-            if (key == YOGGIE_KEY_LEFT)
-                camera->Rotation.y += movement_speed;
-
-            if (key == YOGGIE_KEY_RIGHT)
-                camera->Rotation.y -= movement_speed;
-
-
-
-            if (key == YOGGIE_KEY_A)
-                camera->Position += glm::vec3(1.0f, 0.0f, 0.0f) * movement_speed;
-
-            if (key == YOGGIE_KEY_S)
-                camera->Position += glm::vec3(0.0f, 0.0f, -1.0f) * movement_speed;
-
-            if (key == YOGGIE_KEY_D)
-                camera->Position -= glm::vec3(1.0f, 0.0f, 0.0f) * movement_speed;
-
-            if (key == GLFW_KEY_W)
-                camera->Position -= glm::vec3(0.0f, 0.0f, -1.0f) * movement_speed;
-
-        }
-
-
-        return true;
-    }
-
-    ImGuizmo::OPERATION activeOperation = ImGuizmo::OPERATION::TRANSLATE;
 
     void OnUI() override {
         ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { ImGui::GetWindowWidth(), 7 });
@@ -272,15 +159,6 @@ public:
                 switch (result) {
                 case(NFD_OKAY):
                 {
-                    YoggieEngine::Mesh* importedMesh = AssetRegistry::LoadFromAssetFile(path);
-                    if (importedMesh != nullptr)
-                    {
-                        auto full_name = std::filesystem::path(path);
-                        //  auto importedModel = scene.AddEntity(full_name.filename().u8string());
-                        //  auto& rendererComponent = importedModel.AddComponent<YoggieEngine::Render3DComponent>();
-                        //  rendererComponent.mesh = *importedMesh;
-
-                    }
                 }
                 break;
 
@@ -307,13 +185,6 @@ public:
 
         ImGui::SameLine(ImGui::GetWindowWidth() - 120);
        
-        /*
-        ImGui::PopStyleColor();
-        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.1f, 0.1f, 0.1f, 0.01f));
-        if (ImGui::Button(ICON_MD_MINIMIZE)) { spdlog::info("Minimize"); }
-        if (ImGui::Button(ICON_MD_MAXIMIZE)) { spdlog::info("Maximize"); }
-        if (ImGui::Button(ICON_MD_CLOSE)) { spdlog::info("Quit"); }
-        */
         ImGui::PopStyleColor(1);
         ImGui::PopStyleVar();
 
@@ -412,7 +283,7 @@ public:
        // spdlog::info("{0}x{1}", ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
         SceneisFocused = ImGui::IsWindowFocused() || ImGui::IsWindowHovered();
         ImGui::Image((ImTextureID)(intptr_t)renderer.getCurrentFrameBuffer().GetColourAttachment(),
-            ImVec2{(float)ImGui::GetWindowWidth(),(float)ImGui::GetWindowHeight()},ImVec2{1,1}, ImVec2{0,0});
+            ImVec2{(float)ImGui::GetWindowWidth(),(float)ImGui::GetWindowHeight()});
 
        
        
@@ -472,13 +343,73 @@ public:
 
         ImGui::End();
 
-        inspector.Update();
+        /*
+        {
+            ImGui::Begin("Asset", nullptr);
+
+            const char* hidden_extensions[]{
+        ".exe",
+        ".pdb",
+        ".idb",
+        ".dll",
+        ".ini"
+            };
 
 
-        //settings.Update();
+            std::vector <Asset> files = std::vector<Asset>();
-        //console.Update();
+
+            int iconSize = 60;
+            int maxColumns = 3;
+
+            YoggieEngine::Texture folderIcon;
+            YoggieEngine::Texture assetIcon;
+
+            assetIcon = YoggieEngine::Texture("rsc/AssetIcon.png");
+
+
+            ImGui::DragInt("IconSize", &iconSize, 1, 30, 90);
+            ImGui::DragInt("Max. Columns", &maxColumns, 1, 1, 6);
+
+            if (ImGui::BeginTable("##Resources", 3)) {
+                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.f, 0.f, 0.f, 0.f));
+                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.f, 1.f, 1.f, 0.2f));
+
+                int row = 0;
+                int column = 0;
+                for (auto& asset : files) {
+                    if (column % 3 == 0) {
+                        ImGui::TableNextRow();
+                        column = 0;
+                        row++;
+                    }
+
+                    ImGui::TableSetColumnIndex(column);
+
+                    ImGui::ImageButton(
+                        (ImTextureID)assetIcon.GetID(),
+                        ImVec2{ (float)iconSize, (float)iconSize });
+                    ImGui::Text(asset.GetName(), row);
+
+
+
+                    column++;
+                }
+
+
+
+                ImGui::PopStyleColor(3);
+                ImGui::EndTable();
+
+
+
+            }
+
+            ImGui::End();
+
+        }
+        */
        
-        assetsView.Update();
         
         ImGui::ShowDemoWindow();
         //ImGui::ShowMetricsWindow();
@@ -496,22 +427,63 @@ public:
 	}
 
 
+
+    bool OnKey(int key, int mode) override {
+        float movement_speed = 0.10f;
+
+        if (SceneisFocused) {
+            if (key == YOGGIE_KEY_UP)
+                camera->Rotation.x += movement_speed;
+
+            if (key == YOGGIE_KEY_DOWN)
+                camera->Rotation.x -= movement_speed;
+
+            if (key == YOGGIE_KEY_LEFT)
+                camera->Rotation.y += movement_speed;
+
+            if (key == YOGGIE_KEY_RIGHT)
+                camera->Rotation.y -= movement_speed;
+
+
+
+            if (key == YOGGIE_KEY_A)
+                camera->Position += glm::vec3(1.0f, 0.0f, 0.0f) * movement_speed;
+
+            if (key == YOGGIE_KEY_S)
+                camera->Position += glm::vec3(0.0f, 0.0f, -1.0f) * movement_speed;
+
+            if (key == YOGGIE_KEY_D)
+                camera->Position -= glm::vec3(1.0f, 0.0f, 0.0f) * movement_speed;
+
+            if (key == GLFW_KEY_W)
+                camera->Position -= glm::vec3(0.0f, 0.0f, -1.0f) * movement_speed;
+
+        }
+
+
+        return true;
+    }
+
+
+
 private:
     Inspector inspector;
-    AssetFinder assetsView;
+    Renderer renderer;
+
+    EditorCamera* camera = new EditorCamera();
+
 
-    bool SimulatePhysics = true;
-    YoggieEngine::Entity  Selected;
     Project project;
     Scene scene;
-    char* path = nullptr;
+
-    Texture Logo;
+    bool SimulatePhysics = true;
-    Renderer renderer;
-    EditorCamera* camera = new EditorCamera();
-    Mesh cube ;
     bool SceneisFocused = false;
 
+    YoggieEngine::Entity  Selected;
+    ImGuizmo::OPERATION activeOperation = ImGuizmo::OPERATION::TRANSLATE;
 
+    char* path = nullptr;
+    Texture Logo;
     
     void LoadLastOrEmptyProject() {
         // Check if there is a last known loaded project and 
@@ -536,7 +508,7 @@ private:
         {
 
             Project::LoadProject(ini["cache"]["project"], project);
-            LoadScene(ini["cache"]["scene"], scene);
+            ///LoadScene(ini["cache"]["scene"], scene);
 
         }
         else

Editor/src/Inspector.cpp

@@ -1,6 +1,6 @@
 #include "Inspector.h"
-#include "../TransformVec3.h"
+#include "TransformVec3.h"
-#include "../IconsMaterialDesign.h"
+#include "IconsMaterialDesign.h"
 
 void Inspector::Draw() 
 {

Editor/src/Inspector.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
+#include "EditorWindow.h"
 
 typedef void (*voidFunction) (void);
 

Editor/src/Project/Settings.cpp

@@ -1,48 +0,0 @@
-#include "Settings.h"
-
-void Settings::Draw() {
-    ImGui::LabelText("##title-settings", "Fine grain control over the engine!");
-
-    if (ImGui::BeginCombo("Graphics API", GraphicsAPI[selectedGfxAPI])) {
-        for (int i = 0; i < 3; i++) {
-            bool isSelected = i == selectedGfxAPI;
-            if (ImGui::Selectable(GraphicsAPI[i], isSelected)) {
-                selectedGfxAPI = i;
-            }
-
-            if (isSelected)
-                ImGui::SetItemDefaultFocus();
-        }
-
-        ImGui::EndCombo();
-    }
-
-    ImGui::NewLine();
-
-    if (ImGui::BeginCombo("Physics Engine", PhysicsEngine[selectedPhysicsEngine])) {
-        for (int i = 0; i < 2; i++) {
-            bool isSelected = i == selectedPhysicsEngine;
-            if (ImGui::Selectable(PhysicsEngine[i], isSelected)) {
-                selectedGfxAPI = i;
-            }
-
-            if (isSelected)
-                ImGui::SetItemDefaultFocus();
-        }
-
-        ImGui::EndCombo();
-    }
-
-    ImGui::InputFloat3("Gravity", glm::value_ptr(Gravity));
-
-    ImGui::NewLine();
-    if (ImGui::Button("Show Advanced options ")) {
-        ShowAdvancedOptions = !ShowAdvancedOptions;
-    }
-
-    if (ShowAdvancedOptions)
-    {
-        ImGui::Checkbox("Debug Engine", &DebugEngine);
-
-    }
-}

Editor/src/Project/Settings.h

@@ -1,30 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-
-
-class Settings : public EditorWindow {
-public:
-    Settings() : EditorWindow("Settings") {}
-
-    void Draw() override;
-
-private:
-    int selectedGfxAPI = 0;
-    int selectedPhysicsEngine = 0;
-    glm::vec3 Gravity = glm::vec3(0.0f, -9.81f, 0.0f);
-    bool ShowAdvancedOptions = false;
-    bool DebugEngine = false;
-
-    const char* PhysicsEngine[2] = {
-        "PhysX",
-        "Jolt Physics"
-    };
-
-    const char* GraphicsAPI[3] = {
-        "OpenGL",
-        "Vulkan",
-        "Metal (Apple)"
-    };
-
-};

Editor/src/app.cpp

@@ -12,7 +12,6 @@ public:
     void Run() override
     {
         PushLayer(new EditorLayer());
-
         Application::Run();
 
     }

YoggieEngine/premake5.lua

@@ -40,7 +40,7 @@ project "YoggieEngine"
     "../libs/steam-audio/include",
 
     "../libs/ImGui",
-
+    "../libs/yaml-cpp/include"
   }
 
   links {
@@ -51,6 +51,7 @@ project "YoggieEngine"
     "assimp-vc143-mtd",
     "glfw3",
     "ImGui",
+    "yaml-cpp",
 
     "PhysX_64",
     "PhysXCooking_64",

YoggieEngine/src/Assets/Asset.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "uuid.h"
+
+
+typedef  uuid::v4::UUID  AssetHandle;
+
+enum class AssetType {
+	Unknown = -1,
+	Mesh,
+	Texture,
+	Material,
+	Shader
+};
+
+struct Asset {
+	//AssetHandle Handle;
+	
+	//template<class T > 
+	//static AssetType GetType(T t) { return t.GetType(); }
+	virtual AssetType GetType() { return AssetType::Unknown; }
+};

YoggieEngine/src/Assets/AssetImporter.cpp

@@ -0,0 +1,143 @@
+#include <YoggieEngine.h>
+#include "AssetImporter.h"
+#include <assimp/Importer.hpp>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+
+namespace YoggieEngine {
+
+	void ProcessVertices(aiMesh* mesh, std::vector<YoggieEngine::Vertex>& out_vertices) {
+		for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
+			YoggieEngine::Vertex v{};
+
+			glm::vec3 vector{};
+			vector.x = mesh->mVertices[i].x;
+			vector.y = mesh->mVertices[i].y;
+			vector.z = mesh->mVertices[i].z;
+
+			v.vertices = vector;
+
+			if (mesh->mTextureCoords[0]) {
+				glm::vec2 texCoord{};
+
+				texCoord.x = mesh->mTextureCoords[0][i].x;
+				texCoord.y = mesh->mTextureCoords[0][i].y;
+
+				v.uv = texCoord;
+
+			}
+
+			out_vertices.push_back(v);
+		}
+	}
+
+	void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices) {
+		for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
+			aiFace face = mesh->mFaces[i];
+			if (face.mNumIndices < 3)
+				continue;
+			for (unsigned int j = 0; j < face.mNumIndices; j++) {
+				out_indices.push_back(face.mIndices[j]);
+			}
+		}
+	}
+
+	YoggieEngine::Mesh processMesh(aiMesh* mesh, const aiScene* scene) {
+		std::vector<unsigned int> indices;
+		std::vector<YoggieEngine::Vertex> vertices;
+
+		ProcessVertices(mesh, vertices);
+		ProcessIndices(mesh, indices);
+
+		YoggieEngine::Mesh result;
+		result.vertices = vertices;
+		result.elements = indices;
+
+		return result;
+
+	}
+
+	std::vector<YoggieEngine::Mesh> processNode(aiNode* node, const aiScene* scene) {
+
+		std::vector<YoggieEngine::Mesh> meshes = std::vector<YoggieEngine::Mesh>();
+
+		for (unsigned int i = 0; i < node->mNumMeshes; i++) {
+			aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+			meshes.push_back(processMesh(mesh, scene));
+		}
+
+
+
+		for (unsigned int i = 0; i < node->mNumChildren; i++) {
+			auto m2 = processNode(node->mChildren[i], scene);
+
+			for (auto m : m2) {
+				meshes.push_back(m);
+			}
+		}
+
+		return meshes;
+
+
+	}
+
+	void LoadModelFile(std::filesystem::path path) {
+		Assimp::Importer importer;
+		const aiScene* scene = importer.ReadFile(path.string(), aiProcess_Triangulate | aiProcess_FlipUVs);
+		aiNode* currentNode = scene->mRootNode;
+		auto meshes = processNode(currentNode, scene);
+	}
+
+	bool IsSupportedImageFormat(const std::string& extension) {
+		static std::vector<std::string> supported_image_extensions = { "jpeg", "jpg", "png","bmp","hdr","psd","tga","gif","pic","psd","pgm","ppm" };
+		
+		for (auto support_extension : supported_image_extensions) {
+			if (extension == support_extension)
+				return true;
+		}
+
+
+		return false;
+	}
+
+	Asset AssetImporter::ImportAsset(AssetMetadata& metadata) {
+
+		static Asset emptyAsset;
+
+
+		// Check file extension so we can choose our loader 
+		if (metadata.filepath.has_extension() == true)
+		{
+			spdlog::error("Asset file has no extension!");
+		}
+
+		const auto extension = metadata.filepath.extension().string();
+
+		// Handle as Model file
+		bool IsSupportedModelFile = importer.IsExtensionSupported(extension);
+		if (IsSupportedModelFile) {
+			LoadModelFile(metadata.filepath);
+			return emptyAsset;
+		}
+
+
+
+		// Handle as Texture
+		if (IsSupportedImageFormat(extension))
+		{
+			Texture texture;
+			texture.Load(metadata.filepath.string());
+			return texture;
+		}
+
+		// Handle as shader
+		if (extension == "glsl" || extension == "vert" || extension == "frag") {
+			//Shader shader;
+			//shader.
+			return emptyAsset;
+		}
+
+		return emptyAsset;
+
+	}
+};

YoggieEngine/src/Assets/AssetImporter.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "AssetMetadata.h"
+#include <assimp/Importer.hpp>
+namespace YoggieEngine{
+	class  AssetImporter {
+	public:
+		static Asset ImportAsset(AssetMetadata& metadata);
+	private:
+		static Assimp::Importer importer;
+
+	};
+}

YoggieEngine/src/Assets/AssetManager.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <map>
+#include "AssetMetaData.h"
+
+typedef std::map<AssetHandle, AssetMetadata> AssetRegistry;
+
+class AssetManager {
+public:
+	virtual Asset& GetAsset(AssetHandle handle) = 0;
+
+protected:
+	//AssetRegistry  Assets;
+	//std::map<AssetHandle, Asset> LoadedAssets;
+
+
+};

YoggieEngine/src/Assets/AssetManagerEditor.cpp

@@ -0,0 +1,41 @@
+#include "YoggieEngine.h"
+#include "AssetManagerEditor.h"
+#include "AssetImporter.h"
+using namespace YoggieEngine;
+
+Asset& AssetManagerEditor::GetAsset(AssetHandle handle)
+{
+    static Asset EmptyAsset{};
+
+    // 1. Check if handle is valid
+    if (IsAssetHandleValid(handle) == false)
+        return EmptyAsset;
+
+    // 2. check if asset needs loading
+    Asset asset;
+    if (IsAssetLoaded(handle)) {
+      //  asset = LoadedAssets.at(handle);
+    }
+    else {
+        // Load asset
+        // Get MetaData
+        //auto& metadata = Assets[handle];
+
+        // Load Asset 
+        //asset = AssetImporter::ImportAsset(metadata);
+
+    }
+    
+    // 3. return asset.
+    return  asset;
+
+}
+
+bool AssetManagerEditor::IsAssetHandleValid(AssetHandle handle)
+{
+    return false;///return Assets.find(handle) != Assets.end();
+}
+
+bool AssetManagerEditor::IsAssetLoaded(AssetHandle handle ) {
+    return false;//return LoadedAssets.find(handle) != LoadedAssets.end();
+}

YoggieEngine/src/Assets/AssetManagerEditor.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "AssetManager.h"
+
+class AssetManagerEditor : public AssetManager {
+public:
+	Asset& GetAsset(AssetHandle handle) override;
+private:
+	bool IsAssetHandleValid(AssetHandle handle);
+	bool IsAssetLoaded(AssetHandle handle);
+
+};

YoggieEngine/src/Assets/AssetMetadata.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <filesystem>
+#include "Asset.h"
+struct AssetMetadata{
+	AssetHandle handle;
+	std::filesystem::path filepath;
+};

YoggieEngine/src/Assets/uuid.h

@@ -16,23 +16,24 @@ namespace uuid::v4
     class UUID
     {
     public:
-        // Factory method for creating UUID object.
+        UUID() {}
-        static UUID New()
+
+        // method for creating UUID object.
+        void generate ()
         {
-            UUID uuid;
             std::random_device rd;
             std::mt19937 engine{ rd() };
             std::uniform_int_distribution<int> dist{ 0, 256 }; //Limits of the interval
 
             for (int index = 0; index < 16; ++index)
             {
-                uuid._data[index] = (unsigned char)dist(engine);
+                _data[index] = (unsigned char)dist(engine);
             }
 
-            uuid._data[6] = ((uuid._data[6] & 0x0f) | 0x40); // Version 4
+            _data[6] = ((_data[6] & 0x0f) | 0x40); // Version 4
-            uuid._data[8] = ((uuid._data[8] & 0x3f) | 0x80); // Variant is 10
+            _data[8] = ((_data[8] & 0x3f) | 0x80); // Variant is 10
+
             
-            return uuid;
         }
 
         // Returns UUID as formatted string
@@ -54,7 +55,6 @@ namespace uuid::v4
         }
 
     private:
-        UUID() {}
 
         unsigned char _data[16] = { 0 };
     };

YoggieEngine/src/EventSystem/Event.h

@@ -1,12 +0,0 @@
-#pragma once 
-namespace YoggieEngine {
-
-    struct Event
-    {
-    public:
-        std::string name;
-        int argc;
-        void** argv;
-
-    };
-}

YoggieEngine/src/EventSystem/EventEmitter.cpp

@@ -1,28 +0,0 @@
-#include <YoggieEngine.h>
-#include "EventEmitter.h"
-
-namespace YoggieEngine {
-
-	void EventEmitter::Subscribe(EventListener& subscriber)
-	{
-		subscribers.push_back(&subscriber);
-	}
-
-	void EventEmitter::Unsubscribe(EventListener& subscriber)
-	{
-		subscribers.remove(&subscriber);
-	}
-
-	void EventEmitter::EmitEvent(Event& incident)
-	{
-		// Notify all subscribers an event has taken place 
-		for (auto it = subscribers.begin(); it != subscribers.end(); ++it)
-		{
-			(*it)->ReceiveEvent(incident);
-		}
-	}
-
-	EventEmitter::EventEmitter() {
-		subscribers = std::list<EventListener*>{};
-	}
-}

YoggieEngine/src/EventSystem/EventEmitter.h

@@ -1,16 +0,0 @@
-#pragma once
-
-namespace YoggieEngine{
-	class EventEmitter {
-	public:
-		void Subscribe(EventListener& subscriber);
-		void Unsubscribe(EventListener& subscriber);
-
-	protected:
-		std::list<EventListener*> subscribers;
-		void EmitEvent(Event& incident);
-
-		EventEmitter();
-
-	};
-}

YoggieEngine/src/EventSystem/EventListener.h

@@ -1,9 +0,0 @@
-#pragma once 
-#include "Event.h"
-namespace YoggieEngine {
-    class EventListener {
-    public:
-        virtual void ReceiveEvent(Event& incident) = 0;
-
-    };
-}

YoggieEngine/src/Graphics/OpenglAPI.cpp

@@ -30,7 +30,11 @@ namespace YoggieEngine {
 	void OpenGLApi::DrawTriangles(Render3DComponent rc) {
 
 		glBindVertexArray(rc.VAO);
+		glCheckError();
+
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rc.IBO);
+		glCheckError();
+
 		glDrawElements(GL_TRIANGLES, static_cast<unsigned int> (rc.mesh.elements.size()), GL_UNSIGNED_INT, 0);
 		glCheckError();
 		glBindVertexArray(0);
@@ -41,6 +45,7 @@ namespace YoggieEngine {
 	void OpenGLApi::DrawCubeMap(unsigned int VertexAttributeObject, CubeMap CubeTexture) {
 
 		glDepthMask(GL_FALSE);
+		glActiveTexture(GL_TEXTURE0);
 		glBindTexture(GL_TEXTURE_CUBE_MAP, CubeTexture.getID());
 		//glCheckError(); // INVALID ENUM FOR SOME REASON
 		glBindVertexArray(VertexAttributeObject);

YoggieEngine/src/Graphics/RenderSurface.h

@@ -1,6 +1,6 @@
 #pragma once
-#include "../Graphics/Memory/Buffer.h"
+#include "../Graphics/Buffer.h"
-#include "../Graphics/Memory/VertexArray.h"
+#include "../Graphics/VertexArray.h"
 
 namespace YoggieEngine {
 

YoggieEngine/src/Graphics/Renderable.h

@@ -1,9 +0,0 @@
-#pragma once
-namespace YoggieEngine {
-
-	struct  Renderable {
-		Mesh* mesh;
-		Material* material;
-		Texture* texture;
-	};
-}

YoggieEngine/src/Graphics/Renderer.cpp

@@ -2,13 +2,12 @@
 
 #include "Renderer.h"
 #include "../Scene/Components.h"
-#include "../Graphics/Memory/Buffer.h"
+#include "../Graphics/Buffer.h"
-#include "../Graphics/Memory/VertexArray.h"
+#include "../Graphics/VertexArray.h"
-#include "Renderable.h"
+#include "Framebuffer.h"
-#include "Memory/Framebuffer.h"
 #include "../Scene/Components.h"
 #include"../Scene/Scene.h"
-#include "Primitives/Camera.h"
+#include "Camera.h"
 #include "OpenglAPI.h"
 
 namespace YoggieEngine {
@@ -95,6 +94,7 @@ Renderer::Renderer() :
 	};
 
 	skybox = CubeMap(faces);
+	grassTexture.Load("build/Debug/Texture/grass.png");
 
 }
 
@@ -162,7 +162,7 @@ void Renderer::Render(Scene& scene , Camera MainCamera){
 
 	SkyboxShader.Use();
 	SkyboxShader.setUniformMat4("projection", MainCamera.getProjection(width, height));
-	SkyboxShader.setUniformMat4("view", glm::inverse( glm::mat4(glm::mat3(MainCamera.getTransform()))));
+	SkyboxShader.setUniformMat4("view", glm::inverse(glm::mat4(glm::mat3(MainCamera.getTransform()))));
 
 	if (!skyboxVAO) {
 		unsigned int VBO;
@@ -268,7 +268,7 @@ void Renderer::Render(Scene& scene , Camera MainCamera){
 	if (transparentVAO == 0) {
 		unsigned int transparentVBO;
 		float transparentVertices[] = {
-			// positions         // texture Coords (swapped y coordinates because texture is flipped upside down)
+			// positions         // texture Coords 
 			0.0f,  0.5f,  0.0f,  0.0f,  1.0f,
 			0.0f, -0.5f,  0.0f,  0.0f,  0.0f,
 			1.0f, -0.5f,  0.0f,  1.0f,  0.0f,

YoggieEngine/src/Graphics/Renderer.h

@@ -3,7 +3,7 @@
 #include <vector>
 #include "../PerfCounter.h"
 #include "../Scene/Scene.h"
-#include "Memory/Framebuffer.h"
+#include "Framebuffer.h"
 
 namespace YoggieEngine {
 
@@ -58,7 +58,7 @@ namespace YoggieEngine {
 		// blending
 		Shader BlendingShader;
 		CubeMap skybox;
-		Texture grassTexture = Texture("build/Debug/Texture/grass.png");
+		Texture grassTexture;
 
 		unsigned int transparentVAO = 0;
 		unsigned int skyboxVAO = 0;

YoggieEngine/src/Graphics/Shader.h

@@ -1,12 +1,17 @@
 #pragma once
-
+#include "Assets/Asset.h"
 namespace YoggieEngine {
-    class Shader {
+    class Shader : public  Asset{
     private:
 
         char* readFile(const char* filePath);
+
+
+        AssetType GetType() override{ return AssetType::Shader; }
     public:
         Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath);
+
+
         void Use() const;
         void setUniformMat4(std::string uniformName, const glm::mat4& matrix4)const;
         void setUniformVec4(std::string uniformName, const glm::vec4& vector4)const;

YoggieEngine/src/Graphics/Texture.cpp

@@ -2,7 +2,8 @@
 #include "Texture.h"
 
 namespace YoggieEngine {
-	Texture::Texture(const std::string texturePath , bool Transparency) {
+
+	void Texture::Load(const std::string texturePath, bool Transparency) {
 		int channels;
 		unsigned char* data = stbi_load(texturePath.c_str(), &width, &height, &channels, 0);
 
@@ -30,7 +31,6 @@ namespace YoggieEngine {
 			spdlog::error("Failed to load image ({0})", texturePath);
 		}
 		stbi_image_free(data);
-
 	}
 
 	void Texture::Bind() {

YoggieEngine/src/Graphics/Texture.h

@@ -1,14 +1,18 @@
 #pragma once
+#include "Assets/Asset.h"
+
 namespace YoggieEngine {
-	class Texture {
+	class Texture : public Asset {
 	public:
 		Texture() = default;
-		Texture(const std::string texturePath, bool Transparency = false);
+		void Load(const std::string texturePath, bool Transparency = false);
 
 		void Bind();
 		void Unbind();
 		const unsigned int GetID() const { return Id; }
 		const ImVec2 getSize() { return {(float)width, (float)height}; }
+
+		AssetType GetType() override { return AssetType::Texture; } 
 	private:
 		unsigned int Id;
 		int width;

YoggieEngine/src/Platform/Window.h

@@ -1,7 +1,4 @@
 #pragma once 
-#include "../EventSystem/Event.h"
-#include "../EventSystem/EventListener.h"
-
 namespace YoggieEngine {
     class NativeWindow  {
  

YoggieEngine/src/Scene/Scene.cpp

@@ -31,61 +31,11 @@ namespace YoggieEngine{
 	void Scene::Start()
 	{
 		// Execute start functions in scripts etc....
-
 	}
 
 	void Scene::Update()
 	{
 		// Execute Update functions in scripts etc....
-
-		// Update transforms
-
-		auto& transforms = m_registry.view<TransformComponent>();
-		transforms.each([&](auto ent, TransformComponent& transform) {
-
-			glm::mat4 rotationX =
-			glm::rotate(
-				glm::mat4(1.0f),
-				glm::radians(transform.Rotation.x),
-				glm::vec3(1.f, 0.f, 0.0f)
-			);
-			glm::mat4 rotationY = 
-				glm::rotate(
-					glm::mat4(1.0f),
-					glm::radians(transform.Rotation.y),
-					glm::vec3(0.f, 1.f, 0.0f)
-				);
-			glm::mat4 rotationZ =
-				glm::rotate(
-					glm::mat4(1.0f), 
-					transform.Rotation.z,
-					glm::vec3(0.f, 0.f, 1.0f)
-				);
-
-			glm::mat4 rotationMatrix = rotationY * rotationX * rotationZ;
-			glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), transform.Position);
-			glm::mat4 ScaleMatrix = glm::scale(glm::mat4(1.0f), transform.Scale);
-
-			Entity entity( ent, this );
-			
-
-			if (entity.HasComponent<RelationComponent>()) 
-			{
-				auto& entityRelation = entity.GetComponent<RelationComponent>();
-				Entity parent = entityRelation.Parent;
-				TransformComponent parentTransform = parent.GetComponent<TransformComponent>();
-				glm::mat4 Model = translationMatrix * rotationMatrix * ScaleMatrix;
-				transform.LocalTransform = parentTransform.LocalTransform * Model;
-			}
-			else {
-				transform.LocalTransform = translationMatrix * rotationMatrix * ScaleMatrix;
-
-			}
-			
-		});
-
-	
-
 	}
 
 	void Scene::FixedUpdate()

YoggieEngine/src/Scene/SceneSerializer.cpp

@@ -1,3 +1,4 @@
+#include <YoggieEngine.h>
 #include "SceneSerializer.h"
 #include "../../YoggieEngine/src/YoggieEngine.h"
 #include <yaml-cpp/yaml.h>

YoggieEngine/src/Scene/UUID.h

@@ -1,16 +0,0 @@
-#pragma once
-#include <cstdint>
-
-class UUID {
-
-public:
-	static uint64_t Generate()
-	{
-		return ++last;
-	}
-
-private:
-	static uint64_t last ;
-
-};
-

YoggieEngine/src/YoggieEngine.h

@@ -33,19 +33,16 @@ extern "C"
 // Main library stuff
 #include "Platform/Platform.h"
 
-#include "Graphics/Primitives/Mesh.h"
+#include "Graphics/Mesh.h"
-#include "Graphics/Primitives/Shader.h"
+#include "Graphics/Shader.h"
-#include "Graphics/Primitives/Texture.h"
+#include "Graphics/Texture.h"
-#include "Graphics/Primitives/CubeMap.h"
+#include "Graphics/CubeMap.h"
-#include "Graphics/Primitives/Camera.h"
+#include "Graphics/Camera.h"
-#include "Graphics/Primitives/Material.h"
+#include "Graphics/Material.h"
 #include "Graphics/Renderer.h"
 
 #include "Physics/Physics.h"
 
-#include "EventSystem/EventEmitter.h"
-#include "EventSystem/EventListener.h"
-
 #include "Input/Keyboard.h"
 #include "Input/InputManager.h"