WIP: Switching from Premake to CMake build system

* 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

.gitignore

@@ -22,3 +22,6 @@ libs/physx/physx/compiler/
 libs/physx/physx/buildtools/
 libs/physx/physx/bin/
 libs/nativefiledialog/build/
+.docker
+
+**/bin/

.gitmodules

@@ -14,6 +14,7 @@
 [submodule "ImGui"]
 	path = libs/ImGui
 	url = https://github.com/ocornut/imgui.git
+	ignore = dirty
 [submodule "assimp"]
 	path = libs/assimp
 	url = https://github.com/assimp/assimp.git
@@ -31,9 +32,11 @@
 [submodule "libs/guizmo"]
 	path = libs/guizmo
 	url = https://github.com/CedricGuillemet/ImGuizmo.git
+	ignore = dirty
 [submodule "libs/yaml-cpp"]
 	path = libs/yaml-cpp
 	url = https://git.barink.dev/Nigel/yaml-cpp.git
+	ignore = dirty
 [submodule "libs/nativefiledialog"]
 	path = libs/nativefiledialog
 	url = https://git.barink.dev/Nigel/nativefiledialog.git
@@ -44,3 +47,6 @@
 [submodule "libs/imgui-filebrowser"]
 	path = libs/imgui-filebrowser
 	url = https://github.com/AirGuanZ/imgui-filebrowser.git
+[submodule "libs/googletest"]
+	path = libs/googletest
+	url = https://github.com/google/googletest.git

CmakeLists.txt

@@ -0,0 +1,21 @@
+CMAKE_MINIMUM_REQUIRED (VERSION 4.0)
+project(Yoggie) 
+set(EXPORT_COMPILE_COMMANDS_JSON ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4099")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wclass-struct-conversion")
+endif()
+
+add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+add_compile_definitions(GLFW_STATIC)
+
+add_subdirectory(Editor)
+add_subdirectory(SandboxApp)
+include(libraries.cmake)
+add_subdirectory(YoggieEngine)
+
+

Editor/.gitignore

@@ -0,0 +1 @@
+**.dll

Editor/CMakeLists.txt

@@ -0,0 +1,17 @@
+file(GLOB SOURCE_FILES "src/*.cpp")
+file(GLOB HEADER_FILES "src/*.h")
+add_executable(Editor ${SOURCE_FILES} "../libs/glad/src/glad.c" ${HEADER_FILES}) 
+
+target_include_directories(Editor PRIVATE 
+  "../YoggieEngine/src"
+  "../libs/guizmo"
+)
+target_link_directories(Editor PRIVATE 
+  "../libs/ImGui/build/Release"
+  "../libs/guizmo/build/Release" )
+target_link_libraries(Editor 
+  thirdparty_tools
+  YoggieEngine
+  ImGui
+  ImGuizmo
+)

Editor/premake5.lua

@@ -1,47 +0,0 @@
-project "Editor"
-kind "ConsoleApp"
-
-buildmessage "Building editor ..."
-
-links{
-  "YoggieEngine",
-  "ImGuizmo",
-  "yaml-cpp",
-  "nfd.lib"
-}
-
-includedirs{
-
-  "../YoggieEngine/build/Debug",
-
-  -- I'd prefer if didn't need these..
-  -- We'll figure that out some time later
-  "../libs/physx/physx/include",
-  "../libs/physx/pxshared/include",
-  incfolder["lua"],
-  incfolder["spdlog"],
-  incfolder["glm"],
-  incfolder["assimp"],
-  incfolder["glad"],
-  incfolder["glfw"],
-
-  incfolder["imgui"],
-  incfolder["imguizmo"],
-  incfolder["entt"],
-  incfolder["yamlcpp"],
-  incfolder["nativefiledialog"],
-  incfolder["mINI"]
-
-
-}
-
-libdirs {
-  staticlib["yoggie"],
-  staticlib["nativefiledialog"]
-}
-
-files { 
-  "../libs/glad/src/glad.c",
-  "./src/**.h",
-  "./src/**.cpp"
-}

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 {
-			std::cout << "unknown file!" << std::endl;
-			return ASSET_TYPE::Unknown;
-		}
-	}
-
-
-};

Editor/src/AssetManagement/AssetFinder.h

@@ -1,100 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "EditorWindow.h"
-#include "AssetManagement/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")
-    {
-        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());
-            asset.setFilPath(filepath.string());
-            spdlog::info("Created asset: {0}", asset.GetName());
-            files.push_back(asset);
-        
-        }
-
-    }
-
-    void Draw() override {
-
-        //assetIcon = YoggieEngine::Texture("rsc/AssetIcon.png");
-        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();
-            const GLuint textures[2]{ assetIcon.GetID(), folderIcon.GetID() };
-            glDeleteTextures(2, textures);
-
-        }
-    }
-
-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;
-
-	
-	std::cout << "Loading meshes!" << std::endl;
-
-	auto meshes = processNode(currentNode, scene);
-
-	std::cout << "Model file contained " << meshes.size() << " meshes" << std::endl;
-
-
-
-	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,139 +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 
-		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);
-
-
-		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 {
-		std::cout << "Failed ot open mesh " << std::endl;
-	}
-
-	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");
-	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;
-
-	*/
-	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/Dialog.h

@@ -31,9 +31,9 @@ public:
                     location = std::string(path);
                     break;
                 case(NFD_CANCEL):
-                    std::cout << "NFD_CANCEL" << std::endl;
+                    spdlog::info("NFD_CANCEL" );
                 case (NFD_ERROR):
-                    std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
+                    spdlog::error("NFD_Error: {0}" , NFD_GetError() );
                     break;
 
                 };

Editor/src/EditorCamera.h

@@ -8,24 +8,11 @@ public:
 		Right = glm::vec3(-1.0f, 0.0f, 0.0f);
 		Up = glm::vec3(0.0f, 1.0f, 0.0f);
 
-		projection = glm::perspective(glm::radians(65.0f), (800.0f / 600.0f), 0.001f, 100.0f);
-
-
-		view = glm::translate(glm::mat4(1.0f), Position) * glm::toMat4(glm::quat(Rotation));
 	}
 
-	void Update() {
-
-		view = glm::translate(glm::mat4(1.0f), Position) * glm::toMat4(glm::quat(Rotation));
-	}
-
-	glm::vec3 Position;
-	glm::vec3 Rotation;
 
 private:
-
-
-
+	
 	glm::vec3 Front;
 	glm::vec3 Right;
 	glm::vec3 Up;

Editor/src/EditorLayer.h

@@ -1,123 +1,487 @@
 #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 "AssetManagement/SceneSerializer.h"
-#include "AssetManagement/AssetRegistry.h"
-#include "Views/Viewport.h"
-#include "PropertyPanels/SceneExplorer.h"
-#include "AssetManagement/AssetFinder.h"
-#include "MainMenuBar.h"
-#include "PropertyPanels/Inspector.h"
-#include "Project/ProjectInfo.h"
-#include "Runtime/RuntimeControls.h"
-#include "AssetManagement/uuid.h"
-#include "Project/Settings.h"
-#include "Console.h"
-#include "AssetManagement/AssetLoaders/ModelLoader.h"
+#include <nfd.h>
+#include <ImGuizmo.h>
+#include <memory>
 
+#include "Inspector.h"
+#include "Console.h"
+#include "IconsMaterialDesign.h"
+#include "Project.h"
+#include "EditorCamera.h"
 using namespace YoggieEngine;
+
+
 class EditorLayer : public Layer {
 
+
 public:
-	EditorLayer():
-        Layer(),
-        rc(),
-        sceneview(scene, Selected),
-        explorer(Selected, scene),
-        inspector (Selected)
+    EditorLayer() : Layer()
     {
+
+        Logo.Load("rsc/Yoggie.png");
+        Selected = YoggieEngine::Entity{ (entt::entity)-1, (scene.get()) };
+        
     }
 
 	void OnStartup() override {
         std::string path = (std::filesystem::current_path()).string();
-        project.setProjectDirectory(path);
-        assetsView = AssetFinder(project.GetProjectDirectory());
+        scene = std::make_unique<Scene>();
+        project = std::make_unique<Project>();
+        project.get()->setProjectDirectory(path);
         LoadLastOrEmptyProject();
-
-        AssetRegistry assetManager = AssetRegistry();
-        ModelLoader modelLoader = ModelLoader();
-
-        std::cout << project.GetProjectDirectory() << std::endl;
-
-        auto latern = modelLoader.LoadAsset(std::filesystem::path("build/debug/Models/Latern.gltf"));
-        std::cout << "Loaded mesh: " << latern.GetName() << std::endl;
-
-        //ProjectInfo projectInfo(project);
-        //Settings settings = Settings();
         //Console console = Console();
- 
-
-
-        Selected = YoggieEngine::Entity((entt::entity)-1, &scene);
-
+       
 	}
 
 	void OnUpdate() override {
-        scene.Update();
-
-		if (sceneview.isFocused) {
-			UpdateSceneCamera(sceneview);
-
-			std::cout << "Scene view in Focus!\r";
-		}
-
+        scene.get()->Update();
+        renderer.get()->Render(*scene, *camera);
 	}
 
 
-    void OnUI() override {
-        {
-            MainMenuBar menuBar = MainMenuBar();
-            menuBar.ApplicationMenu(project);
-            menuBar.SceneMenu(project, scene);
-            menuBar.SelectMenu();
-            menuBar.WindowMenu();
-            menuBar.DebugMenu();
-            menuBar.Help();
 
+    void OnUI() override {
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { ImGui::GetWindowWidth(), 7 });
+        ImGui::BeginMainMenuBar();
+        int scaleFactor = 30;
+        ImGui::Image((ImTextureID)Logo.GetID(), { Logo.getSize().x / scaleFactor  , Logo.getSize().y / scaleFactor });
+        ImGui::PopStyleVar();
+        
+        if (ImGui::BeginMenu("App")) {
+
+            if (ImGui::MenuItem("Load Project"))
+            {
+                nfdresult_t result = NFD_OpenDialog({ "yproj" }, NULL, &path);
+                switch (result) {
+                case(NFD_OKAY):
+                    //Project::LoadProject(path, project);
+                    //AssetRegistry::setAssetPath(project.GetProjectDirectory());
+                    //AssetRegistry::BuildAssetView();
+                    break;
+                case(NFD_CANCEL):
+                    break;
+                case(NFD_ERROR):
+                    spdlog::error("NFD_Error: {0}", NFD_GetError());
+                    break;
+                }
+
+            }
+
+            if (ImGui::MenuItem("Save project as...")) {
+                nfdresult_t result = NFD_SaveDialog({ "yproj" }, NULL, &path);
+                switch (result) {
+                case(NFD_OKAY):
+                    spdlog::info("Save as: {0}", path);
+                    //Project::SaveProject(path, project);
+                    break;
+                case(NFD_CANCEL):
+                    break;
+                case(NFD_ERROR):
+                    spdlog::error("NFD_Error: {0}", NFD_GetError());
+                    break;
+                }
+            }
+
+            ImGui::EndMenu();
+        }
+        if (ImGui::BeginMenu("Scene")) {
+
+            if (ImGui::MenuItem("Save scene"))
+            {
+                nfdresult_t result = NFD_SaveDialog({ "yscene" }, NULL, &path);
+                switch (result) {
+                case(NFD_OKAY):
+                    //SaveScene(path, scene);
+
+                    //project.AddScene(scene);
+
+                    break;
+                case(NFD_CANCEL):
+                    break;
+                case(NFD_ERROR):
+                    std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
+                    break;
+                }
+
+            }
+
+            if (ImGui::MenuItem("Load scene"))
+            {
+                auto result = NFD_OpenDialog({ "yscene" }, NULL, &path);
+                switch (result) {
+                case (NFD_OKAY):
+                    //LoadScene(path, scene);
+                    break;
+                case(NFD_CANCEL):
+                    break;
+                case(NFD_ERROR):
+                    std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
+                    break;
+                }
+
+            }
+
+            if (ImGui::MenuItem("Add Entity"))
+            {
+                //scene.AddEntity("New Entity");
+            }
+
+            if (ImGui::MenuItem("Import Model"))
+            {
+                auto result = NFD_OpenDialog("obj,fbx,gltf", NULL, &path);
+                switch (result) {
+                case(NFD_OKAY):
+                    // Import Model
+                    /*
+                    AssetRegistry::LoadFromSource(
+                        path,
+                        "build/Debug/Assets"//project.get()->GetProjectDirectory() / "Assets"
+                    );
+                    */
+                    
+                    break;
+                case(NFD_CANCEL):
+                    break;
+                case(NFD_ERROR):
+                    std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
+                    break;
+                }
+            }
+
+            if (ImGui::MenuItem("Import MeshAsset (temp)"))
+            {
+                auto result = NFD_OpenDialog("mesh", NULL, &path);
+
+                switch (result) {
+                case(NFD_OKAY):
+                {
+                }
+                break;
+
+                case(NFD_CANCEL):
+                    spdlog::debug("User cancelled action");
+                    break;
+                case(NFD_ERROR):
+                    spdlog::warn("Something went wrong!");
+                    break;
+                }
+
+            }
+
+
+
+            ImGui::EndMenu();
         }
 
-        //projectInfo.Update();
-        sceneview.Update();
-        rc.Update();
-        explorer.Update();
-        //settings.Update();
-        inspector.Update();
-        //console.Update();
+        ImGui::SameLine(ImGui::GetWindowWidth() / 4 * 3);
 
-        assetsView.Update();
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.3f, 0.3f, 0.3f, 1.0f));
+        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
+        ImGui::Button(ICON_MD_ROCKET_LAUNCH "Project");
 
+        ImGui::SameLine(ImGui::GetWindowWidth() - 120);
+       
+        ImGui::PopStyleColor(1);
+        ImGui::PopStyleVar();
+
+        ImGui::EndMainMenuBar();
+
+
+        ImGui::Begin("RuntimeControls");
+
+        ImGui::BeginGroup();
+        ImGui::SameLine();
+        ImGui::Text(ICON_MD_TRANSFORM);
+
+        auto spacing = 10;
+        float buttonWidth = 75.0f;
+        float buttonHeight = 30;
+        float ColorIntensity = 0.5f;
+        float ColorIntensityHovered = 0.75;
+        float ColorIntensityActive = 0.85;
+        float yPadding = 6.f;
+
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{0, yPadding });
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.0f,ColorIntensity ,0.0f ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.0f,ColorIntensityHovered ,0.0f ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.0f,ColorIntensityActive ,0.0f ,1.0f });
+        ImGui::SameLine(0, spacing);
+        if (ImGui::Button("Translate", { buttonWidth,buttonHeight }))
+            activeOperation = ImGuizmo::OPERATION::TRANSLATE;
+        
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{ 0, yPadding });
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ ColorIntensity, 0.0f ,0.0f ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ ColorIntensityHovered, 0.0f ,0.0f ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ ColorIntensityActive, 0.0f ,0.0f ,1.0f });
+        ImGui::SameLine(0, spacing);
+        if (ImGui::Button("Rotate", { buttonWidth,buttonHeight }))
+            activeOperation = ImGuizmo::OPERATION::ROTATE;
+
+        ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{ 0, yPadding });
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.0f, 0.0f ,ColorIntensity ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.0f, 0.0f ,ColorIntensityHovered ,1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.0f, 0.0f ,ColorIntensityActive ,1.0f });
+        ImGui::SameLine(0, spacing);
+        if (ImGui::Button("Scale", { buttonWidth,buttonHeight }))
+            activeOperation = ImGuizmo::OPERATION::SCALE;
+
+        ImGui::PopStyleColor(9);
+        ImGui::PopStyleVar(3);
+
+
+        ImGui::EndGroup();
+
+        ImGui::SameLine((ImGui::GetWindowContentRegionMax().x / 2) - (90));
+        auto color = ImVec4{ 0.001 * 12 , 0.001 * 201 , 0.001 * 69, 1.0f };
+        ImGui::PushStyleColor(ImGuiCol_Button, color);
+        const float strengthIncrease = 1.5f;
+        ImGui::PushStyleColor(
+            ImGuiCol_ButtonHovered,
+            ImVec4{
+                color.x * strengthIncrease,
+                color.y * strengthIncrease,
+                color.z * strengthIncrease,
+                color.w
+            }
+        );
+        if (ImGui::Button(ICON_MD_PLAY_ARROW, { 90,25 })) {
+            // Play game 
+        }
+        ImGui::PopStyleColor(2);
+        ImGui::SameLine();
+        color = ImVec4{ 0.001 * 14, 0.001 * 157, 0.001 * 201, 1.0f };
+        ImGui::PushStyleColor(ImGuiCol_Button, color);
+       
+        ImGui::PushStyleColor(
+            ImGuiCol_ButtonHovered,
+            ImVec4{
+                color.x * strengthIncrease,
+                color.y * strengthIncrease,
+                color.z * strengthIncrease,
+                color.w
+            }
+        );
+        
+        if (ImGui::Button(ICON_MD_ELECTRIC_BOLT, { 90,25 })) {
+            // Simulate physics
+        }
+        ImGui::PopStyleColor(2);
+        ImGui::End();
+
+
+        unsigned int viewportWindowFlags = ImGuiWindowFlags_NoTitleBar
+            | ImGuiWindowFlags_NoDecoration
+            | ImGuiWindowFlags_NoScrollbar
+            | ImGuiWindowFlags_NoMove
+            | ImGuiWindowFlags_NoCollapse;
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0,0 });
+        ImGui::Begin("SceneView",nullptr,viewportWindowFlags);
+       // spdlog::info("{0}x{1}", ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
+        SceneisFocused = ImGui::IsWindowFocused() || ImGui::IsWindowHovered();
+        ImGui::Image((ImTextureID)(intptr_t)renderer.get()->getCurrentFrameBuffer().GetColourAttachment(),
+            ImVec2{(float)ImGui::GetWindowWidth(),(float)ImGui::GetWindowHeight()});
+
+       
+       
+        //ImGuizmo::ViewManipulate(glm::value_ptr(cameraView), 1, ImGui::GetWindowPos(), { 90,90 }, 0x22CCCCCCC);
+
+
+        if(Selected.isValid()){
+
+
+            ImGuizmo::SetOrthographic(false);
+            ImGuizmo::SetDrawlist();
+
+            ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
+
+            const auto& ProjMatrix = camera->getProjection(ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
+            const glm::mat4& viewMatrix  = glm::inverse(camera->getTransform());
+
+
+            auto& tc = Selected.GetComponent<YoggieEngine::TransformComponent>();
+            auto transform = tc.GetTransform();
+            ImGuizmo::Manipulate(
+                glm::value_ptr(viewMatrix),
+                glm::value_ptr(ProjMatrix),
+                activeOperation, ImGuizmo::LOCAL, glm::value_ptr(transform));
+            if (ImGuizmo::IsUsing())
+            {
+                tc.Decompose(transform);
+
+            }
+
+
+        }   
+
+
+        
+        ImGui::End();
+        ImGui::PopStyleVar();
+
+        ImGui::Begin("EditorCamera");
+        
+        ImGui::SliderFloat3("position", glm::value_ptr(camera->Position), -50, 50);
+        ImGui::End();
+
+
+
+
+        ImGui::Begin(ICON_MD_MENU "SceneExplorer",nullptr);
+        scene.get()->getReg().each([&](entt::entity enttNumber) {
+            YoggieEngine::Entity entity = YoggieEngine::Entity(enttNumber, &*scene.get());
+            auto id = entity.GetComponent<YoggieEngine::IdentifierComponent>();
+            if (ImGui::Selectable(id.name.c_str(), entity == Selected)) {
+                Selected = YoggieEngine::Entity(enttNumber, &*scene);
+
+            }
+            });
+
+
+        ImGui::End();
+
+        
+        {
+            ImGui::Begin("Asset", nullptr);
+
+            const char* hidden_extensions[]{
+        ".exe",
+        ".pdb",
+        ".idb",
+        ".dll",
+        ".ini"
+            };
+
+
+            std::vector <Asset> files = std::vector<Asset>();
+
+            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.Handle.String().c_str(), row);
+
+
+
+                    column++;
+                }
+
+
+
+                ImGui::PopStyleColor(3);
+                ImGui::EndTable();
+
+
+
+            }
+
+            ImGui::End();
+
+        }
+        
+       
+        
         ImGui::ShowDemoWindow();
         //ImGui::ShowMetricsWindow();
     }
 
 	
 	void OnCreate() override {
-		std::cout << " Layer Create!" << std::endl;
+		spdlog::info(" Layer Create!" );
 
 	}
 
 	void OnDestroy() override {
-		std::cout << " Layer Destroy!" << std::endl;
-
+		spdlog::info( " Layer Destroy!" );
+        
 	}
 
 
-private:
 
-    RuntimeControls rc;
-    Viewport sceneview ;
-    SceneExplorer explorer;
-    Inspector inspector;
-    AssetFinder assetsView;
+    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:
+    std::unique_ptr<Inspector> inspector = std::make_unique<Inspector>(Selected);
+    std::unique_ptr<Renderer> renderer = std::make_unique<Renderer>();
+    std::unique_ptr<EditorCamera> camera = std::make_unique<EditorCamera>();
+    std::unique_ptr<Project> project;
+    std::unique_ptr<Scene> scene;
+
+    Texture Logo;
+
 
     bool SimulatePhysics = true;
-    YoggieEngine::Entity  Selected;
-    Project project;
-    Scene scene;
+    bool SceneisFocused = false;
 
+    YoggieEngine::Entity  Selected;
+    ImGuizmo::OPERATION activeOperation = ImGuizmo::OPERATION::TRANSLATE;
+
+    char* path = nullptr;
+    
     void LoadLastOrEmptyProject() {
         // Check if there is a last known loaded project and 
        // load that one .
@@ -140,8 +504,8 @@ private:
         if (ini["editor"]["openlastproject"] == "TRUE")
         {
 
-            Project::LoadProject(ini["cache"]["project"], project);
-            LoadScene(ini["cache"]["scene"], scene);
+            Project::LoadProject(ini["cache"]["project"], *project);
+            ///LoadScene(ini["cache"]["scene"], scene);
 
         }
         else
@@ -150,98 +514,4 @@ private:
         }
     }
 
-
-    void UpdateSceneCamera(Viewport& sceneview) {
-        const float movement_speed = 0.01f;
-        static float lastX = 400, lastY = 300;
-        const float sensitivity = 0.1;
-        static bool firstMouse = true;
-
-        /*
-
-        if (MouseButtonPressed(YOGGIE_MOUSE_BUTTON_RIGHT)) {
-
-            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
-            auto newX = getCursorPosX(appWindow);
-            auto newY = getCursorPosY(appWindow);
-
-            if (firstMouse)
-            {
-                lastX = newX;
-                lastY = newY;
-                firstMouse = false;
-            }
-
-
-            float xoffset = newX - lastX;
-            float yoffset = newY - lastY;
-
-            lastX = newX;
-            lastY = newY;
-
-            xoffset *= sensitivity;
-            yoffset *= sensitivity;
-
-            sceneview.cam.Rotation.x += (xoffset / 2);
-            sceneview.cam.Rotation.y += (xoffset /2);
-            sceneview.cam.Rotation.z += yoffset;
-
-
-            if (sceneview.cam.pitch > 89.0f)
-                sceneview.cam.pitch = 89.0f;
-            if (sceneview.cam.pitch < -89.0f)
-                sceneview.cam.pitch = -89.0f;
-
-
-        }
-        else if (firstMouse == false)
-        {
-            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-            firstMouse = true;
-        }
-
-
-
-        */
-        
-        EditorCamera& cam = sceneview.GetCamera();
-
-        
-        
-        if (keyIsPressed(YOGGIE_KEY_UP))
-            cam.Rotation.x += movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_DOWN))
-            cam.Rotation.x -= movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_LEFT))
-            cam.Rotation.y += movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_RIGHT))
-            cam.Rotation.y -= movement_speed;
-
-
-        cam.Update();
-
-
-
-        /*
-
-        // Check for Camara movement input here!
-        if (keyIsPressed(YOGGIE_KEY_W))
-            sceneview.cam.Position -= sceneview.cam.Front * movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_A))
-            sceneview.cam.Position += sceneview.cam.Right * movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_S))
-            sceneview.cam.Position += sceneview.cam.Front * movement_speed;
-
-        if (keyIsPressed(YOGGIE_KEY_D))
-            sceneview.cam.Position -= sceneview.cam.Right * movement_speed;
-            */
-
-
-    }
-
 };

Editor/src/EditorWindow.h

@@ -9,7 +9,8 @@ public:
 
 	void Update()
 	{
-		ImGui::Begin(name.c_str(), false, flags);
+		
+		ImGui::Begin(name.c_str(), nullptr, flags);
 		Draw();
 		ImGui::End();
 	}

Editor/src/Inspector.cpp

@@ -1,5 +1,6 @@
 #include "Inspector.h"
-#include "../TransformVec3.h"
+#include "TransformVec3.h"
+#include "IconsMaterialDesign.h"
 
 void Inspector::Draw() 
 {
@@ -56,6 +57,28 @@ void Inspector::ShowComponents()
     if (selected.HasComponent<YoggieEngine::TransformComponent>()) {
         auto& transform = selected.GetComponent<YoggieEngine::TransformComponent>();
         if (ImGui::CollapsingHeader("Transform", ImGuiTreeNodeFlags_DefaultOpen)) {
+
+            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 1.0, 1.0f, 1.0f, 0.0f });
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 1.0, 1.0f, 1.0f, 0.0f });
+            ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 1.0, 1.0f, 1.0f, 0.0f });
+            ImGui::SetCursorPosX(ImGui::GetContentRegionMax().x - 20);
+            ImGui::Button(ICON_MD_SETTINGS, { 20,20 });
+            ImGui::OpenPopupOnItemClick("##myContext", ImGuiPopupFlags_MouseButtonRight);
+            if (ImGui::BeginPopupContextWindow("##myContext")) {
+                if (ImGui::MenuItem("Reset")) {
+                    spdlog::info("Reset component");
+                }
+                if (ImGui::MenuItem("Copy Component")) {
+                    spdlog::info("Copy component");
+                }
+
+
+                ImGui::EndPopup();
+
+            }
+            
+            ImGui::PopStyleColor(3);
+
 /*
             ImGui::DragFloat3("Position", glm::value_ptr(transform.Position), 0.1f);
             ImGui::DragFloat3("Rotation", glm::value_ptr(transform.Rotation), 0.1f);
@@ -134,9 +157,29 @@ void Inspector::ShowComponents()
     }
 
     if (selected.HasComponent<YoggieEngine::ScriptComponent>()) {
-        ComponentView("Scripting", [] {
-            ImGui::LabelText("##--", "Hello scripting");
-            });
+        const char* AssetNames[]{ "Script 1" , "Script 2" };
+        if (ImGui::CollapsingHeader("Script", ImGuiTreeNodeFlags_Leaf)) {
+            
+            if (ImGui::Button("Select Renderable Asset"))
+                ImGui::OpenPopup("Scripts_list_popup");
+          
+            if (ImGui::BeginPopup("Scripts_list_popup")) {
+                ImGui::Text("None");
+                ImGui::Separator();
+                for (int i = 0; i < IM_ARRAYSIZE(AssetNames); i++) {
+                    if (ImGui::Selectable(AssetNames[i]))
+                    {
+                    }
+                }
+                ImGui::EndPopup();
+
+            }
+            
+            ImGui::SameLine();
+            std::string  scriptAssetId = "<Random_GUID>";
+            ImGui::InputText("asset", scriptAssetId.data(), scriptAssetId.length(), ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_AutoSelectAll);
+            
+        }
     }
 }
 

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/MainMenuBar.cpp

@@ -1,194 +0,0 @@
-#include "MainMenuBar.h"
-#include <nfd.h>
-#include "AssetManagement/AssetRegistry.h"
-
-
-
-MainMenuBar::MainMenuBar()
-{
-    ImGui::BeginMainMenuBar(); 
-}
-
-void MainMenuBar::ApplicationMenu(Project& project) {
-
-    if (ImGui::BeginMenu("Application")) {
-
-        if (ImGui::MenuItem("Load Project"))
-        {
-            nfdresult_t result = NFD_OpenDialog({ "yproj" }, NULL, &path);
-            switch (result) {
-            case(NFD_OKAY):
-                Project::LoadProject(path, project);
-                //AssetRegistry::setAssetPath(project.GetProjectDirectory());
-                //AssetRegistry::BuildAssetView();
-                break;
-            case(NFD_CANCEL):
-                break;
-            case(NFD_ERROR):
-                std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
-                break;
-            }
-
-        }
-
-        if (ImGui::MenuItem("Save project as...")) {
-            nfdresult_t result = NFD_SaveDialog({ "yproj" }, NULL, &path);
-            switch (result) {
-            case(NFD_OKAY):
-                std::cout << "Save as: " << path << std::endl;
-                Project::SaveProject(path, project);
-                break;
-            case(NFD_CANCEL):
-                break;
-            case(NFD_ERROR):
-                std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
-                break;
-            }
-        }
-
-
-  
-
-
-
-        if (ImGui::MenuItem("Preferences"))
-        {
-
-        }
-
-        if (ImGui::MenuItem("Exit"))
-        {
-            // TODO: Exit application
-        }
-
-        ImGui::EndMenu();
-    }
-}
-
-void MainMenuBar::SceneMenu(Project& project, YoggieEngine::Scene& scene) {
-
-    if (ImGui::BeginMenu("Scene")) {
-
-        if (ImGui::MenuItem("Save scene"))
-        {
-            nfdresult_t result = NFD_SaveDialog({ "yscene" }, NULL, &path);
-            switch (result) {
-            case(NFD_OKAY):
-                SaveScene(path, scene);
-                
-                project.AddScene(scene);
-
-                break;
-            case(NFD_CANCEL):
-                break;
-            case(NFD_ERROR):
-                std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
-                break;
-            }
-
-        }
-
-        if (ImGui::MenuItem("Load scene"))
-        {
-            auto result = NFD_OpenDialog({ "yscene" }, NULL, &path);
-            switch (result) {
-            case (NFD_OKAY):
-                LoadScene(path, scene);
-                break;
-            case(NFD_CANCEL):
-                break;
-            case(NFD_ERROR):
-                std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
-                break;
-            }
-
-        }
-
-        if (ImGui::MenuItem("Add Entity"))
-        {
-            scene.AddEntity("New Entity");
-        }
-
-        if (ImGui::MenuItem("Import Model"))
-        {
-            auto result = NFD_OpenDialog("obj,fbx,gltf", NULL, &path);
-            switch (result) {
-            case(NFD_OKAY):
-                // Import Model
-
-                AssetRegistry::LoadFromSource(
-                    path,
-                    "build/Debug/Assets"//project.get()->GetProjectDirectory() / "Assets"
-                );
-                break;
-            case(NFD_CANCEL):
-                break;
-            case(NFD_ERROR):
-                std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
-                break;
-            }
-        }
-
-        if (ImGui::MenuItem("Import MeshAsset (temp)"))
-        {
-            auto result = NFD_OpenDialog("mesh", NULL, &path);
-
-            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;
-
-            case(NFD_CANCEL):
-                spdlog::debug("User cancelled action");
-                break;
-            case(NFD_ERROR):
-                spdlog::warn("Something went wrong!");
-                break;
-            }
-
-        }
-
-        ImGui::EndMenu();
-    }
-}
-
-void MainMenuBar::DebugMenu()
-{
-    if (ImGui::BeginMenu("Debug")) {
-        ImGui::EndMenu();
-    }
-}
-
-void MainMenuBar::SelectMenu() {
-    if (ImGui::BeginMenu("Select")) {
-        ImGui::EndMenu();
-    }
-}
-
-void MainMenuBar::WindowMenu() {
-    if (ImGui::BeginMenu("Window")) {
-
-        ImGui::EndMenu();
-    }
-}
-
-void MainMenuBar::Help() {
-    if (ImGui::BeginMenu("Help")) {
-        ImGui::EndMenu();
-    }
-}
-
-MainMenuBar::~MainMenuBar() 
-{ 
-    ImGui::EndMainMenuBar(); 
-}

Editor/src/MainMenuBar.h

@@ -1,30 +0,0 @@
-#pragma once
-#include <imgui.h>
-#include "AssetManagement/SceneSerializer.h"
-#include "../../YoggieEngine/src/Scene/Scene.h"
-#include "Project/Project.h"
-
-
-class MainMenuBar {
-
-public:
-    MainMenuBar();
-
-    void ApplicationMenu(Project& project);
-
-    void SceneMenu(Project& project, YoggieEngine::Scene& scene);
-
-    void DebugMenu();
-
-    void SelectMenu();
-
-    void WindowMenu();
-
-    void Help();
-
-    ~MainMenuBar();
-
-private:
-    char* path = nullptr;
-
-};

Editor/src/Project.cpp

@@ -31,6 +31,11 @@ void Project::SaveProject(std::filesystem::path path, Project& project)
 
 void Project::LoadProject(std::filesystem::path path, Project& project) 
 {
+
+	if (!std::filesystem::exists(path)) {
+		throw std::runtime_error("Couldn't find project file!");
+	}
+
 	std::string YAMLProject;
 	std::stringstream sstream;
 	std::ifstream projectFile;
@@ -47,7 +52,7 @@ void Project::LoadProject(std::filesystem::path path, Project& project)
 	// this is probably not perfect but it seems to work for now
 	project = node.as<Project>();
 
-	std::cout << "loading..." << project.Name << std::endl;
+	spdlog::info("loaded project {0}", project.Name);
 
 
 	
@@ -63,8 +68,13 @@ namespace YAML {
 		{
 			if (!node.IsMap())
 				return false;
-			rhs.setName(node["Project"].as<std::string>());
-			rhs.setProjectDirectory(node["Directory"].as<std::string>());
+
+			std::string projectName = node["Project"].as<std::string>();
+			rhs.setName(projectName);
+
+
+			std::string projectDirectory  = node["Directory"].as<std::string>();
+			rhs.setProjectDirectory(projectDirectory);
 			
 		
 

Editor/src/Project.h

@@ -9,7 +9,7 @@ class Project {
 public:
 	Project() = default;
 	Project(const std::string& name): Name(name){}
-	~Project() { std::cout << "Unloading project..." << Name << std::endl; }
+	~Project() { spdlog::info("Unloading project {0}...", Name);}
 
 	void setName(std::string& name) { Name = name; }
 	const std::string& GetName()const { return Name; }

Editor/src/Project/ProjectInfo.cpp

@@ -1,7 +0,0 @@
-#include "ProjectInfo.h"
-
-void ProjectInfo::Draw() 
-{
-	ImGui::Text("Project: %s", project.GetName().c_str());
-	ImGui::Text("Directory: %s", project.GetProjectDirectory().u8string().c_str());
-}

Editor/src/Project/ProjectInfo.h

@@ -1,15 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-#include "Project.h"
-
-class ProjectInfo : public EditorWindow {
-public:
-    ProjectInfo(Project& project) : EditorWindow("Project Info"), project(project) {}
-
-    void Draw() override;
-
-private:
-    Project& project;
-
-};

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/PropertyPanels/SceneExplorer.cpp

@@ -1,13 +0,0 @@
-#include "SceneExplorer.h"
-
-void SceneExplorer::Draw()
-{
-    scene.getReg().each([&](entt::entity enttNumber) {
-        YoggieEngine::Entity entity = YoggieEngine::Entity(enttNumber, &scene);
-        auto id = entity.GetComponent<YoggieEngine::IdentifierComponent>();
-
-        if (ImGui::Selectable(id.name.c_str(), entity == selected)) {
-            selected = YoggieEngine::Entity(enttNumber, &scene);
-        }
-    });
-}

Editor/src/PropertyPanels/SceneExplorer.h

@@ -1,20 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-#include "../../src/Scene/Entity.h"
-
-class SceneExplorer : public EditorWindow {
-public:
-    SceneExplorer(YoggieEngine::Entity& selected, YoggieEngine::Scene& scene)
-        : EditorWindow("SceneExplorer"), scene(scene), selected(selected)
-    {}
-
-    void Draw() override;
-
-
-private:
-    YoggieEngine::Entity& selected;
-    YoggieEngine::Scene& scene;
-
-
-};

Editor/src/Runtime/RuntimeControls.cpp

@@ -1,27 +0,0 @@
-#include "RuntimeControls.h"
-
-void RuntimeControls::Draw() {
-    ImGui::SameLine((ImGui::GetWindowContentRegionMax().x / 2) - (numButtons * buttonSize.x));
-    for (int i = 0; i < numButtons; i++) {
-        ImVec4 color = button[i].Color;
-        ImGui::PushStyleColor(ImGuiCol_Button, color);
-        const float strengthIncrease = 1.5f;
-        ImGui::PushStyleColor(
-            ImGuiCol_ButtonHovered,
-            ImVec4{
-                color.x * strengthIncrease,
-                color.y * strengthIncrease,
-                color.z * strengthIncrease,
-                color.w
-            }
-        );
-        if (ImGui::Button(button[i].Name, buttonSize)) {
-
-        }
-        ImGui::PopStyleColor();
-        ImGui::PopStyleColor();
-        ImGui::SameLine();
-
-    }
-
-}

Editor/src/Runtime/RuntimeControls.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-
-#define RuntimeControlWindowFlags (ImGuiWindowFlags_)(ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse)
-
-struct ButtonInfo {
-    const char* Name;
-    ImVec4 Color;
-};
-
-class RuntimeControls : public EditorWindow {
-public:
-    RuntimeControls() : EditorWindow("RuntimeControls", RuntimeControlWindowFlags) {}
-
-    void Draw() override;
-
-private:
-    ImVec2 buttonSize = ImVec2{ 90 ,25 };
-    unsigned int numButtons = 2;
-    ButtonInfo button[2] = {
-        {"Play" , ImVec4{ 0.001 * 12 , 0.001 * 201 , 0.001 * 69, 1.0f}},
-        {"Simulate", ImVec4{ 0.001 * 14, 0.001 * 157, 0.001 * 201, 1.0f}}
-    };
-
-};

Editor/src/Views/Viewport.cpp

@@ -1,61 +0,0 @@
-#include "Viewport.h"
-
-Viewport::Viewport(YoggieEngine::Scene& scene, YoggieEngine::Entity& selected) :
-    EditorWindow("SceneView"),
-    renderer(YoggieEngine::RendererConfig{ 1200, 700, glm::vec3(0), true })
-{
-    CurrentScene = &scene;
-    this->selected = &selected;
-}
-
-void Viewport::Draw() {
-
-    auto group = CurrentScene->getReg().view<YoggieEngine::TransformComponent, YoggieEngine::Render3DComponent>();
-    group.each([&](auto enity, YoggieEngine::TransformComponent& t, YoggieEngine::Render3DComponent& renderComponent) {
-        renderer.Submit(renderComponent, t);
-        });
-    
-    isFocused = ImGui::IsWindowFocused();
-
-    renderer.Render(*CurrentScene);
-
-    ImGui::Image(
-        (void*)(intptr_t)renderer.getCurrentFrameBuffer().GetColourAttachment(),
-        ImVec2{ (float)ImGui::GetWindowWidth(),(float)ImGui::GetWindowHeight() }
-    );
-
-
-    
-
-    ImGuizmo::Enable(true);
-    ImGuizmo::SetOrthographic(false);
-    ImGuizmo::SetDrawlist();
-
-    float windowWidth = (float)ImGui::GetWindowWidth();
-    float windowHeight = (float)ImGui::GetWindowHeight();
-    ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, windowWidth, windowHeight);
-
-    const auto& ProjMatrix = camera.projection;
-    glm::mat4& cameraView = glm::mat4(1.0f);//glm::inverse(glm::translate(glm::mat4(1.0f) , cam.Position) * glm::toMat4(glm::quat(cam.Rotation)) );
-
-    ImGuizmo::DrawGrid(glm::value_ptr(cameraView), glm::value_ptr(ProjMatrix), glm::value_ptr(cameraDelta), 100.0f);
-    ImGuizmo::ViewManipulate(glm::value_ptr(cameraView), 1, ImGui::GetWindowPos(), {90,90}, 0x22CCCCCC);
-
-
-    if (selected == nullptr)
-        return;
-
-    if (selected->isValid()) {
-      
-        auto& tc = selected->GetComponent<YoggieEngine::TransformComponent>();
-        glm::mat4 transform = tc.GetTransform();
-
-        ImGuizmo::Manipulate(
-                    glm::value_ptr(cameraView),
-            glm::value_ptr(ProjMatrix),
-            ImGuizmo::TRANSLATE, ImGuizmo::LOCAL,
-            glm::value_ptr(transform), nullptr, nullptr);
-    }
-
-   
-}

Editor/src/Views/Viewport.h

@@ -1,28 +0,0 @@
-#pragma once
-#include "../../YoggieEngine/src/YoggieEngine.h"
-#include "../EditorWindow.h"
-
-#include <glm/glm.hpp>
-
-#include <imgui.h>
-#include "../../libs/guizmo/ImGuizmo.h"
-#include "../EditorCamera.h"
-
-
-class Viewport : public EditorWindow {
-public:
-    bool isFocused = false;
-    Viewport(YoggieEngine::Scene& scene, YoggieEngine::Entity& selected);
-    Viewport() = default;
-    void Draw() override;
-
-    EditorCamera& GetCamera(){ return camera; }
-
-private:
-    YoggieEngine::Renderer renderer;
-    YoggieEngine::Scene* CurrentScene;
-    YoggieEngine::Entity* selected;
-    glm::mat4 cameraDelta = glm::mat4(1.0);
-    EditorCamera camera;
-
-};

Editor/src/app.cpp

@@ -1,59 +1,17 @@
-#include "../../YoggieEngine/src/EntryPoint.h"
-#include <stack>
 #include "EditorLayer.h"
-
+#include "EntryPoint.h"
+#include <stack>
 
 using namespace YoggieEngine;
 
 class Editor : public Application {
 public:
-    Editor() : Application("Editor"){}
-
-    void Run() override
-    {
-
-
-        // Create EditorLayer
-        EditorLayer* firstLayer = new EditorLayer();
-   
-        firstLayer->OnStartup();
-        
-
-        double previous = glfwGetTime();
-        double lag = 0.0;
-        while (!appWindow->WindowShouldClose()) {
-            PollEvents();
-            double now = glfwGetTime();
-            double elapsed = now - previous;
-            previous = now;
-            lag += elapsed;
-            GuiBegin();
-            firstLayer->OnUpdate();
-            firstLayer->OnUI();
-            GuiEnd();
-
-            SwapBuffers();
-        }
-
-        firstLayer->OnDestroy();
-        
-
-    }
-
-
-
-private:
-
-
-    std::vector<Layer*> layers = std::vector<Layer*>();
- 
+  Editor() : Application("Editor") {}
 
+  void Run() override {
+    PushLayer(new EditorLayer());
+    Application::Run();
+  }
 };
 
-YoggieEngine::Application* CreateApplication() {
-   
-    return new Editor();
-
-}
-
-
+YoggieEngine::Application *CreateApplication() { return new Editor(); }

ImGui/premake5.lua

@@ -1,18 +0,0 @@
-project "ImGui"
-  kind "StaticLib"
-
-  includedirs {
-    "../libs/glfw/include",
-    "../libs/ImGui"
-  }
-
-  files {
-    "../libs/ImGui/*.cpp",
-    "../libs/ImGui/backends/imgui_impl_glfw.cpp",
-    "../libs/ImGui/backends/imgui_impl_Opengl3.cpp",
-  }
-
-  libdirs{
-    "../libs/ImGui",
-    "../libs/glad"
-  }

ImGuizmo/premake5.lua

@@ -1,19 +0,0 @@
-project "ImGuizmo"
-  kind "StaticLib"
-
-  includedirs {
-    "../libs/glfw/include",
-    "../libs/ImGui",
-    "../libs/guizmo"
-  }
-
-  files {
-    "../libs/guizmo/*.cpp",
-  }
-
-  libdirs{
-    "../libs/ImGui",
-    "../libs/glad"
-  }
-
-  include("../ImGui")

Runtime/premake5.lua

@@ -1,39 +0,0 @@
-project "Runtime"
-kind "ConsoleApp"
-
-buildmessage "Building the runtime ..."
-
-links{
-  "YoggieEngine"
-}
-
-includedirs{
-  "./../YoggieEngine/src",
-  -- I'd prefer if didn't need these..
-  -- We'll figure that out some time later
-  "./../libs/lua/include",
-  "./../libs/spdlog/include",
-  "./../libs/glm",
-  "./../libs/GorillaAudio/include",
-
-  "./../libs/assimp/include",
-  "./../libs/glad/include",
-  "./../libs/glfw/include",
-  "./../libs/tinygltf",
-  "./../libs/glew/include",
-  "./../libs/glm",
-  "./../libs/ImGui",
-
-
-  "./include"
-
-}
-
-libdirs {
-  './../YoggieEngine/build/Debug'
-}
-
-files { 
-  "./src/*.h",
-  "./src/*.cpp"
-}

Runtime/src/main.cpp

@@ -1,6 +0,0 @@
-#include <iostream>
-
-int main()
-{
-	std::cout << "Welcome to the runtime!" << std::endl;
-}

SandboxApp/CMakeLists.txt

@@ -0,0 +1,6 @@
+file(GLOB SOURCE_FILES "src/*.cpp")
+file(GLOB HEADER_FILES "src/*.h")
+add_executable(SandboxApp ${SOURCE_FILES} ${HEADER_FILES} ) 
+target_link_directories(SandboxApp PRIVATE "../build/YoggieEngine/Debug")
+target_link_libraries(SandboxApp YoggieEngine)
+target_include_directories(SandboxApp PRIVATE "../YoggieEngine/src")

SandboxApp/premake5.lua

@@ -1,40 +0,0 @@
-project "SandboxApp"
-kind "ConsoleApp"
-
-buildmessage "Building SandboxApp ..."
-
-links{
-  "YoggieEngine"
-}
-
-includedirs{
-  "./../YoggieEngine/Include",
-
-  -- I'd prefer if didn't need these..
-  -- We'll figure that out some time later
-  "./../libs/lua/include",
-  "./../libs/spdlog/include",
-  "./../libs/glm",
-  "./../libs/GorillaAudio/include",
-
-  "./../libs/assimp/include",
-  "./../libs/glad/include",
-  "./../libs/glfw/include",
-  "./../libs/tinygltf",
-  "./../libs/glew/include",
-  "./../libs/glm",
-  "./../libs/ImGui",
-  
-  "../libs/entt/src",
-
-
-}
-
-libdirs {
-  './../YoggieEngine/build/Debug'
-}
-
-files { 
-  "./src/*.h",
-  "./src/*.cpp"
-}

SandboxApp/src/GUI.h

@@ -1,11 +1,10 @@
 #pragma once
+#include "YoggieEngine.h"
 #include "imgui.h"
-#include "../../YoggieEngine/src/BarinkEngine.h"
-#include "../../YoggieEngine/src/Graphics/Memory/Framebuffer.h"
 
 void CameraTool();
-void ScriptingTool(char* code);
-///void transformWindow(Transform& transform, std::string PanelName);
-void materialWindow(Material& material, std::string PanelName);
-void SceneExplorer(const std::string& PanelName);
-void SceneView(Framebuffer& framebuffer);
+void ScriptingTool(char *code);
+/// void transformWindow(Transform& transform, std::string PanelName);
+void materialWindow(Material &material, std::string PanelName);
+void SceneExplorer(const std::string &PanelName);
+void SceneView(Framebuffer &framebuffer);

SandboxApp/src/Sandbox.cpp

@@ -1,123 +1,102 @@
-#include <imgui.h>
 #include "GUI.h"
 #include "Util.h"
 #include <entt/entt.hpp>
+#include <imgui.h>
 
-#include "../../YoggieEngine/src/BarinkEngine.h"
-#include "../../YoggieEngine/src/Scene/Components.h"
-#include "../../YoggieEngine/src/Scene/Scene.h"
-#include "../../YoggieEngine/src/Scene/Entity.h"
-#include "../../YoggieEngine/src/AssetManager/ModelImporter.h"
-#include "../../YoggieEngine/src/PerfCounter.h"
-
+#include "YoggieEngine.h"
 
 /*
-* Define globals
-*/
+ * Define globals
+ */
 Scene scene;
 
-BarinkEngine::Renderable* renderable;
-BarinkEngine::SceneObject* object;
+BarinkEngine::Renderable *renderable;
+BarinkEngine::SceneObject *object;
 Entity cube;
 
 /*
-* Runs once at startup 
-* - USe to initialize the game/sandbox/demo
-*/
+ * Runs once at startup
+ * - USe to initialize the game/sandbox/demo
+ */
 void Start() {
-    auto importer = BarinkEngine::ModelImporter();
+  auto importer = BarinkEngine::ModelImporter();
 
-    // Load in asset(S)
-    object = importer.Import("build/Debug/Models/Cube.obj");
-    renderable = object->renderable;
+  // Load in asset(S)
+  object = importer.Import("build/Debug/Models/Cube.obj");
+  renderable = object->renderable;
 
+  // Add Entities to the scene
+  cube = scene.AddEntity("cube");
+  auto &render3DComponent =
+      cube.AddComponent<BarinkEngine::Render3DComponent>();
+  render3DComponent.mesh = *renderable->mesh;
+  cube.GetComponent<BarinkEngine::TransformComponent>().transform =
+      glm::rotate(glm::mat4(1.0f), 32.0f, glm::vec3(0.5f, 1.0f, 0.0f));
 
-    // Add Entities to the scene
-    cube  = scene.AddEntity("cube");
-    auto& render3DComponent = cube.AddComponent<BarinkEngine::Render3DComponent>();
-    render3DComponent.mesh = *renderable->mesh;
-    cube.GetComponent<BarinkEngine::TransformComponent>()
-        .transform = glm::rotate(glm::mat4(1.0f), 32.0f, glm::vec3(0.5f,1.0f,0.0f));
+  // Create a second cube
 
+  auto cube2 = scene.AddEntity("Cube2");
+  auto &cube2Render = cube2.AddComponent<BarinkEngine::Render3DComponent>();
+  cube2Render.mesh = *renderable->mesh;
+  cube2Render.color = glm::vec3(0.0f, 1.0f, 0.0f);
+  auto &cube2Trans = cube2.GetComponent<BarinkEngine::TransformComponent>();
+  cube2Trans.transform =
+      glm::translate(glm::mat4(1.0f), glm::vec3(1.0f, 0.0f, 5.0f));
 
-    // Create a second cube
-   
-    auto cube2 = scene.AddEntity("Cube2");
-    auto& cube2Render = cube2.AddComponent<BarinkEngine::Render3DComponent>();
-    cube2Render.mesh = *renderable->mesh;
-    cube2Render.color = glm::vec3(0.0f, 1.0f, 0.0f);
-    auto& cube2Trans = cube2.GetComponent<BarinkEngine::TransformComponent>();
-    cube2Trans.transform = glm::translate( glm::mat4(1.0f), glm::vec3(1.0f,0.0f, 5.0f));
-
-    // Create a light 
-    auto AmbientLight = scene.AddEntity("AmbientLight");
-    AmbientLight.AddComponent<BarinkEngine::LightComponent>();
-
-    renderer.Prepare(scene);
-
-}
-
-
-/*
-* Runs every frame
-* - Use to draw Immediate mode graphics (Not meant for HUD's )
-*/
-void ImmediateGraphicsDraw() 
-{
-    // Show internal BarinkEngine stats
-    EngineInstrumentation::ShowStats();
-
-    ImGui::Begin("Scene view");
-    auto group = scene.getReg().view<BarinkEngine::IdentifierComponent>();
-    group.each([](auto entity, BarinkEngine::IdentifierComponent& identifier) {
-        
-        ImGui::Text("%s", identifier.name.c_str());
-        
-        });
-    ImGui::End();
-
-    ImGui::ShowMetricsWindow();
-
-    ImGui::Begin("Settings");
-        
-
-        auto& a = cube.GetComponent<BarinkEngine::Render3DComponent>();
-    
-        auto& b = cube.GetComponent<BarinkEngine::TransformComponent>();
-
-        ImGui::DragFloat3("Color", &a.color[0], 0.01f, 0.0f, 1.0f);
-
-        ImGui::DragFloat3("Position", &b.transform[3][0], 0.01f, 0.0f, 16.0f);
-
-        auto l = scene.getReg().view<BarinkEngine::LightComponent>();
-        l.each([](auto entity, BarinkEngine::LightComponent& light) {
-            ImGui::Text("Lighting");
-            ImGui::SliderFloat("Intensity", &light.Strength, 0.0f, 1.0f);
-            ImGui::SliderFloat3("l-Color", &light.Color[0], 0.0f, 1.0f);
-
-        });
-    
-    ImGui::End();
+  // Create a light
+  auto AmbientLight = scene.AddEntity("AmbientLight");
+  AmbientLight.AddComponent<BarinkEngine::LightComponent>();
 
+  renderer.Prepare(scene);
 }
 
 /*
-* Runs every frame
-* - Meant for game logic ( non-physics related) 
-*/
-void Update()
-{
-}
+ * Runs every frame
+ * - Use to draw Immediate mode graphics (Not meant for HUD's )
+ */
+void ImmediateGraphicsDraw() {
+  // Show internal BarinkEngine stats
+  EngineInstrumentation::ShowStats();
 
-void Render() 
-{
-    renderer.Render(scene);
+  ImGui::Begin("Scene view");
+  auto group = scene.getReg().view<BarinkEngine::IdentifierComponent>();
+  group.each([](auto entity, BarinkEngine::IdentifierComponent &identifier) {
+    ImGui::Text("%s", identifier.name.c_str());
+  });
+  ImGui::End();
+
+  ImGui::ShowMetricsWindow();
+
+  ImGui::Begin("Settings");
+
+  auto &a = cube.GetComponent<BarinkEngine::Render3DComponent>();
+
+  auto &b = cube.GetComponent<BarinkEngine::TransformComponent>();
+
+  ImGui::DragFloat3("Color", &a.color[0], 0.01f, 0.0f, 1.0f);
+
+  ImGui::DragFloat3("Position", &b.transform[3][0], 0.01f, 0.0f, 16.0f);
+
+  auto l = scene.getReg().view<BarinkEngine::LightComponent>();
+  l.each([](auto entity, BarinkEngine::LightComponent &light) {
+    ImGui::Text("Lighting");
+    ImGui::SliderFloat("Intensity", &light.Strength, 0.0f, 1.0f);
+    ImGui::SliderFloat3("l-Color", &light.Color[0], 0.0f, 1.0f);
+  });
+
+  ImGui::End();
 }
 
 /*
-* Runs at the end of the program
-* - Meant for cleanup
-*/
-void Stop()
-{
-}
+ * Runs every frame
+ * - Meant for game logic ( non-physics related)
+ */
+void Update() {}
+
+void Render() { renderer.Render(scene); }
+
+/*
+ * Runs at the end of the program
+ * - Meant for cleanup
+ */
+void Stop() {}

SandboxApp/src/Util.h

@@ -1,6 +1,6 @@
 #pragma once
-#include "../../YoggieEngine/src/BarinkEngine.h"
+#include "YoggieEngine.h"
 
-//void PrintSceneTree(Node& node, int depth);
+// void PrintSceneTree(Node& node, int depth);
 
-//glm::mat4 CalculateModelMat(Transform& transform);
+// glm::mat4 CalculateModelMat(Transform& transform);

YoggieEngine/CMakeLists.txt

@@ -0,0 +1,22 @@
+file(GLOB SOURCE_FILES src/*.cpp)
+add_library(YoggieEngine ${SOURCE_FILES} )
+#target_precompile_headers(YoggieEngine PUBLIC src/YoggieEngine.h )
+
+target_link_directories(YoggieEngine PUBLIC  
+    "../libs/physx/physx/bin/win.x86_64.vc142.md/debug" 
+)
+target_link_libraries(YoggieEngine 
+    thirdparty_tools
+    PhysX_64
+    PhysXCooking_64
+    PhysXCommon_64
+    PhysXFoundation_64
+    PhysXPvdSDK_static_64
+    PhysXExtensions_static_64
+)
+
+target_include_directories(YoggieEngine PUBLIC 
+    "../libs/physx/pxshared/include"
+    "../libs/physx/physx/include"
+)
+

YoggieEngine/premake5.lua

@@ -1,87 +0,0 @@
-project "YoggieEngine"
-  kind "StaticLib"
-
-  pchheader "YoggieEngine.h"
-  pchsource "src/YoggieEngine.cpp"
-
-
-  buildmessage "Building Yoggie Engine"
-  disablewarnings{
-    "4099" -- Ignore the missing debug signals for GLFW warning
-    
-  }  
-
-  filter "system:Windows"
-    defines{
-      "GLFW"
-    }
-
-  includedirs {
-    "./src",
-    "../libs/spdlog/include",
-    "../libs/glm",
-
-    "../libs/glfw/include",
-    "../libs/glew/include",
-    "../libs/glad/include",
-
-
-    "../libs/assimp/include",
-    "../libs/entt/src",
-
-    "../libs/physx/pxshared/include",
-    "../libs/physx/physx/include",
-    
-    "../libs/lua/include",
-
-    "../libs/GorillaAudio/include",
-    "../libs/steam-audio/include",
-
-    "../libs/ImGui",
-  }
-
-  links {
-    -- This needs to fall under the filter as the names can differ on different platforms 
-    "phonon",
-    "lua54",
-    "spdlog",
-    "assimp-vc143-mtd",
-    "glfw3",
-    "ImGui",
-
-    "PhysX_64",
-    "PhysXCooking_64",
-    "PhysXCommon_64",
-    "PhysXFoundation_64",
-    "PhysXPvdSDK_static_64",
-    "PhysXExtensions_static_64"
-    
-  }
-
-
-  libdirs {
-    "../libs/steam-audio/lib/windows-x64",
-    "../libs/lua",
-    "../libs/spdlog/build/Release",
-    "../libs/assimp/lib/Debug",
-    "../libs/glfw/build/src/Debug",
-    "../libs/physx/physx/bin/win.x86_64.vc142.md/debug"
-   
-  }
-
-  files {
-
-    "src/**.cpp",
-    "src/**.h"
-  }
-
-  prebuildcommands 
-  {
-    ok,err = os.copyfile("YoggieEngine/src/Graphics/shaders/*" ,"SandboxApp/build/Debug/")
-  }
-
-  postbuildcommands 
-  {
-    ok,err = os.copyfile("YoggieEngine/build/Debug/intermediates/YoggieEngine.pch", "YoggieEngine/build/Debug/YoggieEngine.pch")
-  }
-

YoggieEngine/src/Application.cpp

@@ -4,7 +4,7 @@
 #include <backends/imgui_impl_opengl3.h>
 #include <backends/imgui_impl_glfw.h>
 #include "../../libs/guizmo/ImGuizmo.h"
-
+#include "../../Editor/src/IconsMaterialDesign.h"
 
 namespace YoggieEngine {
 
@@ -23,22 +23,84 @@ namespace YoggieEngine {
 		io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_ViewportsEnable;
 		io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_DockingEnable;
 		io.Fonts->AddFontFromFileTTF("build/Debug/Fonts/Roboto-Regular.ttf", 18);
-
+		ImFontConfig config;
+		config.MergeMode = true;
+		config.GlyphMinAdvanceX = 18.0f;
+		static const ImWchar icon_ranges[] = { ICON_MIN_MD , ICON_MAX_MD, 0 };
+		io.Fonts->AddFontFromFileTTF("build/Debug/Fonts/MaterialIcons-Regular.ttf", 24, &config, icon_ranges);
+		
 		ImGui::StyleColorsDark();
+		/*
+		ImGuiStyle* style = &ImGui::GetStyle();
+		ImVec4* colors = style->Colors;
+
+		colors[ImGuiCol_TitleBg] = ImVec4(0.72f, 0.24f, 0.87f, 1.00f);
+		colors[ImGuiCol_MenuBarBg] = ImVec4(0.72f, 0.24f, 0.87f, 1.00f);
+		colors[ImGuiCol_Tab] = ImVec4(0.53f, 0.09f, 0.67f, 1.00f);
+
+		
+		*/
+		
+
 
 		ImGui_ImplGlfw_InitForOpenGL((GLFWwindow*)appWindow->GetHandle(), true);
 		ImGui_ImplOpenGL3_Init("#version 450");
 
 		ImGuizmo::SetImGuiContext(ImGui::GetCurrentContext());
-		ImGuizmo::SetOrthographic(true);
+		//ImGuizmo::SetOrthographic(true);
 
 
-		init_inputSystem(appWindow);
+		//init_inputSystem(appWindow);
+		glfwSetWindowUserPointer((GLFWwindow*)this->appWindow->GetHandle(), this);
+		glfwSetKeyCallback((GLFWwindow*)this->appWindow->GetHandle(), HandleKey);
+
 	}
 
 
+
+	void Application::HandleKey(GLFWwindow* window, int key, int scancode, int action, int mods) {
+		auto app = (Application*)glfwGetWindowUserPointer(window);
+		for (auto i = app->AppLayerstack.begin(); i < app->AppLayerstack.end(); i++) {
+			if ((*i)->OnKey(key, action)) {
+				break;
+			}
+		}
+	}
+
 	void Application::Run() {
 		
+
+		for (auto i = AppLayerstack.begin(); i < AppLayerstack.end(); i++) {
+			(*i)->OnStartup();
+		}
+		
+		double previous = glfwGetTime();
+		double lag = 0.0;
+
+		while (!appWindow->WindowShouldClose()) {
+			PollEvents();
+			double now = glfwGetTime();
+			double elapsed = now - previous;
+			previous = now;
+			lag += elapsed;
+
+
+			for (auto i = AppLayerstack.begin(); i < AppLayerstack.end(); i++) {
+				(*i)->OnUpdate();
+			}
+
+			GuiBegin();
+			for (auto i = AppLayerstack.begin(); i < AppLayerstack.end(); i++) {
+				(*i)->OnUI();
+			}
+			GuiEnd();
+
+			SwapBuffers();
+		}
+
+		for (auto i = AppLayerstack.begin(); i < AppLayerstack.end(); i++) {
+			(*i)->OnDestroy();
+		}
 	}
 
 

YoggieEngine/src/Application.h

@@ -19,14 +19,19 @@ namespace YoggieEngine {
 		void GuiEnd();
 
 		void PushLayer(Layer* layer);
-
-
-
+		static Application& Get() { return *Application::instance; }
+		static void HandleKey(GLFWwindow* window, int key, int scancode, int action, int mods);
+		static void HandleMouseButton(GLFWwindow* window, int button, int action, int mods);
+		static void HandleScroll(GLFWwindow* window, double xoffset, double yoffset);
 	protected:
 		std::string m_AppName;
 		NativeWindow* appWindow;
 		
 		LayerStack AppLayerstack;
+		Layer* guiLayer;
+		static Application* instance ;
+
+		friend class ImGuiLayer;
 
 	};
 

YoggieEngine/src/Assets/Asset.h

@@ -0,0 +1,22 @@
+#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 Assets.find(handle) != Assets.end();
+}
+
+bool AssetManagerEditor::IsAssetLoaded(AssetHandle handle ) {
+    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,33 @@ namespace uuid::v4
     class UUID
     {
     public:
-        // Factory method for creating UUID object.
-        static UUID New()
+        UUID() {}
+        // I need a better UUID class that will work as a key in std::map 
+        // because this won't properly work
+
+        bool operator() (const UUID& lhs, const UUID& rhs) const {
+            return 1==1;
+        }
+        bool operator< (const UUID& rhs)const {
+            return false;
+        }
+
+        // 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
-            uuid._data[8] = ((uuid._data[8] & 0x3f) | 0x80); // Variant is 10
+            _data[6] = ((_data[6] & 0x0f) | 0x40); // Version 4
+            _data[8] = ((_data[8] & 0x3f) | 0x80); // Variant is 10
 
-            return uuid;
+            
         }
 
         // Returns UUID as formatted string
@@ -54,7 +64,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/Camera.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <glm/gtx/quaternion.hpp>
+
+namespace YoggieEngine {
+	class Camera {
+	public:
+		Camera() {
+			projection = glm::perspective(glm::radians(90.0f), 800.0f / 600.0f, 0.001f, 1000.0f);
+			//projection[3][1] *= -1;
+		}
+
+		glm::mat4 getTransform() const {
+
+			auto transform = glm::translate(glm::mat4(1.0f), Position)
+				* glm::toMat4(glm::quat(Rotation))
+				* glm::scale(glm::mat4(1.0f), glm::vec3(1.0f));
+
+			return glm::inverse(transform);
+		}
+
+		glm::mat4& getProjection(float width, float height) {
+
+			//projection[3][1] *= -1;
+
+			return projection;
+
+		}
+
+		glm::vec3 Position = glm::vec3(0.0f);
+		glm::vec3 Rotation = glm::vec3(0.0f);
+
+
+
+	private:
+		glm::mat4 view;
+		glm::mat4 projection;
+
+
+		
+
+	};
+}

YoggieEngine/src/Graphics/OpenglAPI.cpp

@@ -0,0 +1,60 @@
+#include <YoggieEngine.h>
+#include "OpenglAPI.h"
+namespace YoggieEngine {
+	
+	GLenum glCheckError_(const char* file, int line) {
+		GLenum errorCode;
+		while ((errorCode = glGetError()) != GL_NO_ERROR) {
+			std::string error;
+			switch (errorCode)
+			{
+			case GL_INVALID_ENUM: error = "INVALID_ENUM"; break;
+			case GL_INVALID_VALUE: error = "INVALID_VALUE"; break;
+			case GL_INVALID_OPERATION: error = "INVALID_OPERATION"; break;
+			case GL_STACK_OVERFLOW: error = "STACK_OVERFLOW"; break;
+			case GL_STACK_UNDERFLOW: error = "STACK_UNDERFLOW"; break;
+			case GL_OUT_OF_MEMORY: error = "OUT_OF_MEMORY"; break;
+			case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break;
+			};
+			spdlog::error("{0} | {1} ({2})", error, file, line);
+		}
+		return errorCode;
+	}
+
+#ifdef DEBUG
+#define glCheckError() glCheckError_(__FILE__, __LINE__)
+#else 
+#define glCheckError()
+#endif
+
+	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);
+	}
+
+
+
+	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);
+		glDrawArrays(GL_TRIANGLES, 0, 36);
+		//glCheckError();
+		glBindVertexArray(0);
+		glDepthMask(GL_TRUE);
+
+	}
+
+
+}

YoggieEngine/src/Graphics/OpenglAPI.h

@@ -0,0 +1,9 @@
+#pragma once
+namespace YoggieEngine {
+	class OpenGLApi {
+	public:
+		static void DrawTriangles(Render3DComponent rc);
+
+		static void DrawCubeMap(unsigned int VertexAttributeObject, CubeMap CubeTexture);
+	};
+};

YoggieEngine/src/Graphics/Primitives/Camera.h

@@ -1,16 +0,0 @@
-#pragma once
-namespace YoggieEngine {
-	class Camera {
-	public:
-		Camera() {
-
-		}
-
-		glm::mat4 view;
-		glm::mat4 projection;
-
-
-		
-
-	};
-}

YoggieEngine/src/Graphics/Primitives/Texture.h

@@ -1,14 +0,0 @@
-#pragma once
-namespace YoggieEngine {
-	class Texture {
-	public:
-		Texture() = default;
-		Texture(const std::string texturePath, bool Transparency = false);
-
-		void Bind();
-		void Unbind();
-		const unsigned int GetID() const { return Id; }
-	private:
-		unsigned int Id;
-	};
-}

YoggieEngine/src/Graphics/RenderSurface.h

@@ -1,6 +1,6 @@
 #pragma once
-#include "../Graphics/Memory/Buffer.h"
-#include "../Graphics/Memory/VertexArray.h"
+#include "../Graphics/Buffer.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,9 +2,13 @@
 
 #include "Renderer.h"
 #include "../Scene/Components.h"
-#include "../Graphics/Memory/Buffer.h"
-#include "../Graphics/Memory/VertexArray.h"
-#include "../Graphics/Primitives/DrawCommand.h"
+#include "../Graphics/Buffer.h"
+#include "../Graphics/VertexArray.h"
+#include "Framebuffer.h"
+#include "../Scene/Components.h"
+#include"../Scene/Scene.h"
+#include "Camera.h"
+#include "OpenglAPI.h"
 
 namespace YoggieEngine {
 unsigned int quadVAO = 0;
@@ -65,24 +69,41 @@ float skyboxVertices[]{
 	 1.0f, -1.0f,  1.0f
 };
 
-Renderer::Renderer(RendererConfig& config)
-	: m_framebuffer(Framebuffer(config.ScreenWidth, config.ScreenHeight)),
+
+Renderer::Renderer() :
+	m_framebuffer(800, 600),
 	gBufferShader("build/Debug/Shaders/deferred/geometry.vert", "build/Debug/Shaders/deferred/geometry.frag"),
 	lightingPassShader("build/Debug/Shaders/deferred/lightPass.vert", "build/Debug/Shaders/deferred/lightPass.frag"),
 	SkyboxShader("build/Debug/Shaders/Cubemaps/Skybox.vert", "build/Debug/Shaders/Cubemaps/Skybox.frag"),
 	BlendingShader("build/Debug/Shaders/forward/Blending.vert", "build/Debug/Shaders/forward/Blending.frag"),
 	forwardShader("build/Debug/Shaders/forward/geometry.vert", "build/Debug/Shaders/forward/geometry.frag"),
 	postProcessingShader("build/Debug/Shaders/forward/postprocessing.vert", "build/Debug/Shaders/forward/postprocessing.frag")
-{	
-	width = config.ScreenWidth;
-	height = config.ScreenHeight;
-	
-
+{
+	width = 800;
+	height = 600;
 	glEnable(GL_DEPTH_TEST);
+	CreateGBuffer();
+
+	std::vector<std::string> faces{
+			"build/Debug/skybox/Open_Water/right.jpg",
+			"build/Debug/skybox/Open_Water/left.jpg",
+			"build/Debug/skybox/Open_Water/top.jpg",
+			"build/Debug/skybox/Open_Water/bottom.jpg",
+			"build/Debug/skybox/Open_Water/front.jpg",
+			"build/Debug/skybox/Open_Water/back.jpg"
+	};
+
+	skybox = CubeMap(faces);
+	grassTexture.Load("build/Debug/Texture/grass.png");
+
+}
+
+
+void Renderer::CreateGBuffer() {
 	// Deferred Rendering 
 	glGenFramebuffers(1, &gBuffer);
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
-	
+
 	// - Position Color Buffer ;
 	glGenTextures(1, &gPosition);
 	glBindTexture(GL_TEXTURE_2D, gPosition);
@@ -122,52 +143,139 @@ Renderer::Renderer(RendererConfig& config)
 		spdlog::critical("Framebuffer not complete {}{}", __FILE__, __LINE__);
 	}
 
-	
-
-	std::vector<std::string> faces{
-	"build/Debug/skybox/Open_Water/right.jpg",
-	"build/Debug/skybox/Open_Water/left.jpg",
-	"build/Debug/skybox/Open_Water/top.jpg",
-	"build/Debug/skybox/Open_Water/bottom.jpg",
-	"build/Debug/skybox/Open_Water/front.jpg",
-	"build/Debug/skybox/Open_Water/back.jpg"
-	};
-
-	sky = CubeMap(faces);
-
-	// Create a skybox vao
-	unsigned int VBO;
-	glGenVertexArrays(1, &skyboxVAO);
-	glGenBuffers(1, &VBO);
-	glBindVertexArray(skyboxVAO);
-	glBindBuffer(GL_ARRAY_BUFFER, VBO);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
-
-#ifdef WINDOW 
-	grassTexture = Texture("build/Debug/Texture/blending_transparent_window.png", true);
-#else 
-	grassTexture = Texture("build/Debug/Texture/grass.png", true);
-#endif
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
 }
 
-Renderer::~Renderer(){}
 
-void SubmitVegetationDemo() {
+void Renderer::Render(Scene& scene , Camera MainCamera){
+	int oldviewport[4];
+	glGetIntegerv(GL_VIEWPORT, oldviewport);
+	glViewport(0, 0, width, height);
+
+
+	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
+	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	// Render skybox if the scene has one 
+
+	SkyboxShader.Use();
+	SkyboxShader.setUniformMat4("projection", MainCamera.getProjection(width, height));
+	SkyboxShader.setUniformMat4("view", glm::inverse(glm::mat4(glm::mat3(MainCamera.getTransform()))));
+
+	if (!skyboxVAO) {
+		unsigned int VBO;
+		glGenVertexArrays(1, &skyboxVAO);
+		glGenBuffers(1, &VBO);
+		glBindVertexArray(skyboxVAO);
+		glBindBuffer(GL_ARRAY_BUFFER, VBO);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
+		glEnableVertexAttribArray(0);
+		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
+
+	}
+
+	OpenGLApi::DrawCubeMap(skyboxVAO, skybox);
+
+
+
+
+	auto renderables = scene.getReg().view<TransformComponent, Render3DComponent>();
+	gBufferShader.Use();
+	for (auto renderable : renderables) {
+		auto entity = Entity(renderable, &scene);
+		auto& renderComponent = entity.GetComponent<Render3DComponent>();
+		auto& transform = entity.GetComponent<TransformComponent>();
+
+		// Geometry pass 
+		gBufferShader.setUniformVec3("Color", renderComponent.color);
+		gBufferShader.setUniformMat4("Model", transform.GetTransform());
+		gBufferShader.setUniformMat4("View", glm::inverse(MainCamera.getTransform()));
+		gBufferShader.setUniformMat4("Projection", MainCamera.getProjection(width, height));
+		OpenGLApi::DrawTriangles(renderComponent);
+
+
+	}
+
+	// Light pass
+	glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer.GetId());
+	lightingPassShader.Use();
+	lightingPassShader.setUniformInt("gPosition", 0);
+	lightingPassShader.setUniformInt("gNormal", 1);
+	lightingPassShader.setUniformInt("gColorSpec", 2);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, gPosition);
+
+	glActiveTexture(GL_TEXTURE1);
+	glBindTexture(GL_TEXTURE_2D, gNormal);
+
+	glActiveTexture(GL_TEXTURE2);
+	glBindTexture(GL_TEXTURE_2D, gColorSpec);
+
+	auto lights = scene.getReg().view<LightComponent, TransformComponent>();
+	unsigned int lightnr = 0;
+	for (auto light : lights) {
+		auto lightComponent = Entity(light, &scene).GetComponent<LightComponent>();
+		auto transformComponent = Entity(light, &scene).GetComponent<TransformComponent>();
+
+		auto name = "lights[" + std::to_string(lightnr) + "]";
+		lightingPassShader.setUniformVec3(name + ".Position", transformComponent.Position);
+		lightingPassShader.setUniformVec3(name + ".Color", lightComponent.Color);
+
+		const float linear = 0.7f;
+		const float quadratic = 1.8f;
+		lightingPassShader.setUniformFloat(name + ".Linear", linear);
+		lightingPassShader.setUniformFloat(name + ".Quadratic", quadratic);
+
+		lightnr++;
+
+	}
+
+	if (quadVAO == 0)
+	{
+		float quadVertices[] = {
+			-1.0f,	 1.0f, 0.0f, 0.0f, -1.0f,
+			-1.0f,	-1.0f, 0.0f, 0.0f, 0.0f,
+			 1.0f,	 1.0f, 0.0f, 1.0f, -1.0f,
+			 1.0f,	-1.0f, 0.0f, 1.0f, 0.0f,
+		};
+		unsigned int quadVBO;
+		// setup plane VAO ;
+		glGenVertexArrays(1, &quadVAO);
+		glGenBuffers(1, &quadVBO);
+		glBindVertexArray(quadVAO);
+		glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
+		glEnableVertexAttribArray(0);
+		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
+		glEnableVertexAttribArray(1);
+		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
+	}
+
+	glBindVertexArray(quadVAO);
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	glBindVertexArray(0);
+
+
+	// Copy GBuffer
+	glBindFramebuffer(GL_READ_FRAMEBUFFER, gBuffer);
+	glBindFramebuffer(GL_DRAW_BUFFER, m_framebuffer.GetId());
+	glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
 
 
 	if (transparentVAO == 0) {
+		unsigned int transparentVBO;
 		float transparentVertices[] = {
-			// positions         // texture Coords (swapped y coordinates because texture is flipped upside down)
-			0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
-			0.0f, -0.5f,  0.0f,  0.0f,  1.0f,
-			1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
+			// 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,
 
-			0.0f,  0.5f,  0.0f,  0.0f,  0.0f,
-			1.0f, -0.5f,  0.0f,  1.0f,  1.0f,
-			1.0f,  0.5f,  0.0f,  1.0f,  0.0f
+			0.0f,  0.5f,  0.0f,  0.0f,  1.0f,
+			1.0f, -0.5f,  0.0f,  1.0f,  0.0f,
+			1.0f,  0.5f,  0.0f,  1.0f,  1.0f
 		};
 
 		glGenVertexArrays(1, &transparentVAO);
@@ -183,205 +291,20 @@ void SubmitVegetationDemo() {
 
 	}
 
-
-}
-
-void Renderer::Submit( Render3DComponent& renderComponent, TransformComponent& transform) {
-	if (renderComponent.mesh.elements.empty())
-		return;
-
-	if (renderComponent.VAO == 0 || renderComponent.IBO == 0) 
-	{
-		if (renderComponent.VAO != 0)
-			glDeleteVertexArrays(1, &(renderComponent.VAO));
-		if (renderComponent.IBO != 0)
-			glDeleteBuffers(1, &(renderComponent.IBO));
-
-		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();
-	}
-
-	DrawCommand dc = { renderComponent.isStatic , renderComponent.VAO, renderComponent.mesh.elements.size(), renderComponent.IBO, transform, renderComponent.color };
-	commands.push_back(dc);
-	
-}
-
-void Renderer::GeometryPass() {
-	// 1.0 Geometry pass 
-	gBufferShader.Use();
-
-	for (const DrawCommand& command : commands)
-	{
-		if (command.isDynamic == true)
-			continue;
-
-		glBindVertexArray(command.VAO_identifier);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, command.IBO_identifier);
-
-		gBufferShader.setUniformVec3("Color", command.color);
-		gBufferShader.setUniformMat4("Model", command.transform.LocalTransform);
-		gBufferShader.setUniformMat4("View", MainCamera.view);
-		gBufferShader.setUniformMat4("Projection", MainCamera.projection);
-
-		glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(command.num_elements),
-			GL_UNSIGNED_INT, NULL);
-
-		glBindVertexArray(0);
-	}
-
-
-}
-
-void Renderer::ForwardGeometryPass() 
-{
-	for (const DrawCommand& command : commands)
-	{
-		if (command.isDynamic == false)
-			continue;
-
-		glBindVertexArray(command.VAO_identifier);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, command.IBO_identifier);
-
-		forwardShader.Use();
-
-		forwardShader.setUniformVec3("Color", command.color);
-		forwardShader.setUniformMat4("M", command.transform.LocalTransform);
-		forwardShader.setUniformMat4("V", MainCamera.view);
-		forwardShader.setUniformMat4("P", MainCamera.projection);
-
-		glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(command.num_elements),
-			GL_UNSIGNED_INT, NULL);
-
-		glBindVertexArray(0);
-
-	}
-
-}
-
-void Renderer::SkyboxPass() {
-	// Render skybox 
-	glDepthMask(GL_FALSE);
-	SkyboxShader.Use();
-	SkyboxShader.setUniformMat4("projection", MainCamera.projection);
-	SkyboxShader.setUniformMat4("view", glm::mat4(glm::mat3(MainCamera.view))); // remove rotation from the view matrix
-	glBindVertexArray(skyboxVAO);
-	glBindTexture(GL_TEXTURE_CUBE_MAP, sky.getID());
-	glDrawArrays(GL_TRIANGLES, 0, 36);
-	glBindVertexArray(0);
-	glDepthMask(GL_TRUE);
-	
-}
-
-void Renderer::lightingPass(Scene& scene){
-
-	// 2.0 Lighting Pass
-
-	// configure shader 
-	glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer.GetId());
-
-	lightingPassShader.Use();
-	lightingPassShader.setUniformInt("gPosition", 0);
-	lightingPassShader.setUniformInt("gNormal", 1);
-	lightingPassShader.setUniformInt("gColorSpec", 2);
-
-	// Bind all Gbuffer textures
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, gPosition);
-	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_2D, gNormal);
-	glActiveTexture(GL_TEXTURE2);
-	glBindTexture(GL_TEXTURE_2D, gColorSpec);
-
-	//	send relevant Lighting Uniforms
-	auto lights = scene.getReg().view<LightComponent, TransformComponent>();
-	unsigned int lightnr = 0;
-	lights.each([&](auto entity, LightComponent& light, TransformComponent& transform) {
-		lightingPassShader.setUniformVec3("lights[" + std::to_string(lightnr) + "].Position", transform.Position);
-		lightingPassShader.setUniformVec3("lights[" + std::to_string(lightnr) + "].Color", light.Color);
-
-		// Attenuation
-		const float linear = 0.7f;
-		const float quadratic = 1.8f;
-		lightingPassShader.setUniformFloat("lights[" + std::to_string(lightnr) + "].Linear", linear);
-		lightingPassShader.setUniformFloat("lights[" + std::to_string(lightnr) + "].Quadratic", quadratic);
-
-
-		lightnr++;
-	});
-
-	//lightingPassShader.setUniformVec3("viewPos", MainCamera.Position);
-
-	// render to quad
-	if (quadVAO == 0)
-	{
-		float quadVertices[] = {
-			-1.0f,	 1.0f, 0.0f, 0.0f, 1.0f,
-			-1.0f,	-1.0f, 0.0f, 0.0f, 0.0f,
-			 1.0f,	 1.0f, 0.0f, 1.0f, 1.0f,
-			 1.0f,	-1.0f, 0.0f, 1.0f, 0.0f,
-		};
-		// setup plane VAO ;
-		glGenVertexArrays(1, &quadVAO);
-		glGenBuffers(1, &quadVBO);
-		glBindVertexArray(quadVAO);
-		glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
-		glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), &quadVertices, GL_STATIC_DRAW);
-		glEnableVertexAttribArray(0);
-		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
-		glEnableVertexAttribArray(1);
-		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
-	}
-
-
-	glBindVertexArray(quadVAO);
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	glBindVertexArray(0);
-}
-
-void Renderer::BlendingPass() {
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	// Vegetation / blending test;
 	BlendingShader.Use();
 	glBindVertexArray(transparentVAO);
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, grassTexture.GetID());
 
-	BlendingShader.setUniformMat4("V", MainCamera.view);
-	BlendingShader.setUniformMat4("P", MainCamera.projection);
-
-
+	BlendingShader.setUniformMat4("V", glm::inverse(MainCamera.getTransform()));
+	BlendingShader.setUniformMat4("P", MainCamera.getProjection(width, height));
 	for (unsigned int i = 0; i < vegetation.size(); i++) {
-		auto rotation = glm::rotate(glm::mat4(1.0f), 45.0f, glm::vec3(0.0f, 1.0f, 0.0f));
+
 		auto translation = glm::translate(glm::mat4(1.0f), vegetation[i]);
-		auto transform = translation * rotation;
-		BlendingShader.setUniformMat4("M", transform);
+		BlendingShader.setUniformMat4("M", translation);
 		glDrawArrays(GL_TRIANGLES, 0, 6);
 
 	}
@@ -392,57 +315,19 @@ void Renderer::BlendingPass() {
 
 
 
-}
-
-void Renderer::PostProcessing() 
-{
-	postProcessingShader.Use();
-	postProcessingShader.setUniformInt("screen", 0);
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, m_framebuffer.GetColourAttachment());
 
 
-	glBindVertexArray(quadVAO);
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	glBindVertexArray(0);
-
-	
-}
-
-void Renderer::CopyGBuffer() {
-	glBindFramebuffer(GL_READ_FRAMEBUFFER, gBuffer);
-	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebuffer.GetId());
-	glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-
-	glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer.GetId());
-}
-
-void Renderer::Render(Scene& scene) 
-{	
-	SubmitVegetationDemo();
-	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
-	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-	SkyboxPass();
-
-	GeometryPass();
-
-	lightingPass(scene);
-	
-	CopyGBuffer();
-
-	ForwardGeometryPass();
-
-	BlendingPass();
-
-	//PostProcessing();
-	
-	commands.clear();
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glViewport(oldviewport[0], oldviewport[1], oldviewport[2], oldviewport[3]);
 }
 
+
+Renderer::~Renderer(){}
+
+
+
+
+
 void Renderer::setCurrentFrameBuffer(const Framebuffer& fb)
 {
 	m_framebuffer = fb;

YoggieEngine/src/Graphics/Renderer.h

@@ -2,13 +2,8 @@
 #include "GLFW/glfw3.h"
 #include <vector>
 #include "../PerfCounter.h"
-
-#include "Renderable.h"
-#include "Memory/Framebuffer.h"
-#include "../Scene/Components.h"
-#include"../Scene/Scene.h"
-#include "Graphics/Primitives/DrawCommand.h"
-#include "Primitives/Camera.h"
+#include "../Scene/Scene.h"
+#include "Framebuffer.h"
 
 namespace YoggieEngine {
 
@@ -20,39 +15,36 @@ namespace YoggieEngine {
 
 	class Renderer {
 	public:
-		Renderer(RendererConfig& config);
+		Renderer();
 		~Renderer();
 
 
-		void Submit(Render3DComponent& renderComponent, TransformComponent& transform); // Collects DrawCommands
-		void Render(Scene&);	// Draw to screen (using drawCall structs)
-	
+		// Forward pass
+		/*
+		forwardShader.Use();
+		forwardShader.setUniformVec3("Color", renderComponent.color);
+		forwardShader.setUniformMat4("M", transform.LocalTransform);
+		forwardShader.setUniformMat4("V", MainCamera.view);
+		forwardShader.setUniformMat4("P", MainCamera.projection);
+
+		OpenGLApi::DrawTriangles(renderComponent);
+		*/
+
+		void Render(Scene& scene, Camera MainCamera);
+			
 		void setCurrentFrameBuffer(const Framebuffer& fb);
 		void setClearColor(const glm::vec3& ClearColor);
 
-		void SetMainCamera(const Camera& camera) { MainCamera = camera;  }
 
 		Framebuffer& getCurrentFrameBuffer() { return m_framebuffer; }
-	private:
-		void GeometryPass();
-		void ForwardGeometryPass();
-		void SkyboxPass();
-		void lightingPass(Scene& scene);
-		void BlendingPass();
-		void PostProcessing();
-		void CopyGBuffer();
-
 
 	private:
 		Framebuffer m_framebuffer;
 		int width, height;
 		glm::vec3 m_clearColor;
 		bool m_depthTest;
-		std::vector<DrawCommand> commands;
-		Camera MainCamera;
 
-        unsigned int skyboxVAO = 0;
-		CubeMap sky;
+		void CreateGBuffer();
 
 		Shader forwardShader;
 
@@ -63,8 +55,59 @@ namespace YoggieEngine {
 		Shader SkyboxShader;
 		Shader postProcessingShader;
 
-
 		// blending
 		Shader BlendingShader;
+		CubeMap skybox;
+		Texture grassTexture;
+
+		unsigned int transparentVAO = 0;
+		unsigned int skyboxVAO = 0;
+		unsigned int quadVAO = 0;
+		float skyboxVertices[36*3]{
+			// positions          
+			-1.0f,  1.0f, -1.0f,
+			-1.0f, -1.0f, -1.0f,
+			 1.0f, -1.0f, -1.0f,
+			 1.0f, -1.0f, -1.0f,
+			 1.0f,  1.0f, -1.0f,
+			-1.0f,  1.0f, -1.0f,
+			-1.0f, -1.0f,  1.0f,
+			-1.0f, -1.0f, -1.0f,
+			-1.0f,  1.0f, -1.0f,
+			-1.0f,  1.0f, -1.0f,
+			-1.0f,  1.0f,  1.0f,
+			-1.0f, -1.0f,  1.0f,
+			 1.0f, -1.0f, -1.0f,
+			 1.0f, -1.0f,  1.0f,
+			 1.0f,  1.0f,  1.0f,
+			 1.0f,  1.0f,  1.0f,
+			 1.0f,  1.0f, -1.0f,
+			 1.0f, -1.0f, -1.0f,
+			-1.0f, -1.0f,  1.0f,
+			-1.0f,  1.0f,  1.0f,
+			 1.0f,  1.0f,  1.0f,
+			 1.0f,  1.0f,  1.0f,
+			 1.0f, -1.0f,  1.0f,
+			-1.0f, -1.0f,  1.0f,
+			-1.0f,  1.0f, -1.0f,
+			 1.0f,  1.0f, -1.0f,
+			 1.0f,  1.0f,  1.0f,
+			 1.0f,  1.0f,  1.0f,
+			-1.0f,  1.0f,  1.0f,
+			-1.0f,  1.0f, -1.0f,
+			-1.0f, -1.0f, -1.0f,
+			-1.0f, -1.0f,  1.0f,
+			 1.0f, -1.0f, -1.0f,
+			 1.0f, -1.0f, -1.0f,
+			-1.0f, -1.0f,  1.0f,
+			 1.0f, -1.0f,  1.0f
+		};
+		std::vector<glm::vec3> vegetation = {
+	glm::vec3(-1.5f, 0.0f, -0.48f),
+	glm::vec3(1.5f, 0.0f, 0.51f),
+	glm::vec3(0.0f, 0.0f, 0.7f),
+	glm::vec3(-0.3f, 0.0f, -2.3f)
+		};
+
 	};
 }

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,10 +2,11 @@
 #include "Texture.h"
 
 namespace YoggieEngine {
-	Texture::Texture(const std::string texturePath , bool Transparency) {
-		int width, height, channels;
+
+	void Texture::Load(const std::string texturePath, bool Transparency) {
+		int channels;
 		unsigned char* data = stbi_load(texturePath.c_str(), &width, &height, &channels, 0);
-		
+
 		if (data) {
 			glGenTextures(1, &Id);
 			glBindTexture(GL_TEXTURE_2D, Id);
@@ -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

@@ -0,0 +1,22 @@
+#pragma once
+#include "Assets/Asset.h"
+
+namespace YoggieEngine {
+	class Texture : public Asset {
+	public:
+		Texture() = default;
+		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;
+		int height;
+
+	};
+}

YoggieEngine/src/Layer.h

@@ -1,29 +1,34 @@
 #pragma once
-
+#include <spdlog/spdlog.h>
 class Layer {
 
 public:
 	~Layer() { OnDestroy(); }
 	Layer() { OnCreate(); }
 
-	Layer(const std::string name ) 
-		: Name(name) {}
-
-
 	virtual void OnUpdate(){}
 	virtual void OnUI(){}
+	
+	virtual bool OnKey(int key , int status ) {
+		spdlog::info( "Key {0} , {1}", key, status);
+		return false;
+	}
+	
+	virtual bool OnMouseButton(int button, int action) {
+		return false;
+	}
+
+	virtual bool OnScroll(int xoffset, int yoffset) {
+		return false;
+	}
+	
 	virtual void OnStartup(){}
 
 	virtual void OnAttach() {}
 	virtual void OnDetach() {}
-
-
 	virtual void OnCreate() {}
 	virtual void OnDestroy(){}
 
-private:
-
-	std::string Name;
 
 
 };

YoggieEngine/src/PerfCounter.cpp

@@ -1,72 +1,67 @@
-#include <YoggieEngine.h>
 #include "PerfCounter.h"
+#include <YoggieEngine.h>
 
 namespace YoggieEngine {
-	uint64_t EngineInstrumentation::GetPrecisionTime() {
-		using namespace std::chrono; // REMINDER: This is kinda ugly but safes line width
-		return duration_cast<milliseconds>(high_resolution_clock::now().time_since_epoch()).count();
-	}
-
-	void EngineInstrumentation::PerfomanceSamplerInit() {
-
-		std::cout << "Initialize perf sampler" << std::endl;
-		/*EngineInstrumentation::frames = 0;
-		EngineInstrumentation::lastSampleTime = GetPrecisionTime();*/
-	}
-
-
-
-	void EngineInstrumentation::Update() {
-		
-	/*	uint64_t MilliSecondsPast = GetPrecisionTime() - EngineInstrumentation::lastSampleTime;
-
-			if (MilliSecondsPast >= 1000) {
-
-				EngineInstrumentation::frameTime = (float)1000 / EngineInstrumentation::frames;
-				EngineInstrumentation::FPS = frames;
-				EngineInstrumentation::frames = 0;
-				EngineInstrumentation::lastSampleTime = GetPrecisionTime();
-			}*/
-		
-
-	}
-
-	void EngineInstrumentation::ShowStats() {
-		ImGui::Begin("Statistics", false, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize);
-
-		ImGui::Text("Currently not available");
-/*		ImGui::Text("FPS: %i", ES.FPS);
-		ImGui::Text("Frame Time: %f", ES.frameTime);
-		ImGui::Text("Verts: %i", ES.verts);
-		ImGui::Text("Draw Calls: %i", ES.DC);
-		*/
-		ImGui::End();
-	}
-
-
-	PerfSampler::PerfSampler(const std::string& name)
-		: name(name)
-	{
-		using namespace std::chrono;
-		startTime = high_resolution_clock::now();
-
-	}
-
-	PerfSampler::~PerfSampler()
-	{
-		Stop();
-	}
-
-	void PerfSampler::Stop()
-	{
-		using namespace std::chrono;
-		auto end = high_resolution_clock::now();
-		auto durationInuSeconds =
-			duration_cast<nanoseconds>(end.time_since_epoch()).count() -
-			duration_cast<nanoseconds>(startTime.time_since_epoch()).count();
-
-		auto ms = durationInuSeconds * 0.001f;
-
-		//	std::cout << "[" << name << "]" <<  "Took: " << durationInuSeconds << " us (" << ms << " ms)" << std::endl;
-	}
+uint64_t EngineInstrumentation::GetPrecisionTime() {
+  using namespace std::chrono; // REMINDER: This is kinda ugly but safes line
+                               // width
+  return duration_cast<milliseconds>(
+             high_resolution_clock::now().time_since_epoch())
+      .count();
 }
+
+void EngineInstrumentation::PerfomanceSamplerInit() {
+
+  spdlog::info("Initialize perf sampler");
+  /*EngineInstrumentation::frames = 0;
+  EngineInstrumentation::lastSampleTime = GetPrecisionTime();*/
+}
+
+void EngineInstrumentation::Update() {
+
+  /*	uint64_t MilliSecondsPast = GetPrecisionTime() -
+     EngineInstrumentation::lastSampleTime;
+
+                  if (MilliSecondsPast >= 1000) {
+
+                          EngineInstrumentation::frameTime = (float)1000 /
+     EngineInstrumentation::frames; EngineInstrumentation::FPS = frames;
+                          EngineInstrumentation::frames = 0;
+                          EngineInstrumentation::lastSampleTime =
+     GetPrecisionTime();
+                  }*/
+}
+
+void EngineInstrumentation::ShowStats() {
+  //		ImGui::Begin("Statistics", false, ImGuiWindowFlags_NoCollapse |
+  //ImGuiWindowFlags_NoResize);
+
+  //		ImGui::Text("Currently not available");
+  /*		ImGui::Text("FPS: %i", ES.FPS);
+                  ImGui::Text("Frame Time: %f", ES.frameTime);
+                  ImGui::Text("Verts: %i", ES.verts);
+                  ImGui::Text("Draw Calls: %i", ES.DC);
+                  */
+  //		ImGui::End();
+}
+
+PerfSampler::PerfSampler(const std::string &name) : name(name) {
+  using namespace std::chrono;
+  startTime = high_resolution_clock::now();
+}
+
+PerfSampler::~PerfSampler() { Stop(); }
+
+void PerfSampler::Stop() {
+  using namespace std::chrono;
+  auto end = high_resolution_clock::now();
+  auto durationInuSeconds =
+      duration_cast<nanoseconds>(end.time_since_epoch()).count() -
+      duration_cast<nanoseconds>(startTime.time_since_epoch()).count();
+
+  auto ms = durationInuSeconds * 0.001f;
+
+  //	std::cout << "[" << name << "]" <<  "Took: " << durationInuSeconds << "
+  //us (" << ms << " ms)" << std::endl;
+}
+} // namespace YoggieEngine

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/Platform/glfw/glfwWindow.cpp

@@ -1,6 +1,7 @@
 #include "YoggieEngine.h"
 #include "glfwWindow.h"
-
+#include <chrono>
+#include<GLFW/glfw3.h>
 namespace YoggieEngine {
 
 	void LoadGLExtensions() {
@@ -10,6 +11,11 @@ namespace YoggieEngine {
 		}
 	}
 
+
+	static void error_callback(int error, const char* description) {
+		spdlog::error("{0}", description);
+	}
+
 	glfwWindow::glfwWindow(const int width, const int height, const char* title)
 	: NativeWindow()
 	{
@@ -19,15 +25,20 @@ namespace YoggieEngine {
 		m_fullscreen = false;
 
 
+		glfwSetErrorCallback(error_callback);
+
+		auto start = std::chrono::high_resolution_clock::now();
 		if (!glfwInit()) {
 
 			spdlog::error("Failed to initialise GLFW!");
 			exit(-1);
 		}
+		auto end =  std::chrono::high_resolution_clock::now();
+		auto duration = std::chrono::duration_cast<std::chrono::milliseconds> (end - start);
+		spdlog::info("GLFWInit() call took {0} milliseconds.", duration.count());
 
 		glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE);
 		glfwWindowHint(GLFW_FOCUS_ON_SHOW, GLFW_TRUE);
-
 		if (m_fullscreen) {
 			glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);
 		}
@@ -35,10 +46,7 @@ namespace YoggieEngine {
 		if (!m_resizable) {
 			glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
 		}
-
-		if (!m_vsync) {
-			glfwSwapInterval(0);
-		}
+	
 
 		window = glfwCreateWindow(m_width, m_height, title, NULL, NULL);
 
@@ -49,6 +57,12 @@ namespace YoggieEngine {
 		}
 
 		SetContext();
+	
+
+		if (!m_vsync) {
+			glfwSwapInterval(0);
+		}
+
 		glfwGetFramebufferSize(window, &m_width, &m_height);
 		LoadGLExtensions();
 

YoggieEngine/src/Scene/Components.h

@@ -1,6 +1,9 @@
 #pragma once
 #include "Entity.h"
+
+#include <glm/glm.hpp>
 #include <glm/gtx/quaternion.hpp>
+
 namespace YoggieEngine {
 	struct IdentifierComponent {
 		std::string name;
@@ -8,15 +11,81 @@ namespace YoggieEngine {
 
 
 	struct TransformComponent {
-		glm::vec3 Position = glm::vec3(0.0f);
-		glm::vec3 Rotation = glm::vec3(0.0f);
+		glm::vec3 Position = glm::vec3(0.0f, 0.0f, 0.0f);
+		glm::vec3 Rotation = glm::vec3(0.0f , 0.0f, 0.0f);
 		glm::vec3 Scale = glm::vec3(1.0f);
 		
 		glm::mat4 LocalTransform = glm::mat4(1.0f);
 
 		glm::mat4 GetTransform() const {
 			glm::mat4 rotation = glm::toMat4(glm::quat(Rotation));
-			return glm::translate(glm::mat4(1.0f), Position) * rotation * glm::scale(glm::mat4(1.0f), Scale);
+
+			auto transform = glm::translate(glm::mat4(1.0f), Position)* rotation 
+				* glm::scale(glm::mat4(1.0f), Scale);
+
+			
+
+			return transform;
+		}
+
+		void Decompose(glm::mat4& transformationMatrix) {
+
+			
+
+			auto& a = transformationMatrix[0][0];
+			auto& b = transformationMatrix[1][0];
+			auto& c = transformationMatrix[2][0];
+			auto& d = transformationMatrix[3][0];
+
+			auto& e = transformationMatrix[0][1];
+			auto& f = transformationMatrix[1][1];
+			auto& g = transformationMatrix[2][1];
+			auto& h = transformationMatrix[3][1];
+
+			auto& i = transformationMatrix[0][2];
+			auto& j = transformationMatrix[1][2];
+			auto& k = transformationMatrix[2][2];
+			auto& l = transformationMatrix[3][2];
+
+			Position = glm::vec3(transformationMatrix[3]);
+			
+			// Remove the position from the matrix
+			d = 0;
+			h = 0;
+			l = 0;
+		
+			auto sx = glm::sqrt(a*a + e*e + i*i);
+			auto sy = glm::sqrt(b*b + f*f + j*j);
+			auto sz = glm::sqrt(c*c + g*g + k*k);
+
+			Scale = glm::vec3(sx, sy, sz);
+	
+			// Remove the scale from the matrix;
+			a/= sx;
+			e /= sx;
+			i /= sx;
+
+			b /= sy;
+			f /= sy;
+			j /= sy;
+
+			c /= sz;
+			g /= sz;
+			k /= sz;
+			
+
+			auto w = glm::sqrt(1 + transformationMatrix[0][0] + transformationMatrix[1][1] + transformationMatrix[2][2]) / 2;
+
+
+			auto x = (transformationMatrix[2][1] - transformationMatrix[1][2]) / (4 * w);
+			auto y = (transformationMatrix[0][2] - transformationMatrix[2][0]) / (4 * w);
+			auto z = (transformationMatrix[1][0] - transformationMatrix[0][1]) / (4 * w);
+
+
+			auto rot = glm::quat(w, x, y, z);
+			Rotation = glm::eulerAngles(rot);
+
+
 		}
 
 
@@ -65,7 +134,6 @@ namespace YoggieEngine {
 
 
 	struct Render3DComponent {
-		Renderable* renderable;
 
 		unsigned int VAO = 0;
 		unsigned int IBO = 0;

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>
@@ -6,7 +7,7 @@
 
 void WriteFile(std::string& emitter, std::filesystem::path path)
 {
-	std::cout << "Writing Scene file to: " << path.u8string() << std::endl;
+	spdlog::info( "Writing Scene file to: {0}" , path.u8string());
 	std::ofstream sceneFile;
 	sceneFile.open(path.u8string());
 

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