Editor Refactor

This refactor of the editor code makes the code more maintainable.

All widget objects have now moved away from RAII and are now just allocated object that live for the entirety of the applications lifetime.
This feels better as I am used to this style plus constantly pushing and popping objects from the stack seems a little wasteful (although I as of right now have no way to prove that it is ).

.gitattributes

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

.gitignore

@@ -1,12 +1,11 @@
-build/
-intermediates/
+**/build/
+**/intermediates/
 tools/
 *.make
 Makefile
 .vscode/
 libs/lua
 libs/glad
-Debug/
 *.sln
 *.vcxproj
 *.vcxproj.filters

.gitmodules

@@ -4,12 +4,10 @@
 [submodule "glm"]
 	path = libs/glm
 	url = https://github.com/nigelbarink/glm.git
+	ignore = untracked
 [submodule "spdlog"]
 	path = libs/spdlog
 	url = https://github.com/nigelbarink/spdlog.git
-[submodule "tinygltf"]
-	path = libs/tinygltf
-	url = https://github.com/syoyo/tinygltf.git
 [submodule "GorrillaAudio"]
 	path = libs/GorillaAudio
 	url = https://github.com/mewspring/gorilla-audio.git
@@ -22,6 +20,19 @@
 [submodule "libs/steam-audio"]
 	path = libs/steam-audio
 	url = https://github.com/ValveSoftware/steam-audio.git
+	ignore = untracked
 [submodule "libs/physx"]
 	path = libs/physx
 	url = https://git.barink.dev/Nigel/PhysX.git
+[submodule "libs/entt"]
+	path = libs/entt
+	url = https://github.com/skypjack/entt.git
+[submodule "libs/guizmo"]
+	path = libs/guizmo
+	url = https://github.com/CedricGuillemet/ImGuizmo.git
+[submodule "libs/yaml-cpp"]
+	path = libs/yaml-cpp
+	url = https://git.barink.dev/Nigel/yaml-cpp.git
+[submodule "libs/nativefiledialog"]
+	path = libs/nativefiledialog
+	url = https://git.barink.dev/Nigel/nativefiledialog.git

.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "cmake.configureOnOpen": true,
-    "files.associations": {
-        "iosfwd": "cpp"
-    }
-}

BarinkEngine/BarinkEngine.cpp

@@ -1,82 +0,0 @@
-#include "BarinkEngine.h"
-
-EngineStatistics* ES;
-BarinkEngine::InputManager InputSystem;
-
-int main(int argc, char* argv[]) {
-	// Setup performance sampler 
-	PerfomanceSamplerInit();
-
-
-	// Create the window 
-	BarinkWindow MainWindow = BarinkWindow(800, 600);
-
-	// =================================================
-	// Startup services 
-	// =================================================
-
-	// Startup Renderer
-	BarinkEngine::Renderer renderer = BarinkEngine::Renderer();
-	
-
-	// Startup InputManager
-	InputSystem = BarinkEngine::InputManager();
-
-	InputSystem.attach(&MainWindow);
-	InputSystem.setupGLFWInput(MainWindow.windowptr());
-
-
-
-	// Startup GUI System
-	GUIManager GUISystem = GUIManager(&MainWindow);
-
-
-
-
-	// Enable depth testing 
-	// NOTE: TODO Move this into the renderer
-	glEnable(GL_DEPTH_TEST);
-
-
-
-	// First call to setup game
-	Start();
-
-
-	
-	// Runtime loop
-	while (!MainWindow.WindowShouldClose()) {
-
-		SamplePerformance();
-
-
-		// Execute main logic 
-		InputSystem.PollEvents();
-		
-		Update();
-
-		renderer.Render();
-
-		ImmediateGraphicsDraw();
-
-		GUISystem.Render();
-		
-
-
-		MainWindow.SwapBuffers();
-	}
-
-
-	// Shutdown game
-	Stop();
-
-
-	// Shutdown Services
-	delete ES;
-	InputSystem.detach(&MainWindow);
-	
-
-
-	return 0;
-}
-

BarinkEngine/EventSystem/EventEmitter.cpp

@@ -1,25 +0,0 @@
-#include "../Include/EventSystem/EventEmitter.h"
-
-
-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*>{};
-}

BarinkEngine/Include/AssetManager/ModelImporter.h

@@ -1,23 +0,0 @@
-#pragma once
-#define TINYGLTF_IMPLEMENTATION
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#define TINYGLTF_NO_EXTERNAL_IMAGE
-
-#include "Graphics/Mesh.h"
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h> 
-#include <string>
-
-class ModelImporter {
-
-public:
-	static std::vector<BarinkEngine::Mesh>  Import(std::string path);
-
-	
-private:
-	static BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene);
-	static std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene);
-
-};

BarinkEngine/Include/BarinkEngine.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "glm/glm.hpp"
-#include "graphics/Shader.h"
-#include "graphics/Window.h"
-#include "graphics/Texture.h"
-#include "graphics/Camera.h"
-#include "graphics/Renderable.h"
-#include "Graphics/Material.h"
-
-#include "spdlog/spdlog.h"
-
-#include "Input/InputManager.h"
-#include "Graphics/Renderer.h"
-#include "Graphics/GUI/GUIManager.h"
-#include "Scene.h"
-
-
-#include "PerfCounter.h"
-
-
-extern void Start();
-extern void Update();
-extern void ImmediateGraphicsDraw();
-extern void Stop();
-
-extern BarinkEngine::InputManager InputSystem;

BarinkEngine/Include/Editor/EditorWindow.h

@@ -1,12 +0,0 @@
-#pragma once
-#include <string>
-
-class EditorWindow {
-protected:
-	std::string WindowTitle;
-
-public:
-
-	virtual void Show() = 0;
-
-};

BarinkEngine/Include/EventSystem/Event.h

@@ -1,9 +0,0 @@
-#pragma once 
-#include <string> 
-
-struct Event
-{
-  public:
-    std::string name;
-    
-};

BarinkEngine/Include/EventSystem/EventEmitter.h

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

BarinkEngine/Include/EventSystem/EventListener.cpp

@@ -1,5 +0,0 @@
-#include "EventListener.h"
-
-void EventListener::ReceiveEvent(Event& incident)
-{
-}

BarinkEngine/Include/EventSystem/EventListener.h

@@ -1,8 +0,0 @@
-#pragma once 
-#include "Event.h"
-#include <list>
-class EventListener{
-  public: 
-    virtual void ReceiveEvent(Event& incident);
-
-};

BarinkEngine/Include/EventSystem/InputSystemEvents.h

@@ -1,18 +0,0 @@
-#pragma once
-#include "Event.h"
-
-
-struct KEY_DOWN_EVENT : public Event {
-public:
-	int scancode;
-	int keycode;
-	int mods;
-};
-
-struct KEY_UP_EVENT : public Event {
-public:
-	int scancode;
-	int keycode;
-	int mods;
-
-};

BarinkEngine/Include/Graphics/Buffer.h

@@ -1,19 +0,0 @@
-#pragma once
-#include <glad/glad.h>
-class Buffer {
-private:
-	unsigned int id;
-public:
-
-	int getBufferID();
-
-	void createBuffer();
-
-	void setBufferData(void* data, size_t dataSize, bool elementBuffer );
-
-	void Bind(bool elementBuffer);
-	void Unbind(bool elementBuffer);
-
-	void Delete();
-
-};

BarinkEngine/Include/Graphics/Camera.h

@@ -1,22 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-
-class Camera {
-public:
-	glm::vec3 Position;
-	glm::vec3 Rotation;
-	float Zoom;
-
-	Camera(glm::vec3 position, glm::vec3 rotation, float zoom );
-	~Camera();
-
-	glm::mat4 GetViewMatrix();
-
-
-private:
-	glm::vec3 Front;  
-	glm::vec3 Right;
-	glm::vec3 Up;
-
-};

BarinkEngine/Include/Graphics/GUI/GUIManager.h

@@ -1,15 +0,0 @@
-#pragma once
-#include "Graphics/Window.h"
-
-
-class GUIManager {
-public:
-	GUIManager(BarinkWindow* window);
-	~GUIManager();
-
-	void Render();
-
-
-private:
-	BarinkWindow* currentwindow;
-};

BarinkEngine/Include/Graphics/Material.h

@@ -1,19 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include <string>
-#include "Shader.h"
-
-class Material {
-public:
-	Material(const Shader& shader);
-	
-	void Apply();
-	
-	glm::vec3 Color;
-
-
-private:
-	const Shader& shader;
-	
-
-};

BarinkEngine/Include/Graphics/Mesh.h

@@ -1,20 +0,0 @@
-#pragma once
-#include <vector>
-#include <glm/glm.hpp>
-
-namespace BarinkEngine{
-
-
-	struct Vertex {
-		glm::vec3 vertices;
-		glm::vec2 uv;
-	};
-
-	class Mesh {
-	public:
-		std::vector<Vertex> vertices;
-		std::vector<unsigned int > elements;
-	
-	};
-
-}

BarinkEngine/Include/Graphics/RenderSurface.h

@@ -1,30 +0,0 @@
-#pragma once
-#include "BarinkEngine.h"
-#include <vector>;
-class RenderSurface 
-{
-public:
-	RenderSurface();
-	~RenderSurface();
-
-	void Draw();
-
-private:
-	// would normally be a material
-	// however rendersurface is special and
-	// thus does not contain a material
-	Shader* shader;
-
-	// Basically a mesh
-	std::vector<glm::vec3> verts;
-	std::vector<unsigned int > indices;
-
-
-	Buffer vertexBuffer;
-	Buffer elementBuffer;
-
-	VertexArray VAO;
-
-
-
-};

BarinkEngine/Include/Graphics/Renderable.h

@@ -1,37 +0,0 @@
-#pragma once
-#include <vector>
-#include "Mesh.h"
-#include "Buffer.h"
-#include "Material.h"
-#include "Texture.h"
-#include "VertexArray.h"
-#include "Scene.h"
-
-
-class Renderable  : public SceneNode {
-public:
-	/*
-	* NOTE: Should combine into a Mesh!!
-	*/
-	Buffer vertexBuffer;
-	Buffer elementBuffer;
-	//Buffer uv;
-	VertexArray VAO;
-
-
-	GLuint UV_id;
-	Material* material;
-	Texture* texture;
-
-	
-	Shader* shader;
-
-	~Renderable();
-
-	static Renderable* Load(std::string& path);
-	void Draw();
-
-private:
-	std::vector<BarinkEngine::Mesh> meshes;
-	Renderable(std::string& path);
-};

BarinkEngine/Include/Graphics/Renderer.h

@@ -1,21 +0,0 @@
-#pragma once
-#include "Graphics/Renderable.h"
-
-#include <vector>
-
-namespace BarinkEngine {
-
-	class Renderer {
-	public:
-		Renderer();
-		~Renderer();
-
-		void Render();
-
-		void Submit(Renderable* model);
-
-	private:
-		std::vector<Renderable*> models;
-
-	};
-}

BarinkEngine/Include/Graphics/Shader.h

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <glad/glad.h>
-#include <string>
-#include <iostream>
-#include <fstream>
-#include <glm/glm.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-
-class Shader {
-    private:
-        
-        char* readFile (const char* filePath);
-    public:
-        Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath);
-        void Use();
-        void setUniformMat4(std::string uniformName, glm::mat4 matrix4)const;
-        void setUniformVec4(std::string uniformName, glm::vec4 vector4)const;
-        void setUniformVec3(std::string uniformName, glm::vec3 vector3)const;
-        void setUniformVec2(std::string uniformName, glm::vec2 vector2)const;
-        void setUniformFloat(std::string uniformName, float value)const;
-        void setUniformInt(std::string uniformName, int value) const ;
-
-        int id;
-
-};

BarinkEngine/Include/Graphics/Texture.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <spdlog/spdlog.h>
-#include <string>
-
-
-class Texture {
-public:
-	Texture(const std::string texturePath);
-	
-	void Bind();
-	void Unbind();
-
-
-private:
-
-	unsigned int Id;
-
-};

BarinkEngine/Include/Graphics/VertexArray.h

@@ -1,18 +0,0 @@
-#pragma once 
-
-class VertexArray{
-private:
-unsigned int id;
-
-
-public:
-void Create();
-void Bind();
-void Unbind();
-
-void Delete();
-
-void AttachAttribute(unsigned int index, int size, int stride);
-
-
-};

BarinkEngine/Include/Graphics/Window.h

@@ -1,37 +0,0 @@
-#pragma once 
-#define GLFW_STATIC
-
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
-#include "../Include/EventSystem/EventListener.h"
-
-
-
-
-
-class BarinkWindow : EventListener {
-    private:
-        GLFWwindow* window;
-        bool FullScreen;
-        bool VulkanSupported;
-        int Width, Height;
-
-        static bool InitGLFW();
-
-
-
-
-    public:
-        BarinkWindow(const int width, const int height);
-        ~BarinkWindow();
-
-        GLFWwindow* windowptr();
-
-        void ReceiveEvent(Event& incident) override;
-        bool WindowShouldClose();
-
-        void Poll();
-        void SwapBuffers();
-
-
-};

BarinkEngine/Include/Input/GLFWInput.h

@@ -1,14 +0,0 @@
-#pragma once
-#include "GLFW/glfw3.h"
-
-namespace BarinkEngine {
-	namespace Input {
-
-		void BE_GLFW_KEYS(GLFWwindow* window, int key, int scancode, int action, int mods);
-		void BE_GLFW_CURSOR_POSITION(GLFWwindow* window, double x, double y);
-		void BE_GLFW_CURSOR_ENTER(GLFWwindow* window, int entered);
-		void BE_GLFW_MOUSE_BUTTON(GLFWwindow* window, int button, int action, int mods);
-		void BE_GLFW_SCROLL(GLFWwindow* window, double xoffset, double yoffset);
-
-	}
-}

BarinkEngine/Include/Input/InputManager.h

@@ -1,29 +0,0 @@
-#pragma once
-#include <list>
-
-#include "Graphics/Window.h"
-#include "EventSystem/EventEmitter.h"
-#include "../Include/Input/GLFWInput.h"
-#include "BarinkEngine.h"
-
-namespace BarinkEngine {
-
-	class InputManager : public EventEmitter {
-	public:
-		InputManager();
-
-		void PollEvents();
-		
-		void attach(BarinkWindow* window);
-		void detach(BarinkWindow* window);
-
-
-		void setupGLFWInput(GLFWwindow* window);
-
-
-	
-	private:
-		std::list<BarinkWindow*> windows;
-
-	};
-}

BarinkEngine/Include/PerfCounter.h

@@ -1,50 +0,0 @@
-#pragma once
-#include <chrono>
-#include <imgui.h>
-
- struct EngineStatistics {
-	uint32_t lastSampleTime;
-	float frameTime;
-	uint32_t verts;
-	uint32_t DC;
-
-	uint64_t frames;
-	uint64_t  FPS;
-};
-extern EngineStatistics* ES;
-
-inline void PerfomanceSamplerInit(){
-	ES = new EngineStatistics();
-	ES->frames = 0;
-	ES->lastSampleTime = 0;
-	ES->lastSampleTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
-
-}
-
-inline void SamplePerformance(void) {
-	ES->frames++; 
-	ES->DC = 0; 
-	ES->verts = 0; 
-	unsigned int  now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); 
-	unsigned int MilliSecondsPast = now - ES->lastSampleTime; 
-	if (MilliSecondsPast >= 1000) {
-			
-			ES->frameTime = (float)1000 / ES->frames; 
-			ES->FPS = ES->frames; 
-			ES->frames = 0; 
-			ES->lastSampleTime = now; 
-	}
-}
-
-
-
-inline void ShowStats() {
-	ImGui::Begin("Statistics", false, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove);
-
-	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();
-
-}

BarinkEngine/Include/Scene.h

@@ -1,47 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-#include "glm/glm.hpp"
-
-/*
-*	Scene should be a description of a game world 
-*/
-
-struct Transform {
-	glm::vec3 Position;
-	glm::vec3 Rotation;
-	glm::vec3 Scale;
-
-	glm::mat4 ModelMatrix;
-};
-
-
-class SceneNode {
-public: 
-	std::string name;
-	Transform transform;
-	SceneNode* parent;
-	std::vector<SceneNode*> children;
-
-
-	void addChild(SceneNode& node);
-
-};
-
-
-class Scene {
-
-public:
-	SceneNode& GetSceneNode(std::string);
-	SceneNode& GetRoot();
-
-	Scene(std::string SceneName = "Default Scene");
-	~Scene();
-
-
-private:
-	SceneNode* root;
-		
-};
-

BarinkEngine/Include/Scripting/LuaScript.h

@@ -1,28 +0,0 @@
-#pragma once
-#include <string>
-
-extern "C"
-{
-	#include "lauxlib.h"
-	#include "lua.h"
-	#include "lualib.h"
-}
-
-
-#include "LuaScriptingManager.h"
-
-
-/*
-class LuaScript {
-public:
-
-	LuaScript(const std::string&);
-	void execute(lua_State& l);
-
-private:
-	std::string filePath;
-
-};
-
-
-*/

BarinkEngine/Include/Scripting/LuaScriptingManager.h

@@ -1,28 +0,0 @@
-#pragma once
-#include <vector>
-
-extern "C"
-{
-	#include "lauxlib.h"
-	#include "lua.h"
-	#include "lualib.h"
-}
-
-
-#include "LuaScript.h"
-
-/*
-class LuaScriptingManager 
-{
-public:
-	std::vector<LuaScript*> scripts;
-
-	LuaScriptingManager();
-
-	void ExecuteLuaString(const std::string&);
-
-private:
-	lua_State* L;
-
-	lua_State& getState();
-};*/

BarinkEngine/Input/GLFWInput.cpp

@@ -1,104 +0,0 @@
-#include "BarinkEngine.h"
-#include "../Include/Input/GLFWInput.h"
-#include "../Include/EventSystem/InputSystemEvents.h"
-#include "../Include/Input/InputManager.h"
-
-
-namespace BarinkEngine {
-	namespace Input {
-
-
-		void BE_GLFW_KEYS(GLFWwindow* window, int key, int scancode, int action, int mods)
-		{
-
-			switch (action)
-			{
-			case GLFW_KEY_DOWN: {
-				KEY_DOWN_EVENT keydown{};
-				keydown.name = "KEY::DOWN";
-				keydown.mods = mods;
-				keydown.scancode = scancode;
-				keydown.keycode = key;
-
-				InputSystem.EmitEvent(keydown);
-				break;
-
-			}
-				
-			case GLFW_KEY_UP: {
-				KEY_UP_EVENT keyup{};
-				keyup.name = "KEY::DOWN";
-				keyup.mods = mods;
-				keyup.scancode = scancode;
-				keyup.keycode = key;
-
-				InputSystem.EmitEvent(keyup);
-				break;
-
-			}
-				
-
-
-			default:
-				Event KeyEvent{};
-				KeyEvent.name = "KEY";
-
-				InputSystem.EmitEvent(KeyEvent);
-
-				break;
-			}
-
-			
-		}
-
-		void BE_GLFW_CURSOR_POSITION(GLFWwindow* window, double x, double y) 
-		{
-			Event CursorPosUpdate{};
-			CursorPosUpdate.name = "UPDATE::CURSOR:POSITION";
-
-			InputSystem.EmitEvent(CursorPosUpdate);
-
-
-		}
-
-		void BE_GLFW_CURSOR_ENTER(GLFWwindow* window, int entered) 
-		{
-			if (entered) {
-				Event mouseEntered{};
-				mouseEntered.name = "Mouse Entered Window's confines!";
-
-				InputSystem.EmitEvent(mouseEntered);
-
-
-
-			}
-			else {
-				Event mouseLeft{};
-				mouseLeft.name = "Mouse Left Window's confines!";
-
-				InputSystem.EmitEvent(mouseLeft);
-
-
-			}
-		}
-
-
-		void BE_GLFW_MOUSE_BUTTON(GLFWwindow* window, int button, int action, int mods) 
-		{
-			Event MouseButtonEvent{};
-			MouseButtonEvent.name = "MOUSEBUTTON";
-
-			InputSystem.EmitEvent(MouseButtonEvent);
-		}
-
-
-		void BE_GLFW_SCROLL(GLFWwindow* window, double xoffset, double yoffset) 
-		{
-			Event ScrollEvent{};
-			ScrollEvent.name = "SCROLL";
-
-			InputSystem.EmitEvent(ScrollEvent);
-
-		}
-	}
-}

BarinkEngine/Input/InputManager.cpp

@@ -1,44 +0,0 @@
-#include "Input/InputManager.h"
-
-namespace BarinkEngine {
-
-	void InputManager::PollEvents()
-	{
-		for (auto it = windows.begin(); it != windows.end(); ++it) {
-			(*it)->Poll();
-		}
-	}
-
-
-	void InputManager::setupGLFWInput(GLFWwindow* window) {
-		// Attach callbacks
-		glfwSetKeyCallback(window, BarinkEngine::Input::BE_GLFW_KEYS);
-		glfwSetCursorPosCallback(window, BarinkEngine::Input::BE_GLFW_CURSOR_POSITION);
-		glfwSetCursorEnterCallback(window, BarinkEngine::Input::BE_GLFW_CURSOR_ENTER);
-		glfwSetMouseButtonCallback(window, BarinkEngine::Input::BE_GLFW_MOUSE_BUTTON);
-		glfwSetScrollCallback(window, BarinkEngine::Input::BE_GLFW_SCROLL);
-	}
-
-
-	void InputManager::attach(BarinkWindow* window)
-	{
-		windows.push_back(window);
-		this->Subscribe((EventListener&)(*window));
-
-	}
-
-	void InputManager::detach(BarinkWindow* window)
-	{
-		windows.remove(window);
-		this->Unsubscribe((EventListener&)*window);
-	}
-
-
-	InputManager::InputManager() : EventEmitter()
-	{
-		windows = std::list<BarinkWindow*>();
-	}
-
-
-}
-

BarinkEngine/Scene.cpp

@@ -1,52 +0,0 @@
-#include "Scene.h"
-
-
-SceneNode* SearchInChildren(SceneNode* root, std::string name ) {
-	
-	if (root->name == name)
-		return root;
-
-	SceneNode* found = nullptr;
-	for (auto child : root->children) {
-		found = SearchInChildren(child, name);
-	}
-	return found;
-}
-
-
-SceneNode& Scene::GetSceneNode(std::string name)
-{
-	return *SearchInChildren(root, name);
-}
-
-
-
-SceneNode& Scene::GetRoot()
-{
-	return *root;
-}
-
-Scene::Scene(std::string sceneName)
-{
-	// Create a root node
-	root = new SceneNode();
-	root->name = sceneName;
-	root->transform = Transform();
-
-	root->transform.Position	= glm::vec3(0);
-	root->transform.Rotation	= glm::vec3(0);
-	root->transform.Scale		= glm::vec3(0);
-
-	root->transform.ModelMatrix = glm::mat4(0);
-
-}
-
-Scene::~Scene()
-{	
-	// Destruct scene!
-}
-
-void SceneNode::addChild(SceneNode& node)
-{
-	children.push_back(&node);
-}

BarinkEngine/Scripting/LuaScript.cpp

@@ -1,11 +0,0 @@
-#include "Scripting/LuaScript.h"
-/*
-LuaScript::LuaScript(const std::string& path)
-: filePath(path) {
-}
-
-void LuaScript::execute(lua_State& l)
-{
-	luaL_dofile(&l, filePath.c_str());
-}
-*/

BarinkEngine/Scripting/LuaScriptingManager.cpp

@@ -1,18 +0,0 @@
-#include "Scripting/LuaScriptingManager.h"
-/*
-LuaScriptingManager::LuaScriptingManager()
-{
-	L = luaL_newstate();
-	luaL_openlibs(L);
-}
-
-
-void LuaScriptingManager::ExecuteLuaString(const std::string& code) {
-	luaL_dostring(L, code.c_str());
-}
-
-lua_State& LuaScriptingManager::getState()
-{
-	return (*L);
-}
-*/

BarinkEngine/graphics/Buffer.cpp

@@ -1,47 +0,0 @@
-#include "Graphics/Buffer.h"
-
-
-int Buffer::getBufferID() {
-	return id;
-}
-
-void Buffer::createBuffer() {
-	glGenBuffers(1, (GLuint*) &id);
-}
-
-void Buffer::setBufferData(void* data, size_t dataSize, bool elementBuffer = false ) {
-	
-	if (elementBuffer) {
-		glBufferData(GL_ELEMENT_ARRAY_BUFFER, dataSize, data, GL_STATIC_DRAW);
-
-	}
-	else {
-		glBufferData(GL_ARRAY_BUFFER, dataSize, data, GL_STATIC_DRAW);
-	}
-
-}
-
-void Buffer::Bind(bool elementBuffer = false ) {
-	if (elementBuffer) {
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
-
-	}
-	else {
-		glBindBuffer(GL_ARRAY_BUFFER, id);
-
-	}
-}
-
-void Buffer::Unbind(bool elementBuffer = false) {
-	if (elementBuffer) {
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-	}
-	else {
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	}
-}
-
-void Buffer::Delete() {
-	glDeleteBuffers(1, (GLuint*) &id);
-}

BarinkEngine/graphics/Camera.cpp

@@ -1,22 +0,0 @@
-#include "Graphics/Camera.h"
-
-Camera::Camera(glm::vec3 position, glm::vec3 rotation, float zoom)
-: Position(position), Rotation(rotation), Zoom(zoom) {
-	
-	Front = glm::vec3(-1.0f, 0.0f, 0.0f);
-	Right = glm::vec3(0.0f, 0.0f, 1.0f);
-	Up = glm::vec3(0.0f, 1.0f, 0.0f);
-
-}
-
-Camera::~Camera() {
-
-}
-
-glm::mat4 Camera::GetViewMatrix() {
-	return glm::lookAt(
-		Position,
-		Position + Front,
-		Up
-	);
-}

BarinkEngine/graphics/GUI/GUIManager.cpp

@@ -1,38 +0,0 @@
-#include "Graphics/GUI/GUIManager.h"
-#include "imgui.h"
-#include "backends/imgui_impl_opengl3.h"
-#include <backends/imgui_impl_glfw.cpp>
-
-GUIManager::GUIManager(BarinkWindow* window) 
-	: currentwindow(window)
-{
-    IMGUI_CHECKVERSION();
-    ImGui::CreateContext();
-    ImGuiIO& io = ImGui::GetIO();
-    (void)io;
-
-    ImGui::StyleColorsDark();
-    ImGui_ImplGlfw_InitForOpenGL(currentwindow->windowptr(), true);
-    ImGui_ImplOpenGL3_Init("#version 440");
-
-
-    ImGui_ImplGlfw_NewFrame();
-    ImGui_ImplOpenGL3_NewFrame();
-
-}
-
-GUIManager::~GUIManager()
-{
-    ImGui_ImplOpenGL3_Shutdown();
-    ImGui_ImplGlfw_Shutdown();
-    ImGui::DestroyContext();
-}
-
-
-void GUIManager::Render()
-{
-   
-
-    ImGui::Render();
-    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-}

BarinkEngine/graphics/Material.cpp

@@ -1,10 +0,0 @@
-#include "../Include/Graphics/Material.h"
-
-Material::Material(const Shader& shader) :
-shader(shader) {
-}
-
-
-void Material::Apply() {
-	shader.setUniformVec3("Color", Color);
-}

BarinkEngine/graphics/ModelImporter.cpp

@@ -1,80 +0,0 @@
-#include "AssetManager/ModelImporter.h"
-
-
-std::vector<BarinkEngine::Mesh> ModelImporter::Import(std::string path)
-{
-    Assimp::Importer importer;
-    const aiScene* scene = importer.ReadFile(path.c_str(), aiProcess_Triangulate | aiProcess_FlipUVs);
-    aiNode* currentNode = scene->mRootNode;
-
-    return processNode(currentNode, scene);
-}
-
-std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene) {
-    std::vector<BarinkEngine::Mesh> meshes;
-    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;
-}
-
-BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
-    std::vector<unsigned int> indices;
-    std::vector<BarinkEngine::Vertex> vertices;
-
-    // Process vertices
-    for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
-        BarinkEngine::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;
-
-        }
-    
-        vertices.push_back(v);
-    }
-
-    // Process 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++) {
-            indices.push_back(face.mIndices[j]);
-        }
-    }
-
-    
-
-    BarinkEngine::Mesh result;
-    
-
-    result.vertices = vertices;
-    result.elements = indices;
-
-
-    return result;
-
-}

BarinkEngine/graphics/RenderSurface.cpp

@@ -1,46 +0,0 @@
-#include "Graphics/RenderSurface.h";
-
-RenderSurface::RenderSurface(){
-	shader = new Shader("build/SandboxAppliction/Debug/renderSuface.vs", "build/SandboxApplication/Debug/renderSurface.fs");
-
-
-
-	verts = std::vector<glm::vec3>{
-		{-0.5f, 0.5f, 0.0f}, // 0
-		{-0.5f, -0.5f, 0.0f}, // 1
-		{0.5f, -0.5f, 0.0f}, // 2
-		{0.5f, 0.5f, 0.0f}, // 3 
-	};
-
-	indices = std::vector<unsigned int>{
-		0,2,1,
-		0,3,2
-	};
-
-	VAO.Create();
-	VAO.Bind();
-
-	vertexBuffer.createBuffer();
-	vertexBuffer.Bind(false);
-	vertexBuffer.setBufferData(&verts[0], verts.size() * sizeof(glm::vec3), false);
-
-	elementBuffer.createBuffer();
-	elementBuffer.Bind(true);
-	elementBuffer.setBufferData(&indices[0], indices.size() * sizeof(unsigned int), true);
-
-	VAO.AttachAttribute(0, 3, 0);
-
-	vertexBuffer.Unbind(false);
-	VAO.Unbind();
-
-
-
-}
-
-RenderSurface::~RenderSurface() {
-	delete shader;
-}
-
-void RenderSurface::Draw() {
-	
-}

BarinkEngine/graphics/Renderable.cpp

@@ -1,62 +0,0 @@
-#include "Graphics/Renderable.h"
-#include "AssetManager/ModelImporter.h"
-#include "PerfCounter.h"
-
-
-Renderable* Renderable::Load(std::string& path)
-{
-    return new Renderable(path);
-}
-
-Renderable::Renderable(std::string& path)
-{
-    meshes = ModelImporter::Import(path);
-
-    transform.Scale = glm::vec3(1.0f);
-    transform.Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
-    transform.Position = glm::vec3(0.0f, 0.0f, 0.0f);
-
-    VAO.Create();
-    VAO.Bind();
-
-
-    vertexBuffer.createBuffer();
-    vertexBuffer.Bind(false);
-    vertexBuffer.setBufferData(&meshes[0].vertices[0], meshes[0].vertices.size() * sizeof(BarinkEngine::Vertex), false);   
-
-    elementBuffer.createBuffer();
-    elementBuffer.Bind(true);
-    elementBuffer.setBufferData(&meshes[0].elements[0], meshes[0].elements.size() * sizeof(unsigned int), true);
-
-    VAO.AttachAttribute(0, 3, sizeof(BarinkEngine::Vertex));
-
-   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(BarinkEngine::Vertex),(void* )offsetof(BarinkEngine::Vertex, vertices));
-   glEnableVertexAttribArray(1);
-    
-   vertexBuffer.Unbind(false);
-  
-   VAO.Unbind();
-
-
-}
-
-Renderable::~Renderable()
-{
-    glDeleteBuffers(1, &UV_id);
-}
-
-void Renderable::Draw()
-{
-    VAO.Bind();
-    elementBuffer.Bind(true);
-
-    glActiveTexture(GL_TEXTURE0);
-    glUniform1i(glGetUniformLocation(shader->id, "Texture"), GL_TEXTURE0);
-    texture->Bind();
-
-    ES->verts = meshes[0].vertices.size();
-    ES->DC++;
-    glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(meshes[0].elements.size()), GL_UNSIGNED_INT, NULL);
-    VAO.Unbind();
-
-}

BarinkEngine/graphics/Renderer.cpp

@@ -1,25 +0,0 @@
-#include "Graphics/Renderer.h"
-
-BarinkEngine::Renderer::Renderer()
-{
-	models = std::vector<Renderable*>();
-}
-
-BarinkEngine::Renderer::~Renderer()
-{
-	// CleanUp!
-}
-
-void BarinkEngine::Renderer::Render()
-{
-
-	for (auto model : models) {
-		model->Draw();
-	}
-
-}
-
-void BarinkEngine::Renderer::Submit(Renderable* model)
-{
-	models.push_back(model);
-}

BarinkEngine/graphics/Shader.cpp

@@ -1,124 +0,0 @@
-#include "Graphics/Shader.h"
-#include "spdlog/spdlog.h"
-Shader::Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath)
-{
-    char infoLog[512];
-    int succes;
-    
-    char* vertexCode = readFile(vertexShaderPath.c_str());
-    //spdlog::info(vertexCode);
-    unsigned int vertId = glCreateShader(GL_VERTEX_SHADER);
-    
-    glShaderSource(vertId, 1, &vertexCode, NULL);
-    glCompileShader(vertId);
-
-    glGetShaderiv(vertId, GL_COMPILE_STATUS, &succes);
-    if(!succes){
-        glGetShaderInfoLog(vertId, 512, NULL, infoLog);
-        spdlog::error( "Vertex shader has compile error {}", infoLog);
-        return;
-    }
-
-
-    char* fragmentCode = readFile(fragmentShaderPath.c_str());
-    //spdlog::info(fragmentCode); 
-    unsigned int fragId = glCreateShader(GL_FRAGMENT_SHADER);
-
-
-    
-    glShaderSource(fragId, 1, &fragmentCode, NULL);
-    glCompileShader(fragId);
-
-    
-    glGetShaderiv(fragId, GL_COMPILE_STATUS, &succes);
-    if(!succes){
-        glGetShaderInfoLog(fragId, 512, NULL, infoLog);
-        spdlog::error("Fragment shader has compile error {}", infoLog);
-        return;
-    }
-
-    id = glCreateProgram();
-
-    glAttachShader(id, vertId);
-    glAttachShader(id, fragId);
-    glLinkProgram(id);
-
-
-    int success;
-    glGetProgramiv(id, GL_LINK_STATUS, &success);
-    if(!success) {
-        glGetProgramInfoLog(id, 512, NULL, infoLog);
-        printf("ERROR::SHADER_PROGRAM::LINKING_FAILED\n %s", infoLog);
-    }
-
-
-    delete vertexCode;
-    delete fragmentCode;
-
-
-}
-char* Shader::readFile (const char* filePath){
-
-    std::ifstream file ;
-    file.open(filePath);
-
-    if(file.is_open() == false){
-         spdlog::info("File not found.");
-         return nullptr;
-    }
-
-
-    // Determine the file size!
-    file.seekg(0, std::ios::end);
-    size_t filesize = file.tellg();
-
-    // Undo previous seek.
-    file.seekg(0, std::ios::beg);
-    //spdlog::info("filesize: {}", filesize);
-
-
-    // Create a big enough buffer for the file
-
-    size_t bufferSize = filesize + 3;
-    char* FileBuffer = new char[bufferSize];
- 
-    memset(FileBuffer, '\0', bufferSize);
-   
-    // read the whole file
-    file.read(FileBuffer, filesize);
-    
-    return FileBuffer;
-}
-
-void Shader::Use()
-{
-    glUseProgram(id);
-}
-
-
-void Shader::setUniformMat4(std::string uniformName, glm::mat4 matrix4) const
-{    
-    glUniformMatrix4fv(glGetUniformLocation(id, uniformName.c_str()), 1, GL_FALSE, glm::value_ptr(matrix4));
-}
-void Shader::setUniformVec4(std::string uniformName, glm::vec4 vector4) const
-{
-    glUniform4fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector4));
-}
-void Shader::setUniformVec3(std::string uniformName, glm::vec3 vector3) const
-{
-    glUniform3fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector3));
-}
-void Shader::setUniformVec2(std::string uniformName, glm::vec2 vector2) const
-{
-    glUniform2fv(glGetUniformLocation(id, uniformName.c_str()),1, glm::value_ptr(vector2));
-}
-
-void Shader::setUniformFloat(std::string uniformName, float value) const
-{
-    glUniform1f(glGetUniformLocation(id, uniformName.c_str()), value);
-}
-
-void Shader::setUniformInt(std::string uniformName, int value) const
-{
-    glUniform1i(glGetUniformLocation(id, uniformName.c_str()), value);
-}

BarinkEngine/graphics/Texture.cpp

@@ -1,40 +0,0 @@
-#include "../Include/Graphics/Texture.h"
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
-#define STB_IMAGE_IMPLEMENTATION
-#include "Graphics/stb_image.h"
-#include <iostream>
-
-Texture::Texture(const std::string texturePath) {
-
-	int width, height, channels;
-	unsigned char* data = stbi_load(texturePath.c_str(), &width, &height, &channels, 0);
-	std::cout << channels << std::endl;
-
-	if (data) {
-		glGenTextures(1, &Id);
-
-		glBindTexture(GL_TEXTURE_2D, Id);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
-		glGenerateMipmap(GL_TEXTURE_2D);
-
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-	}
-	else {
-		spdlog::error("Failed to load image (%s)", texturePath );
-	}
-	stbi_image_free(data);
-
-}
-
-void Texture::Bind() {
-	glBindTexture(GL_TEXTURE_2D, Id);
-}
-
-void Texture::Unbind() {
-	glBindTexture(GL_TEXTURE_2D, 0);
-}

BarinkEngine/graphics/VertexArray.cpp

@@ -1,25 +0,0 @@
-#include "Graphics/VertexArray.h"
-#include <glad/glad.h>
-
-void VertexArray::Create(){
-    glGenVertexArrays(1, &id);
-}
-
-void VertexArray::Bind(){
-    glBindVertexArray(id);
-}
-
-void VertexArray::Unbind(){
-    glBindVertexArray(0);
-}
-
-void VertexArray::Delete() {
-    glDeleteVertexArrays(1, &id);
-}
-
-
-void VertexArray::AttachAttribute(unsigned int index , int size, int stride  ){
-    glVertexAttribPointer(index, size, GL_FLOAT, GL_FALSE, stride, 0);
-    glEnableVertexAttribArray(0);
-}
-

BarinkEngine/graphics/window.cpp

@@ -1,87 +0,0 @@
-#include "Graphics/Window.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <iostream>
-#include <GLFW/glfw3.h>
-#include <spdlog/spdlog.h>
-#include "../Include/EventSystem/Event.h"
-
-bool BarinkWindow::InitGLFW(){
-	if(!glfwInit())
-	{
-		spdlog::error("Failed to initialise GLFW!");
-		return false;
-	}
-	
-	return true;
-}
-
-BarinkWindow::BarinkWindow(const int width, const int height) :
-Width(width), Height(height), FullScreen(false){
-	if (InitGLFW()==false) {
-		exit(-1);
-	}
-
-	window = glfwCreateWindow(Width, Height, "BarinkEngine", NULL, NULL);
-
-	if( !window)
-	{
-		spdlog::error("GLFW failed to create window!");
-		glfwTerminate();
-		return;
-	}
-
-	glfwMakeContextCurrent(window);
-	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
-		printf("Failed to initialize GLAD!\n");
-		exit(-1);
-	}
-
-	// Set vsync off !! 
-	glfwSwapInterval(0);
-
-	VulkanSupported = glfwVulkanSupported();
-
-	glfwGetFramebufferSize(window, &Width, &Height);
-	glViewport(0,0, Width, Height);
-
-
-
-	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
-
-}
-
-
-BarinkWindow::~BarinkWindow(){
-
-	glfwTerminate();
-}
-
-GLFWwindow* BarinkWindow::windowptr()
-{
-	return window;
-}
-
-bool BarinkWindow::WindowShouldClose(){
-	return glfwWindowShouldClose(window);
-}
-
-void BarinkWindow::Poll()
-{	
-	glfwPollEvents();
-}
-
-void BarinkWindow::SwapBuffers() 
-{
-	glfwSwapBuffers(window);
-}
-
-
-void BarinkWindow::ReceiveEvent(Event& incident)
-{
-
-	
-
-	std::cout << "EVENT RECEIVED: " <<  incident.name << std::endl;
-
-}

BarinkEngine/premake5.lua

@@ -1,83 +0,0 @@
-project "BarinkEngine"
-  kind "StaticLib"
-
-  buildmessage "Building BarinkEngine"
-
-  includedirs {
-    "Include/",
-
-    "../libs/lua/include",
-    "../libs/spdlog/include",
-    "../libs/glm",
-    "../libs/GorillaAudio/include",
-
-    "../libs/physx/physx/include",
-    "../libs/steam-audio/include",
-    
-    "../libs/assimp/include",
-    
-
-    "../libs/glad/include",
-
-    "../libs/glfw/include",
-    "../libs/glew/include",
-    "../libs/glm",
-    
-    "../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_Opengl3",
-
-    
-
-  }
-
-
-  libdirs {
-    "../libs/steam-audio/lib/windows-x64",
-    "../libs/lua",
-    "../libs/spdlog/build/Release",
-    "../libs/assimp/lib/Debug",
-    "../libs/glfw/build/src/Debug",
-  }
-
-  files {
-    "../libs/glad/src/glad.c",
-
-    "./*.cpp",
-    "./*.h",
-    "./**/*.cpp",
-    "./**/*.h"
-  }
-
-
-
-  filter { "system:windows"}
-    prebuildcommands {
-      -- Copy shaders 
-      "copy graphics\\shaders\\fragment.shader            ..\\build\\SandboxApplication\\Debug\\test.fs", 
-      "copy graphics\\shaders\\vertex.shader              ..\\build\\SandboxApplication\\Debug\\test.vs",
-      "copy graphics\\shaders\\RenderSurfaceFrag.shader   ..\\build\\SandboxApplication\\Debug\\RenderSurface.fs",
-      "copy graphics\\shaders\\RenderSurfaceVert.shader   ..\\build\\SandboxApplication\\Debug\\RenderSurface.vs" 
-    }
-    
-   
-
-  filter { "system:linux" }
-    prebuildcommands {
-      -- Copy shaders
-      "cp graphics/shaders/fragment.shader ../build/SandboxApplication/Debug/test.fs", 
-      "cp graphics/shaders/vertex.shader ../build/SandboxApplication/Debug/test.vs",
-      "cp graphics/shaders/RenderSurfaceFrag.shader ../build/SandboxApplication/Debug/RenderSurface.fs",
-      "cp graphics/shaders/RenderSurfaceVert.shader ../build/SandboxApplication/Debug/RenderSurface.vs" 
-    }
-
-include('../ImGui')

DEVELOPMENT.md

@@ -0,0 +1,23 @@
+## Requirements
+*_NOTE:_ Right now the build proces of some third party libraries have not been converted and may need special tooling*
+
+#### Software
+* Premake
+* Git
+* C++ Compiler
+
+## Windows development workflow 
+User premake to generate project files for the approperiate build method.
+On Windows I assume you'll build with visual studio
+
+```bash
+User:~$ premake vs2022
+```
+
+## Linux development workflow
+Use premake to generate project files for the approperiate build method.
+On Linux I assume you'll build with something like make.
+
+```bash
+User@Machine:~$ premake gmake2
+```

Editor/premake5.lua

@@ -0,0 +1,46 @@
+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"],
+
+
+}
+
+libdirs {
+  staticlib["yoggie"],
+  staticlib["nativefiledialog"]
+}
+
+files { 
+  "../libs/glad/src/glad.c",
+  "./src/**.h",
+  "./src/**.cpp"
+}

Editor/src/AssetManagement/Asset.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include <filesystem>
+#include <string>
+
+enum class ASSET_TYPE {
+	Unknown = -1,
+	Mesh,
+	Texture,
+	Material
+};
+
+class Asset {
+public:
+	Asset(const char* name):  name(name) {}
+	virtual ASSET_TYPE GetType() { return ASSET_TYPE::Unknown; }
+	const char* GetName() const { return name.c_str(); }
+	bool isFolder = false ;
+protected:
+	std::string name;
+
+};
+
+class MeshAsset : Asset {
+public:
+	MeshAsset(YoggieEngine::Mesh mesh) : Asset("New MeshAsset"), mesh(mesh) {}
+	ASSET_TYPE  GetType() override { return ASSET_TYPE::Mesh; }
+private:
+	YoggieEngine::Mesh& mesh;
+};
+
+class TextureAsset : Asset {
+public:
+	TextureAsset (YoggieEngine::Texture texture): Asset("New TextureAsset"), texture(texture) {}
+	ASSET_TYPE GetType() override { return ASSET_TYPE::Texture; }
+private:
+	YoggieEngine::Texture& texture;
+};
+
+class MaterialAsset : Asset {
+public:
+	MaterialAsset ()  : Asset("New MaterialAsset"){}
+	ASSET_TYPE GetType() override { return ASSET_TYPE::Material; }
+private:
+
+};

Editor/src/AssetManagement/AssetFinder.h

@@ -0,0 +1,68 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include "EditorWindow.h"
+#include "AssetManagement/AssetManager.h"
+
+class AssetFinder : EditorWindow {
+public:
+    AssetFinder() : EditorWindow("Assets") {}
+
+    void Draw() override {
+
+
+        ImGui::DragInt("IconSize", &iconSize, 1, 30, 90);
+
+
+        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));
+
+            YoggieEngine::Texture folderIcon = YoggieEngine::Texture("rsc/folderIcon.png");
+            YoggieEngine::Texture assetIcon = YoggieEngine::Texture("rsc/assetIcon.png");
+
+
+            int row = 0;
+            int column = 0;
+            for (auto& asset : AssetManager::assets) {
+                if (column % 3 == 0) {
+                    ImGui::TableNextRow();
+                    column = 0;
+                    row++;
+                }
+
+                ImGui::TableSetColumnIndex(column);
+
+                if (asset.isFolder) {
+                    ImGui::ImageButton(
+                        (ImTextureID)folderIcon.GetID(),
+                        ImVec2{ (float)iconSize,(float)iconSize });
+                    ImGui::Text(asset.GetName(), row);
+
+                }
+                else {
+                    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:
+    int iconSize = 60;
+};
+

Editor/src/AssetManagement/AssetManager.cpp

@@ -0,0 +1,148 @@
+#include "AssetManager.h"
+#include "../../YoggieEngine/src/AssetManager/ModelImporter.h"
+#include <iostream>
+#include <fstream>
+#include <spdlog/spdlog.h>
+
+std::vector<Asset> AssetManager::assets;
+std::filesystem::path AssetManager::currentPath;
+
+void AssetManager::Init() 
+{ 
+	assets = std::vector<Asset>();
+	currentPath = std::filesystem::path("."); 
+}
+
+void AssetManager::BuildAssetView()
+{
+	if (currentPath.empty()) {
+		return;
+	}
+
+	for (auto& dir_entry : std::filesystem::directory_iterator(currentPath))
+	{
+		auto asset = Asset(dir_entry.path().filename().string().c_str());
+	
+		if (dir_entry.is_directory()) {
+			asset.isFolder = true;
+		}
+		
+		assets.push_back(asset);
+	}
+
+}
+
+void AssetManager::setAssetPath(std::filesystem::path path) 
+{ 
+	currentPath = path; 
+}
+
+YoggieEngine::Mesh* AssetManager::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* AssetManager::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;
+
+}

Editor/src/AssetManagement/AssetManager.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <vector>
+#include "Asset.h"
+
+class AssetManager {
+public:
+
+	static void Init();
+	static void BuildAssetView();
+	static void setAssetPath(std::filesystem::path path);
+
+	static YoggieEngine::Mesh* LoadFromAssetFile(const std::filesystem::path assetPath);
+	static YoggieEngine::Renderable* LoadFromSource(const std::filesystem::path srcPath, const std::filesystem::path assetFolder);
+	
+	static std::vector<Asset> assets ;
+
+private:
+	static std::filesystem::path currentPath;
+
+};

Editor/src/AssetManagement/SceneSerializer.cpp

@@ -0,0 +1,129 @@
+#include "SceneSerializer.h"
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include <yaml-cpp/yaml.h>
+#include <yaml-cpp/node/type.h>
+#include <filesystem>
+
+void WriteFile(std::string& emitter, std::filesystem::path path)
+{
+	std::cout << "Writing Scene file to: " << path.u8string() << std::endl;
+	std::ofstream sceneFile;
+	sceneFile.open(path.u8string());
+
+	sceneFile << emitter.c_str();
+
+	sceneFile.close();
+}
+
+YAML::Emitter& operator<< (YAML::Emitter& emitter, glm::vec3& vector) {
+	emitter << YAML::Flow << YAML::BeginSeq << vector.x << vector.y << vector.x << YAML::EndSeq;
+	return emitter;
+}
+
+
+
+std::string Serialize(YoggieEngine::Scene& scene) {
+	YAML::Emitter emitter;
+
+	emitter << YAML::BeginMap;
+	emitter << YAML::Key << "Scene" << YAML::Value << "test-Scene";
+	emitter << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
+
+	scene.getReg().each([&emitter, &scene](entt::entity enttNumber) {
+
+		YoggieEngine::Entity entity = YoggieEngine::Entity(enttNumber, &scene);
+
+	emitter << YAML::BeginMap;
+	emitter << YAML::Key << "Entity" << YAML::Value << entity.GetComponent<YoggieEngine::IdentifierComponent>().name;
+
+	if (entity.HasComponent<YoggieEngine::IdentifierComponent>()) {
+		emitter << YAML::Key << "Ident";
+		emitter << YAML::BeginMap;
+		emitter << YAML::Value << entity.GetComponent<YoggieEngine::IdentifierComponent>().name;
+		emitter << YAML::EndMap;
+	}
+
+	if (entity.HasComponent<YoggieEngine::TransformComponent>()) {
+		emitter << YAML::Key << "Transform" << YAML::Value;
+
+		emitter << YAML::BeginMap;
+
+		emitter << YAML::Key << "Position";
+		emitter << YAML::Value << entity.GetComponent<YoggieEngine::TransformComponent>().Position;
+
+		emitter << YAML::Key << "Rotation";
+		emitter << YAML::Value << entity.GetComponent<YoggieEngine::TransformComponent>().Rotation;
+
+		emitter << YAML::Key << "Scale";
+		emitter << YAML::Value << entity.GetComponent<YoggieEngine::TransformComponent>().Scale;
+
+		emitter << YAML::EndMap;
+	}
+
+
+	if (entity.HasComponent<YoggieEngine::LightComponent>()) {
+		emitter << YAML::Key << "Light";
+		emitter << YAML::Value;
+		emitter << YAML::BeginMap;
+		emitter << YAML::Key << "Color";
+		emitter << YAML::Value << entity.GetComponent<YoggieEngine::LightComponent>().Color;
+		emitter << YAML::EndMap;
+	}
+
+
+	emitter << YAML::EndMap;
+		});
+
+	emitter << YAML::EndSeq;
+	emitter << YAML::EndMap;
+
+	return std::string(emitter.c_str());
+}
+
+
+void SaveScene(std::filesystem::path path, YoggieEngine::Scene& scene) {
+	std::string YAMLString = Serialize(scene);
+	WriteFile(YAMLString, path);
+}
+
+
+void LoadScene(std::filesystem::path path, YoggieEngine::Scene& scene)
+{
+	auto sceneYAML = YAML::LoadFile(path.u8string());
+
+	if (!sceneYAML["Scene"]) {
+		spdlog::error("Not a scene file!");
+		return;
+	}
+
+	scene.getReg().clear();
+
+	std::string SceneName = sceneYAML["Scene"].as<std::string>();
+
+	auto entities = sceneYAML["Entities"];
+
+	for (const auto& entity : entities) {
+
+		std::string entityID = entity["Ident"].as<std::string>();
+		YoggieEngine::Entity SE = scene.AddEntity(entityID);
+		if (entity["Transform"])
+		{
+			YoggieEngine::TransformComponent tc = SE.GetComponent <YoggieEngine::TransformComponent> ();
+			auto positionNode = entity["Transform"]["Position"];
+			tc.Position = glm::vec3(positionNode[0].as<float>(), positionNode[1].as<float>(), positionNode[2].as<float>());
+
+			auto rotationNode = entity["Transform"]["Rotation"];
+			tc.Rotation = glm::vec3(rotationNode[0].as<float>(), rotationNode[1].as<float>(), rotationNode[2].as<float>());
+
+			auto scaleNode = entity["Transform"]["Scale"];
+			tc.Scale = glm::vec3(scaleNode[0].as<float>(), scaleNode[1].as<float>(), scaleNode[2].as<float>());
+		}
+		if (entity["Light"]) {
+			YoggieEngine::LightComponent lc = SE.AddComponent<YoggieEngine::LightComponent>();
+			lc.Color = glm::vec3(entity["Light"]["Color"][0].as<float>(), entity["Light"]["Color"][1].as<float>(), entity["Light"]["Color"][2].as<float>());
+		}
+
+	}
+
+
+}

Editor/src/AssetManagement/SceneSerializer.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <entt/entity/fwd.hpp>
+#include <glm/glm.hpp>
+#include <yaml-cpp/yaml.h>
+#include <filesystem>
+#include "../../YoggieEngine/src/YoggieEngine.h"
+
+void WriteFile(std::string& emitter, std::filesystem::path path);
+
+YAML::Emitter& operator<< (YAML::Emitter& emitter, glm::vec3& vector);
+
+std::string Serialize(YoggieEngine::Scene& scene);
+
+void SaveScene(std::filesystem::path path, YoggieEngine::Scene& scene);
+
+void LoadScene(std::filesystem::path path, YoggieEngine::Scene& scene);

Editor/src/Console.cpp

@@ -0,0 +1,38 @@
+#include "Console.h"
+#include <stdio.h>
+
+Console::Console()
+	: EditorWindow("Console"), Items(ImVector<char*>()), AutoScroll(false), ScrollToBottom(false)
+{
+	AddLog("Hello Editor console!");
+}
+
+Console::~Console() {
+
+}
+
+void Console::Show() {
+	Draw();
+}
+
+void Console::Draw() {
+	ImGui::SetNextWindowSize(ImVec2(520, 600), ImGuiCond_FirstUseEver);
+
+
+	for (int i = 0; i < Items.Size; i++)
+	{
+		const char* item = Items[i];
+		ImGui::TextUnformatted(item);
+	}
+}
+
+
+void Console::AddLog(const char* fmt, ...) {
+	char buf[1024];
+	va_list args;
+	va_start(args, fmt);
+	vsnprintf(buf, IM_ARRAYSIZE(buf), fmt, args);
+	buf[IM_ARRAYSIZE(buf) - 1] = 0;
+	va_end(args);
+	Items.push_back(strdup(buf));
+}

Editor/src/Console.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include "EditorWindow.h"
+#include <imgui.h>
+
+class Console : public EditorWindow {
+public:
+
+    Console();
+    ~Console();
+
+    void Draw() override;
+
+    void Show();
+
+    void AddLog(const  char* fmt, ...);
+
+private:
+    ImVector<char*> Items;
+    bool AutoScroll;
+    bool ScrollToBottom;
+};

Editor/src/Dialog.h

@@ -0,0 +1,72 @@
+#pragma once
+#include <string>
+#include <imgui.h>
+#include <nfd.h>
+#include <iostream>
+#include <functional>
+#include "Project/Project.h"
+struct DialogSpec {
+    const std::string& id;
+    const std::string& Title;
+    const std::string& confirmText;
+    DialogSpec() = default;
+};
+
+//classes based on RAII
+class Dialog {
+public:
+	Dialog( DialogSpec spec, std::function<void(std::string&)> onConfirm)
+	: path(nullptr), location() {
+        if (ImGui::BeginPopupModal(spec.id.c_str(), NULL, ImGuiWindowFlags_NoMove))
+        {
+            ImGui::Text(spec.Title.c_str());
+            ImGui::Separator();
+
+            ImGui::LabelText("##Directory", "Directory: %s", location.c_str());
+            if (ImGui::Button("...")) {
+                nfdresult_t result = NFD_OpenDialog(NULL, NULL, &path);
+
+                switch (result) {
+                case (NFD_OKAY):
+                    location = std::string(path);
+                    break;
+                case(NFD_CANCEL):
+                    std::cout << "NFD_CANCEL" << std::endl;
+                case (NFD_ERROR):
+                    std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
+                    break;
+
+                };
+
+            }
+
+            if (ImGui::Button(spec.confirmText.c_str(), ImVec2(120, 0)))
+            {
+                onConfirm(location);
+
+                ImGui::CloseCurrentPopup();
+            }
+
+            ImGui::SetItemDefaultFocus();
+            ImGui::SameLine();
+
+            if (ImGui::Button("Cancel", ImVec2(120, 0)))
+            {
+                ImGui::CloseCurrentPopup();
+            }
+
+            ImGui::EndPopup();
+
+        }
+	}
+
+	~Dialog() {
+		delete path;
+	}
+
+protected :
+	char* path;
+	std::string location;
+};
+
+

Editor/src/EditorWindow.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <imgui.h>
+#include <string>
+
+class EditorWindow {
+
+public:
+	EditorWindow (const std::string& name, ImGuiWindowFlags_ flags = ImGuiWindowFlags_None ) : name(name) , flags(flags) {}
+
+	void Update()
+	{
+		ImGui::Begin(name.c_str(), false, flags);
+		Draw();
+		ImGui::End();
+	}
+
+	~EditorWindow() = default;
+
+protected:
+	std::string name; 
+
+private:
+	ImGuiWindowFlags_ flags;
+
+	virtual void Draw() = 0;
+};

Editor/src/MainMenuBar.cpp

@@ -0,0 +1,188 @@
+#include "MainMenuBar.h"
+#include <nfd.h>
+#include "AssetManagement/AssetManager.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);
+                AssetManager::setAssetPath(project.GetProjectDirectory());
+                AssetManager::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);
+                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
+
+                AssetManager::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 = AssetManager::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

@@ -0,0 +1,30 @@
+#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/Project.cpp

@@ -0,0 +1,65 @@
+#include "Project.h"
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <yaml-cpp/yaml.h>
+
+
+void Project::SaveProject(std::filesystem::path path, Project& project)
+{
+	YAML::Emitter projectYAML;
+	projectYAML << YAML::BeginMap;
+	projectYAML << YAML::Key << "Project" << YAML::Value << project.Name;	
+	projectYAML << YAML::Key << "Directory" << YAML::Value << path.parent_path().u8string();
+	projectYAML << YAML::EndMap;
+	std::ofstream projectFile;
+
+	projectFile.open(path.u8string());
+	projectFile << projectYAML.c_str();
+	projectFile.close();
+}
+
+void Project::LoadProject(std::filesystem::path path, Project& project) 
+{
+	std::string YAMLProject;
+	std::stringstream sstream;
+	std::ifstream projectFile;
+	projectFile.open(path.u8string());
+
+	sstream << projectFile.rdbuf();
+	YAMLProject = sstream.str();
+
+	projectFile.close();
+
+
+	YAML::Node node = YAML::Load(YAMLProject);
+	
+	// this is probably not perfect but it seems to work for now
+	project = node.as<Project>();
+
+	std::cout << "loading..." << project.Name << std::endl;
+
+
+	
+}
+
+
+namespace YAML {
+
+	template<>
+	class convert<Project> {
+	public:
+		static bool decode(const Node& node , Project& rhs) 
+		{
+			if (!node.IsMap())
+				return false;
+			rhs.setName(node["Project"].as<std::string>());
+			rhs.setProjectDirectory(node["Directory"].as<std::string>());
+			return true;
+		}
+
+
+	};
+
+}

Editor/src/Project/Project.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <filesystem>
+#include <iostream>
+class Project {
+public:
+	Project() = default;
+	Project(const std::string& name): Name(name){}
+	~Project() { std::cout << "Unloading project..." << Name << std::endl; }
+
+	void setName(std::string& name) { Name = name; }
+	const std::string& GetName()const { return Name; }
+
+	void setProjectDirectory(std::string& path) { ProjectDirectory = std::filesystem::path(path); }
+	const std::filesystem::path GetProjectDirectory() { return ProjectDirectory; }
+
+	static void SaveProject(std::filesystem::path path, Project& project);
+	static void LoadProject(std::filesystem::path path, Project& project);
+private:
+	std::string Name;
+	std::filesystem::path ProjectDirectory;
+};
+

Editor/src/Project/ProjectInfo.cpp

@@ -0,0 +1,7 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,48 @@
+#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

@@ -0,0 +1,30 @@
+#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/Inspector.cpp

@@ -0,0 +1,104 @@
+#include "Inspector.h"
+
+
+void Inspector::Draw() 
+{
+
+}
+
+
+void Inspector::AddComponentDropDown(YoggieEngine::Entity& selected) 
+{
+    static char* names[] = { "Script Component", "Camera Component", "Light Component" };
+    if (ImGui::Button("Add Component"))
+        ImGui::OpenPopup("Component picker");
+
+    ImGui::SameLine();
+    if (ImGui::BeginPopup("Component picker")) {
+
+        for (int i = 0; i < IM_ARRAYSIZE(names); i++)
+            if (ImGui::MenuItem(names[i])) {
+                std::cout << "Add a " << names[i] << " to "
+                    << selected.GetComponent<YoggieEngine::IdentifierComponent>().name << std::endl;
+            }
+
+        ImGui::EndPopup();
+    }
+    ImGui::NewLine();
+}
+
+
+void Inspector::ShowComponents(YoggieEngine::Entity& selected)
+{
+    auto component = selected.GetComponent<YoggieEngine::IdentifierComponent>();
+    ImGui::InputText("Name:", (char*)component.name.c_str(), component.name.size() * sizeof(char), ImGuiInputTextFlags_ReadOnly);
+
+
+    if (selected.HasComponent<YoggieEngine::TransformComponent>()) {
+        auto& transform = selected.GetComponent<YoggieEngine::TransformComponent>();
+        if (ImGui::CollapsingHeader("Transform", ImGuiTreeNodeFlags_DefaultOpen)) {
+            ImGui::DragFloat3("Position", glm::value_ptr(transform.Position), 0.1f);
+            ImGui::DragFloat3("Rotation", glm::value_ptr(transform.Rotation), 0.1f);
+            ImGui::DragFloat3("Scale", glm::value_ptr(transform.Scale), 0.1f, 0.0f);
+        }
+        if (selected.HasComponent<YoggieEngine::RelationComponent>()) {
+            ImGui::Text("Has relation");
+        }
+
+
+    }
+
+
+    if (selected.HasComponent<YoggieEngine::Render3DComponent>()) {
+        auto& render3d = selected.GetComponent<YoggieEngine::Render3DComponent>();
+        if (ImGui::CollapsingHeader("Render3D", ImGuiTreeNodeFlags_DefaultOpen)) {
+            ImGui::ColorEdit3("Colour", glm::value_ptr(render3d.color));
+
+            ImGui::Checkbox("Use static rendering:", &render3d.isStatic);
+        }
+    }
+    static bool deferred = true;
+    if (selected.HasComponent<YoggieEngine::LightComponent>()) {
+        auto& light = selected.GetComponent<YoggieEngine::LightComponent>();
+        if (ImGui::CollapsingHeader("Light", ImGuiTreeNodeFlags_DefaultOpen)) {
+            ImGui::ColorEdit3("Colour", glm::value_ptr(light.Color));
+            ImGui::Checkbox("Deferred", &deferred);
+        }
+
+    }
+
+    if (selected.HasComponent <YoggieEngine::CameraComponent>()) {
+        auto& camera = selected.GetComponent<YoggieEngine::CameraComponent>();
+        if (ImGui::CollapsingHeader("Camera")) {
+            ImGui::DragFloat3("Position:", glm::value_ptr(camera.Position), 0.01f);
+            ImGui::DragFloat3("Rotation:", glm::value_ptr(camera.Rotation), 0.01f);
+
+        }
+    }
+
+    if (selected.HasComponent<YoggieEngine::RigidBody>()) {
+        auto& rigibody = selected.GetComponent<YoggieEngine::RigidBody>();
+        if (ImGui::CollapsingHeader("RigidBody")) {
+
+        }
+    }
+
+    if (selected.HasComponent<YoggieEngine::ScriptComponent>()) {
+        ComponentView("Scripting", [] {
+            ImGui::LabelText("##--", "Hello scripting");
+            });
+    }
+}
+
+
+void ComponentView(const std::string& componentName, voidFunction func) 
+{
+    ImGuiWindowFlags_ window_flags = ImGuiWindowFlags_None;
+    ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 5.0f);
+    ImGui::BeginChild(componentName.c_str());
+
+    func();
+
+    ImGui::EndChild();
+    ImGui::PopStyleVar();
+}

Editor/src/PropertyPanels/Inspector.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include "../EditorWindow.h"
+
+typedef void (*voidFunction) (void);
+
+inline void ComponentView(const std::string& componentName, voidFunction func);
+
+class Inspector : public EditorWindow {
+public:
+    Inspector() : EditorWindow("Inspector") {}
+
+    void Draw()override;
+
+
+    void AddComponentDropDown(YoggieEngine::Entity& selected);
+
+    void ShowComponents(YoggieEngine::Entity& selected);
+
+};

Editor/src/PropertyPanels/SceneExplorer.cpp

@@ -0,0 +1,13 @@
+#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(), enttNumber == selected)) {
+            selected = enttNumber;
+        }
+    });
+}

Editor/src/PropertyPanels/SceneExplorer.h

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

Editor/src/Runtime/RuntimeControls.cpp

@@ -0,0 +1,27 @@
+#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

@@ -0,0 +1,26 @@
+#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

@@ -0,0 +1,55 @@
+#include "Viewport.h"
+
+Viewport::Viewport(YoggieEngine::Scene& scene ):
+    EditorWindow("SceneView"),
+    renderer(YoggieEngine::RendererConfig{ 1200, 700, glm::vec3(0), true }),
+    cam(glm::vec3(14.0f, 1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), 90),
+    scene(scene)
+{
+    renderer.SetMainCamera(cam);
+
+}
+
+void Viewport::Draw() {
+
+    auto group = scene.getReg().view<YoggieEngine::TransformComponent, YoggieEngine::Render3DComponent>();
+    group.each([&](auto enity, YoggieEngine::TransformComponent& t, YoggieEngine::Render3DComponent& renderComponent) {
+        renderer.Submit(renderComponent, t);
+        });
+
+    cam.Update();
+    renderer.Render(scene);
+
+    ImVec2 WinPos = ImGui::GetWindowPos();
+    ImVec2 ContentRegionMin = ImGui::GetWindowContentRegionMin();
+    ImVec2 ContentRegionMax = ImGui::GetWindowContentRegionMax();
+    ImVec2 ScreenSpaceMin = { ContentRegionMin.x + WinPos.x, ContentRegionMin.y + WinPos.y };
+    ImVec2 ScreenSpaceMax = { ContentRegionMax.x + WinPos.x,ContentRegionMax.y + WinPos.y };
+
+
+    ImGui::Image(
+        (void*)(intptr_t)renderer.getCurrentFrameBuffer().GetColourAttachment(),
+        ImVec2{ (float)ImGui::GetWindowWidth(),(float)ImGui::GetWindowHeight() }
+    );
+
+
+    ImGuizmo::Enable(true);
+    ImGuizmo::SetRect(ScreenSpaceMin.x, ScreenSpaceMin.y, ContentRegionMax.x, ContentRegionMax.y);
+
+    glm::mat4 transposed_view = glm::transpose(cam.ViewMatrix);
+
+    //ImGuizmo::DrawGrid(glm::value_ptr(cam.ViewMatrix), glm::value_ptr(cam.ProjectionMatrix), glm::value_ptr(worldOrigin), 100.0f);
+    //ImGuizmo::ViewManipulate(glm::value_ptr(cam.ViewMatrix), 1, { ScreenSpaceMin.x,ScreenSpaceMin.y }, { 90,90 }, 0x22CCCCCC);
+
+    // Matrix is the model matrix we would want to manipulate
+    //ImGuizmo::Manipulate(glm::value_ptr(cam.ViewMatrix), glm::value_ptr(cam.ProjectionMatrix), ImGuizmo::TRANSLATE, ImGuizmo::WORLD, glm::value_ptr(cam.ViewMatrix));
+
+    if (ImGui::IsWindowFocused())
+    {
+        isFocused = true;
+
+    }
+    else {
+        isFocused = false;
+    }
+}

Editor/src/Views/Viewport.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include "../EditorWindow.h"
+
+#include <glm/glm.hpp>
+
+#include <imgui.h>
+#include "../../libs/guizmo/ImGuizmo.h"
+
+
+class Viewport : public EditorWindow {
+public:
+    bool isFocused = false;
+    YoggieEngine::Camera cam;
+
+    Viewport(YoggieEngine::Scene& scene);
+
+    void Draw() override;
+
+private:
+    YoggieEngine::Renderer renderer;
+    YoggieEngine::Scene& scene;
+
+};

Editor/src/app.cpp

@@ -0,0 +1,211 @@
+#include "../../YoggieEngine/src/EntryPoint.h"
+#include "../../YoggieEngine/src/AssetManager/ModelImporter.h"
+#include "../../YoggieEngine/src/Physics/Physics.h"
+
+#include <nfd.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include "Project/Project.h"
+#include "AssetManagement/SceneSerializer.h"
+#include "AssetManagement/AssetManager.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 "Project/Settings.h"
+#include "Console.h"
+
+using namespace YoggieEngine;
+
+
+class Editor : public Application {
+public:
+    Editor() : Application("Editor"), Selected((entt::entity)-1){}
+
+    void Run() override
+    {
+        LoadLastOrEmptyProject();
+
+        MainMenuBar menuBar = MainMenuBar();
+        ProjectInfo projectInfo(project);
+        Viewport sceneview = Viewport(scene);
+        RuntimeControls rc = RuntimeControls();
+        SceneExplorer explorer(Selected, scene);
+        Inspector inspector = Inspector();
+        Settings settings = Settings();
+        // AssetFinder assetsView = AssetFinder();
+        Console console = Console();
+
+        double previous = glfwGetTime();
+        double lag = 0.0;
+        while (!appWindow.WindowShouldClose())
+        {
+            PollEvents();
+            double now = glfwGetTime();
+            double elapsed = now - previous ;
+            previous = now;
+            lag += elapsed;
+        
+            if (sceneview.isFocused)
+            {
+                const float movement_speed = 0.1f;
+                static float lastX = 400, lastY = 300;
+                const float sensitivity = 0.1;
+                static bool firstMouse = true;
+
+                if (MouseButtonPressed(YOGGIE_MOUSE_BUTTON_RIGHT)) {
+
+                    glfwSetInputMode(appWindow.GetGLFWHandle(), 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.yaw += xoffset;
+                    sceneview.cam.pitch += 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(appWindow.GetGLFWHandle(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+                    firstMouse = true;
+                }
+
+                // 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;
+
+            }
+
+            GuiBegin();
+
+            // Show a menu bar
+            menuBar.ApplicationMenu(project);
+            menuBar.SceneMenu(project, scene);
+            menuBar.SelectMenu();
+            menuBar.WindowMenu();
+            menuBar.DebugMenu();
+            menuBar.Help();
+          
+     
+            if (scene.getReg().valid(Selected)) {
+                Entity SelectedEntity = Entity(Selected, &scene);
+                inspector.AddComponentDropDown(SelectedEntity);
+                inspector.ShowComponents(SelectedEntity);
+            }
+
+
+            projectInfo.Update();
+            sceneview.Update();
+            rc.Update();
+            explorer.Update();
+            settings.Update();
+            inspector.Update();
+            console.Update();
+            
+            ImGui::ShowDemoWindow();
+            ImGui::ShowMetricsWindow();
+
+            
+            GuiEnd();
+            SwapBuffers();
+        }
+    }
+
+
+    void LoadLastOrEmptyProject() {
+        // Check if there is a last known loaded project and 
+       // load that one .
+
+       // Otherwise load no project..
+       // OR 
+       // Load an empty project.
+
+        std::string path = (std::filesystem::current_path()).string();
+        project.setProjectDirectory(path);
+
+        AssetManager::Init();
+        AssetManager::setAssetPath(project.GetProjectDirectory());
+        AssetManager::BuildAssetView();
+
+        // Create a level and load it as the current level
+        auto importer = ModelImporter();
+
+
+        // create an ambient light source
+        auto light = scene.AddEntity("Light");
+        auto& lightComponent = light.AddComponent<LightComponent>();
+        lightComponent.Color = glm::vec3(1.0f);
+
+
+        // Create a cube 
+        auto model = importer.Import("build/Debug/Models/Cube.obj");
+
+        auto cube = scene.AddEntity("Cube");
+        auto& render3DComponent = cube.AddComponent<Render3DComponent>();
+        render3DComponent.mesh = *(model->renderable->mesh);
+
+        cube.GetComponent<TransformComponent>().Position = glm::vec3(1.0f, 0.0f, 5.0f);
+
+        auto cube2 = scene.AddEntity("Cube2");
+        auto& rendercube2 = cube2.AddComponent<Render3DComponent>();
+        rendercube2.mesh = *(model->renderable->mesh);
+        auto& relationcube = cube.AddComponent<RelationComponent>(cube2);
+        auto& rigidbodycomp = cube.AddComponent<RigidBody>();
+        auto& rigidbodycomp2 = cube2.AddComponent<RigidBody>();
+
+
+        auto Grass = scene.AddEntity("Grass/Window-Pane");
+        //auto& renderGrass = Grass.AddComponent<Render3DComponent>();
+    }
+
+private:
+    bool SimulatePhysics = true;
+    entt::entity  Selected;
+
+    Project project;
+    Scene scene;
+
+};
+
+YoggieEngine::Application* CreateApplication() {
+   
+    return new Editor();
+
+}

ImGui/premake5.lua

@@ -1,4 +1,4 @@
-project "ImGUI_Opengl3"
+project "ImGui"
   kind "StaticLib"
 
   includedirs {

ImGuizmo/premake5.lua

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

README.md

@@ -1,76 +1,34 @@
-# BarinkEngine
-```
-    ,---,.                                           ,-.    ,---,.                                                  
-  ,'  .'  \                   ,--,               ,--/ /|  ,'  .' |                      ,--,                        
-,---.' .' |           __  ,-,--.'|        ,---,,--. :/ |,---.'   |     ,---,          ,--.'|        ,---,           
-|   |  |: |         ,' ,'/ /|  |,     ,-+-. /  :  : ' / |   |   .' ,-+-. /  | ,----._,|  |,     ,-+-. /  |          
-:   :  :  / ,--.--. '  | |' `--'_    ,--.'|'   |  '  /  :   :  |-,,--.'|'   |/   /  ' `--'_    ,--.'|'   |  ,---.   
-:   |    ; /       \|  |   ,,' ,'|  |   |  ,"' '  |  :  :   |  ;/|   |  ,"' |   :     ,' ,'|  |   |  ,"' | /     \  
-|   :     .--.  .-. '  :  / '  | |  |   | /  | |  |   \ |   :   .|   | /  | |   | .\  '  | |  |   | /  | |/    /  | 
-|   |   . |\__\/: . |  | '  |  | :  |   | |  | '  : |. \|   |  |-|   | |  | .   ; ';  |  | :  |   | |  | .    ' / | 
-'   :  '; |," .--.; ;  : |  '  : |__|   | |  |/|  | ' \ '   :  ;/|   | |  |/'   .   . '  : |__|   | |  |/'   ;   /| 
-|   |  | ;/  /  ,.  |  , ;  |  | '.'|   | |--' '  : |--'|   |    |   | |--'  `---`-'| |  | '.'|   | |--' '   |  / | 
-|   :   /;  :   .'   ---'   ;  :    |   |/     ;  |,'   |   :   .|   |/      .'__/\_: ;  :    |   |/     |   :    | 
-|   | ,' |  ,     .-./      |  ,   /'---'      '--'     |   | ,' '---'       |   :    |  ,   /'---'       \   \  /  
-`----'    `--`---'           ---`-'                     `----'                \   \  / ---`-'              `----'   
-                                                                               `--`-'         
-```
+# Yoggie Engine
+
+<img src="Screenshots/Yoggie.webp" width="160" ></img>
+## Goal
+Must support building a full game in 48 hours. 
+The goal is to build a mature enough engine to be capable of using during game jams.
+
 
 ## Features
-**NOTE** __Not in any particular order__    
+*_NOTE:_ Just because it is listed as a feature here does not imply it has been nor guarantees it ever will be implemented*
 - Rendering
     - OpenGL
     - Vulkan 
-
+    - Metal (Possibly)
 - Logging
     - Different for debug and release    
-    - Different per OS
-    
 - Physics
     -  PhysX
-    - Alternative for non-nvidia stuff?!
-
-- Basic Entity Component system
-
-- Graphical scripting ??
-
-- Scripting support ( idk what language)
+    -  Jolt Physics
+- Entity Component system
+- Graphical scripting (Possibly)
+- Scripting support
     - LUA
+    - C# (for object orientated approaches to gamedev)
 - Configuration options 
     - JSON
-    - LUA
-    - others ?!?!?
+    - YAML
+    - INI
 
-## Screenshots
-
-<img src="Screenshots/screen1.png" width="300"></img>
-<img src="Screenshots/screen2.png" width="300"></img>
-
-## Planning
-see [TODO](docs/TODO.md)
-
-_NOTE:_ 
-
-The planning is moving away from markdown in favor 
-of gitea Projects. New planning will be visible on [this page](https://git.barink.dev/Nigel/MyGameEngine/projects). 
-## Requirements
-#### Software
-* Premake
-* Git
-* C++ Compiler
-
-## Windows development workflow 
-User premake to generate project files for the approperiate build method.
-On Windows I assume you'll build with visual studio
-
-```bash
-User:~$ premake vs2022
-```
-
-## Linux development workflow
-Use premake to generate project files for the approperiate build method.
-On Linux I assume you'll build with something like make.
-
-```bash
-User@Machine:~$ premake gmake2
-```
+## More docs
+[Todo list](TODO.md)    \
+[Planning](https://git.barink.dev/Nigel/MyGameEngine/projects)\
+[Development](DEVELOPMENT.md)\
+[Show case](SHOWCASE.md)

Runtime/premake5.lua

@@ -0,0 +1,39 @@
+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

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

SHOWCASE.md

@@ -0,0 +1,17 @@
+## The engine development in pictures
+
+__Testing OpenGl with ImGui as a concept__
+
+<img src="Screenshots/OpenGLAndImGuiTest.png" width="300"></img>
+
+__Working on docking with different windows using ImGui__
+
+<img src="Screenshots/YoggieEditor_workingGuizmo.png" width="300"></img>
+
+__A first more complete look of the engine__
+
+<img src="Screenshots/YoggieEditorV0.2.png" width="300"></img>
+
+__Mixing deferred and forward rendering and adding a skybox__
+
+<img src="Screenshots/ImprovedRendering.png" width="300"></img>     

SandboxApp/premake5.lua

@@ -0,0 +1,40 @@
+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.cpp

@@ -0,0 +1,87 @@
+#include "GUI.h"
+
+
+void SceneExplorer(const std::string& PanelName) {
+    ImGui::Begin(PanelName.c_str()); 
+        //if (ImGui::ListBoxHeader("##ObjectList")) {
+            //Node& current = scene.GetRoot();
+
+           //Node* next = &current;
+
+           // Show first node
+           //ImGui::Selectable(next->name.c_str(), true);
+           // ImGui::Selectable("Scene Node", true);
+            // ImGui::Indent();
+
+             /*
+
+             if (next->children.size() != 0) {
+                 for (auto child : next->children)
+                 {
+                     std::string& name = child->name;
+                     ImGui::Selectable(name.c_str(), false);
+                 }
+             }
+
+             */
+
+         //   ImGui::ListBoxFooter();
+        // }
+    ImGui::End();
+}  
+
+    
+
+void CameraTool() {
+    static float Zoom = 0;
+    static glm::vec3 Position = glm::vec3(0.0f, 0.0f, 0.0f);
+    static glm::vec3 Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
+
+
+    ImGui::Begin("Camera");
+
+
+    ImGui::SliderFloat("Zoom:", &Zoom, 10, 190);
+
+    ImGui::InputFloat3("Position:", &Position[0]);
+
+    ImGui::InputFloat3("Rotation:", &Rotation[0]);
+
+    ImGui::End();
+}
+
+void ScriptingTool(char* code) {
+    ImGui::Begin("Scripting");
+
+    ImGui::Text("Lua Code");
+    ImGui::InputTextMultiline("##", code, 255);
+    bool runCode = ImGui::Button("Run");
+
+
+    ImGui::End();
+
+}
+
+void SceneView(Framebuffer& framebuffer ) {
+    ImGui::Begin("Viewport");
+        ImGui::Image((void*)(intptr_t)framebuffer.GetColourAttachment(), ImVec2{800, 600});
+    ImGui::End();
+}
+
+/*
+* void transformWindow(Transform& transform, std::string PanelName) {
+    ImGui::Begin(PanelName.c_str());
+    ImGui::InputFloat3("Position:", (float*)&transform.Position[0]);
+    ImGui::InputFloat3("Rotation:", (float*)&transform.Rotation[0]);
+    ImGui::InputFloat3("Scale:", (float*)&transform.Scale[0]);
+    ImGui::End();
+
+}
+
+*/
+
+void materialWindow(Material& material, std::string PanelName) {
+    ImGui::Begin(PanelName.c_str());
+    ImGui::ColorPicker3("Color:", &material.Color[0]);
+    ImGui::End();
+}

SandboxApp/src/GUI.h

@@ -0,0 +1,11 @@
+#pragma once
+#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);

SandboxApp/src/Sandbox.cpp

@@ -0,0 +1,123 @@
+#include <imgui.h>
+#include "GUI.h"
+#include "Util.h"
+#include <entt/entt.hpp>
+
+#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"
+
+
+/*
+* Define globals
+*/
+Scene scene;
+
+BarinkEngine::Renderable* renderable;
+BarinkEngine::SceneObject* object;
+Entity cube;
+
+/*
+* Runs once at startup 
+* - USe to initialize the game/sandbox/demo
+*/
+void Start() {
+    auto importer = BarinkEngine::ModelImporter();
+
+    // 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));
+
+
+    // 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();
+
+}
+
+/*
+* 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()
+{
+}