Script component inspector, glfwErrorCallback etc...

* Filling out script component inspector
* adding error_callback for glfw
* Measuring gflwInit time
* Moving Swap interval set to be after making context current

.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/
+**/build/
-intermediates/
+**/intermediates/
 tools/
 *.make
 Makefile
 .vscode/
 libs/lua
 libs/glad
-Debug/
 *.sln
 *.vcxproj
 *.vcxproj.filters
@@ -17,4 +16,9 @@ x64/
 *.gltf
 !sponza.gltf
 
-imgui.ini
+imgui.ini
+libs/physx/physx/include/
+libs/physx/physx/compiler/
+libs/physx/physx/buildtools/
+libs/physx/physx/bin/
+libs/nativefiledialog/build/

.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,27 @@
 [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
+	ignore = dirty
+[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
+	ignore = dirty
+[submodule "libs/mINI"]
+	path = libs/mINI
+	url = https://github.com/pulzed/mINI.git
+[submodule "libs/imgui-filebrowser"]
+	path = libs/imgui-filebrowser
+	url = https://github.com/AirGuanZ/imgui-filebrowser.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,47 @@
+project "Editor"
+kind "ConsoleApp"
+
+buildmessage "Building editor ..."
+
+links{
+  "YoggieEngine",
+  "ImGuizmo",
+  "yaml-cpp",
+  "nfd.lib"
+}
+
+includedirs{
+
+  "../YoggieEngine/build/Debug",
+
+  -- I'd prefer if didn't need these..
+  -- We'll figure that out some time later
+  "../libs/physx/physx/include",
+  "../libs/physx/pxshared/include",
+  incfolder["lua"],
+  incfolder["spdlog"],
+  incfolder["glm"],
+  incfolder["assimp"],
+  incfolder["glad"],
+  incfolder["glfw"],
+
+  incfolder["imgui"],
+  incfolder["imguizmo"],
+  incfolder["entt"],
+  incfolder["yamlcpp"],
+  incfolder["nativefiledialog"],
+  incfolder["mINI"]
+
+
+}
+
+libdirs {
+  staticlib["yoggie"],
+  staticlib["nativefiledialog"]
+}
+
+files { 
+  "../libs/glad/src/glad.c",
+  "./src/**.h",
+  "./src/**.cpp"
+}

Editor/src/AssetManagement/Asset.h

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

Editor/src/AssetManagement/AssetFinder.h

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

Editor/src/AssetManagement/AssetLoaders/AssetLoader.h

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

Editor/src/AssetManagement/AssetLoaders/ModelLoader.cpp

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

Editor/src/AssetManagement/AssetLoaders/ModelLoader.h

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

Editor/src/AssetManagement/AssetRegistry.cpp

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

Editor/src/AssetManagement/AssetRegistry.h

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

Editor/src/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)
+{
+	spdlog::info( "Writing Scene file to: {0}" , path.u8string());
+	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/AssetManagement/uuid.h

@@ -0,0 +1,63 @@
+/*
+* 
+* SOURCE: https://github.com/rkg82/uuid-v4/blob/main/uuid/v4/uuid.h
+*
+*/
+#ifndef __UUID__
+#define __UUID__
+
+#include <random>
+#include <string>
+
+namespace uuid::v4
+{
+    // Encaasulate the genaeration of a Version 4 UUID object
+    // A Version 4 UUID is a universally unique identifier that is generated using random numbers.
+    class UUID
+    {
+    public:
+        // Factory method for creating UUID object.
+        static UUID New()
+        {
+            UUID uuid;
+            std::random_device rd;
+            std::mt19937 engine{ rd() };
+            std::uniform_int_distribution<int> dist{ 0, 256 }; //Limits of the interval
+
+            for (int index = 0; index < 16; ++index)
+            {
+                uuid._data[index] = (unsigned char)dist(engine);
+            }
+
+            uuid._data[6] = ((uuid._data[6] & 0x0f) | 0x40); // Version 4
+            uuid._data[8] = ((uuid._data[8] & 0x3f) | 0x80); // Variant is 10
+
+            return uuid;
+        }
+
+        // Returns UUID as formatted string
+        std::string String()
+        {
+            // Formats to "0065e7d7-418c-4da4-b4d6-b54b6cf7466a"
+            char buffer[256] = { 0 };
+            std::snprintf(buffer, 255,
+                "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                _data[0], _data[1], _data[2], _data[3],
+                _data[4], _data[5],
+                _data[6], _data[7],
+                _data[8], _data[9],
+                _data[10], _data[11], _data[12], _data[13], _data[14], _data[15]);
+
+            std::string uuid = buffer;
+
+            return uuid;
+        }
+
+    private:
+        UUID() {}
+
+        unsigned char _data[16] = { 0 };
+    };
+};
+
+#endif // #ifndef __UUID__

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):
+                    spdlog::info("NFD_CANCEL" );
+                case (NFD_ERROR):
+                    spdlog::error("NFD_Error: {0}" , NFD_GetError() );
+                    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/EditorCamera.h

@@ -0,0 +1,32 @@
+#pragma once
+#include "../../YoggieEngine/src/YoggieEngine.h"
+
+class EditorCamera : public YoggieEngine::Camera {
+public:
+	EditorCamera () : Camera(){
+		Front = glm::vec3(0.0f, 0.0f, 1.0f);
+		Right = glm::vec3(-1.0f, 0.0f, 0.0f);
+		Up = glm::vec3(0.0f, 1.0f, 0.0f);
+
+		projection = glm::perspective(glm::radians(65.0f), (800.0f / 600.0f), 0.001f, 100.0f);
+
+
+		view = glm::translate(glm::mat4(1.0f), Position) * glm::toMat4(glm::quat(Rotation));
+	}
+
+	void Update() {
+
+		view = glm::translate(glm::mat4(1.0f), Position) * glm::toMat4(glm::quat(Rotation));
+	}
+
+	glm::vec3 Position;
+	glm::vec3 Rotation;
+
+private:
+
+
+
+	glm::vec3 Front;
+	glm::vec3 Right;
+	glm::vec3 Up;
+};

Editor/src/EditorLayer.h

@@ -0,0 +1,247 @@
+#pragma once
+#include <iostream>
+#include <mini/ini.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include "AssetManagement/SceneSerializer.h"
+#include "AssetManagement/AssetRegistry.h"
+#include "Views/Viewport.h"
+#include "PropertyPanels/SceneExplorer.h"
+#include "AssetManagement/AssetFinder.h"
+#include "MainMenuBar.h"
+#include "PropertyPanels/Inspector.h"
+#include "Project/ProjectInfo.h"
+#include "Runtime/RuntimeControls.h"
+#include "AssetManagement/uuid.h"
+#include "Project/Settings.h"
+#include "Console.h"
+#include "AssetManagement/AssetLoaders/ModelLoader.h"
+
+using namespace YoggieEngine;
+class EditorLayer : public Layer {
+
+public:
+	EditorLayer():
+        Layer(),
+        rc(),
+        sceneview(scene, Selected),
+        explorer(Selected, scene),
+        inspector (Selected)
+    {
+    }
+
+	void OnStartup() override {
+        std::string path = (std::filesystem::current_path()).string();
+        project.setProjectDirectory(path);
+        assetsView = AssetFinder(project.GetProjectDirectory());
+        LoadLastOrEmptyProject();
+
+        AssetRegistry assetManager = AssetRegistry();
+        ModelLoader modelLoader = ModelLoader();
+
+        spdlog::info( "{0}", project.GetProjectDirectory().string());
+
+        auto latern = modelLoader.LoadAsset(std::filesystem::path("build/debug/Models/Latern.gltf"));
+        spdlog::info( "Loaded mesh: {0}" , latern.GetName() );
+
+        //ProjectInfo projectInfo(project);
+        //Settings settings = Settings();
+        //Console console = Console();
+ 
+
+
+        Selected = YoggieEngine::Entity((entt::entity)-1, &scene);
+
+	}
+
+	void OnUpdate() override {
+        scene.Update();
+
+		if (sceneview.isFocused) {
+			UpdateSceneCamera(sceneview);
+
+			spdlog::info( "Scene view in Focus!\r");
+		}
+
+	}
+
+
+    void OnUI() override {
+        {
+            MainMenuBar menuBar = MainMenuBar();
+            menuBar.ApplicationMenu(project);
+            menuBar.SceneMenu(project, scene);
+            menuBar.SelectMenu();
+            menuBar.WindowMenu();
+            menuBar.DebugMenu();
+            menuBar.Help();
+
+        }
+
+        //projectInfo.Update();
+        sceneview.Update();
+        rc.Update();
+        explorer.Update();
+        //settings.Update();
+        inspector.Update();
+        //console.Update();
+
+        assetsView.Update();
+
+        ImGui::ShowDemoWindow();
+        //ImGui::ShowMetricsWindow();
+    }
+
+	
+	void OnCreate() override {
+		spdlog::info(" Layer Create!" );
+
+	}
+
+	void OnDestroy() override {
+		spdlog::info( " Layer Destroy!" );
+
+	}
+
+
+private:
+
+    RuntimeControls rc;
+    Viewport sceneview ;
+    SceneExplorer explorer;
+    Inspector inspector;
+    AssetFinder assetsView;
+
+    bool SimulatePhysics = true;
+    YoggieEngine::Entity  Selected;
+    Project project;
+    Scene scene;
+
+    void LoadLastOrEmptyProject() {
+        // Check if there is a last known loaded project and 
+       // load that one .
+
+       // Otherwise load no project..
+       // OR 
+       // Load an empty project.
+        mINI::INIStructure ini;
+
+        if (std::filesystem::exists("build\\Debug\\Editor.ini"))
+        {
+            mINI::INIFile file("build\\Debug\\Editor.ini");
+            file.read(ini);
+        }
+        else
+        {
+            spdlog::debug("Could not find an `Editor.ini` file.");
+        }
+
+        if (ini["editor"]["openlastproject"] == "TRUE")
+        {
+
+            Project::LoadProject(ini["cache"]["project"], project);
+            LoadScene(ini["cache"]["scene"], scene);
+
+        }
+        else
+        {
+            spdlog::debug("Starting without a project. Please create one.");
+        }
+    }
+
+
+    void UpdateSceneCamera(Viewport& sceneview) {
+        const float movement_speed = 0.01f;
+        static float lastX = 400, lastY = 300;
+        const float sensitivity = 0.1;
+        static bool firstMouse = true;
+
+        /*
+
+        if (MouseButtonPressed(YOGGIE_MOUSE_BUTTON_RIGHT)) {
+
+            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+            auto newX = getCursorPosX(appWindow);
+            auto newY = getCursorPosY(appWindow);
+
+            if (firstMouse)
+            {
+                lastX = newX;
+                lastY = newY;
+                firstMouse = false;
+            }
+
+
+            float xoffset = newX - lastX;
+            float yoffset = newY - lastY;
+
+            lastX = newX;
+            lastY = newY;
+
+            xoffset *= sensitivity;
+            yoffset *= sensitivity;
+
+            sceneview.cam.Rotation.x += (xoffset / 2);
+            sceneview.cam.Rotation.y += (xoffset /2);
+            sceneview.cam.Rotation.z += yoffset;
+
+
+            if (sceneview.cam.pitch > 89.0f)
+                sceneview.cam.pitch = 89.0f;
+            if (sceneview.cam.pitch < -89.0f)
+                sceneview.cam.pitch = -89.0f;
+
+
+        }
+        else if (firstMouse == false)
+        {
+            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            firstMouse = true;
+        }
+
+
+
+        */
+        
+        EditorCamera& cam = sceneview.GetCamera();
+
+        
+        
+        if (keyIsPressed(YOGGIE_KEY_UP))
+            cam.Rotation.x += movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_DOWN))
+            cam.Rotation.x -= movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_LEFT))
+            cam.Rotation.y += movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_RIGHT))
+            cam.Rotation.y -= movement_speed;
+
+
+        cam.Update();
+
+
+
+        /*
+
+        // Check for Camara movement input here!
+        if (keyIsPressed(YOGGIE_KEY_W))
+            sceneview.cam.Position -= sceneview.cam.Front * movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_A))
+            sceneview.cam.Position += sceneview.cam.Right * movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_S))
+            sceneview.cam.Position += sceneview.cam.Front * movement_speed;
+
+        if (keyIsPressed(YOGGIE_KEY_D))
+            sceneview.cam.Position -= sceneview.cam.Right * movement_speed;
+            */
+
+
+    }
+
+};

Editor/src/EditorWindow.h

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

Editor/src/MainMenuBar.h

@@ -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,76 @@
+#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;
+	projectYAML << YAML::BeginMap;
+
+
+	projectYAML << YAML::Key << "Scenes" << YAML::Value << YAML::BeginSeq;
+	for (auto scene : project.Scenes) {
+		projectYAML << scene->name;
+	}
+	projectYAML << YAML::EndSeq;
+
+	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,37 @@
+#pragma once
+#include <filesystem>
+#include <iostream>
+#include "../../YoggieEngine/src/YoggieEngine.h"
+#include <yaml-cpp/yaml.h>
+
+
+class Project {
+public:
+	Project() = default;
+	Project(const std::string& name): Name(name){}
+	~Project() { spdlog::info("Unloading project {0}...", Name);}
+
+	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; }
+
+
+	void AddScene(YoggieEngine::Scene& scene)
+	{
+		Scenes.push_back(&scene);
+	}
+
+	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;
+
+	std::vector<YoggieEngine::Scene*> Scenes;
+
+	friend class YAML::convert<Project>;
+
+};
+

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,174 @@
+#include "Inspector.h"
+#include "../TransformVec3.h"
+
+void Inspector::Draw() 
+{
+    if (selected.isValid()) {
+        AddComponentDropDown();
+        ShowComponents();
+    }
+}        
+void AddComponent(YoggieEngine::Entity selected , int i) {
+    switch (i) {
+    case 0:
+        selected.AddComponent<YoggieEngine::ScriptComponent>();
+        break;
+    case 1:
+        selected.AddComponent<YoggieEngine::CameraComponent>();
+        break;
+    case 2:
+        selected.AddComponent<YoggieEngine::LightComponent>();
+        break;
+    case 3:
+        selected.AddComponent<YoggieEngine::Render3DComponent>();
+    default:
+
+        break;
+    }
+}
+
+void Inspector::AddComponentDropDown() 
+{
+    static char* names[] = { "Script Component", "Camera Component", "Light Component", "Render3D"};
+    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]))
+                AddComponent(selected, i);
+        }
+        ImGui::EndPopup();
+
+    }
+    ImGui::NewLine();
+}
+
+
+void Inspector::ShowComponents()
+{
+    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);
+*/
+            auto something = glm::value_ptr(transform.Position);
+
+            ImGuiExtension::TransformVec3("Position", transform.Position);
+            ImGuiExtension::TransformVec3("Rotation", transform.Rotation);
+            ImGuiExtension::TransformVec3("Scale", transform.Scale);
+
+
+        }
+        if (selected.HasComponent<YoggieEngine::RelationComponent>()) {
+            ImGui::Text("Has relation");
+        }
+
+
+    }
+
+
+    if (selected.HasComponent<YoggieEngine::Render3DComponent>()) {
+        auto& render3d = selected.GetComponent<YoggieEngine::Render3DComponent>();
+        const char* AssetNames[]{ "Asset1" , "Asset2" };
+        if (ImGui::CollapsingHeader("Render3D", ImGuiTreeNodeFlags_DefaultOpen)) {
+
+            if (ImGui::Button("Select Renderable Asset"))
+                ImGui::OpenPopup("Renderable_list_popup");
+            ImGui::SameLine();
+            ImGui::TextUnformatted(render3d.mesh.elements.empty() ? "<None>" : "ASSET_GUID_OR_ID");
+            if (ImGui::BeginPopup("Renderable_list_popup")) {
+                ImGui::Text("None");
+                ImGui::Separator();
+                for (int i = 0; i < IM_ARRAYSIZE(AssetNames); i++) {
+                    if(ImGui::Selectable(AssetNames[i]))
+                    { }
+                }
+                ImGui::EndPopup();
+
+            }
+
+
+
+
+            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>()) {
+        const char* AssetNames[]{ "Script 1" , "Script 2" };
+        if (ImGui::CollapsingHeader("Script", ImGuiTreeNodeFlags_Leaf)) {
+            
+            if (ImGui::Button("Select Renderable Asset"))
+                ImGui::OpenPopup("Scripts_list_popup");
+          
+            if (ImGui::BeginPopup("Scripts_list_popup")) {
+                ImGui::Text("None");
+                ImGui::Separator();
+                for (int i = 0; i < IM_ARRAYSIZE(AssetNames); i++) {
+                    if (ImGui::Selectable(AssetNames[i]))
+                    {
+                    }
+                }
+                ImGui::EndPopup();
+
+            }
+            
+            ImGui::SameLine();
+            std::string  scriptAssetId = "<Random_GUID>";
+            ImGui::InputText("asset", scriptAssetId.data(), scriptAssetId.length(), ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_AutoSelectAll);
+            
+        }
+    }
+}
+
+
+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,22 @@
+#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( YoggieEngine::Entity& selected ) : EditorWindow("Inspector"), selected(selected){}
+
+    void Draw()override;
+
+private:
+
+    void AddComponentDropDown();
+    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(), entity == selected)) {
+            selected = YoggieEngine::Entity(enttNumber, &scene);
+        }
+    });
+}

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(YoggieEngine::Entity& selected, YoggieEngine::Scene& scene)
+        : EditorWindow("SceneExplorer"), scene(scene), selected(selected)
+    {}
+
+    void Draw() override;
+
+
+private:
+    YoggieEngine::Entity& selected;
+    YoggieEngine::Scene& scene;
+
+
+};

Editor/src/Runtime/RuntimeControls.cpp

@@ -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/TransformVec3.h

@@ -0,0 +1,59 @@
+#pragma once
+#include <imgui_widgets.cpp>
+#include <glm/glm.hpp>
+namespace ImGuiExtension {
+
+
+    void  TransformVec3(const char* label, glm::vec3& vector) {
+
+        ImGui::PushID(label);
+        ImGui::Columns(2);
+        ImGui::SetColumnWidth(0, 100.0f);
+        ImGui::Text(label);
+
+        ImGui::NextColumn();
+
+        ImGui::PushMultiItemsWidths(3, ImGui::CalcItemWidth());
+        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{ 0, 0 });
+
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.8f, 0.1f, 0.15f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.9f,0.2f,0.2f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.8f,0.1f,0.15f, 1.0f });
+        if (ImGui::Button("X"))
+            vector.x = 0;
+        ImGui::PopStyleColor(3);
+
+        ImGui::SameLine();
+        ImGui::DragFloat("##X", &glm::value_ptr(vector)[0], 0.1f, 0.0f, 0.0f, "%.2f");
+        ImGui::PopItemWidth();
+        ImGui::SameLine();
+
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.2f, 0.7f, 0.2f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.3f,0.8f,0.3f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.2f,0.7f,0.2f, 1.0f });
+        if (ImGui::Button("Y"))
+            vector.y = 0;
+        ImGui::PopStyleColor(3);
+
+        ImGui::SameLine();
+        ImGui::DragFloat("##Y", &glm::value_ptr(vector)[1], 0.1f, 0.0f, 0.0f, "%.2f");
+        ImGui::PopItemWidth();
+        ImGui::SameLine();
+
+        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.1f, 0.25f, 0.8f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.2f,0.35f,0.9f, 1.0f });
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.1f,0.25f,0.8f, 1.0f });
+        if (ImGui::Button("Z"))
+            vector.z = 0;
+        ImGui::PopStyleColor(3);
+
+        ImGui::SameLine();
+        ImGui::DragFloat("##Z", &glm::value_ptr(vector)[2], 0.1f, 0.0f, 0.0f, "%.2f");
+        ImGui::PopItemWidth();
+        ImGui::PopStyleVar();
+
+        ImGui::Columns(1);
+        ImGui::PopID();
+
+    }
+}

Editor/src/Views/Viewport.cpp

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

Editor/src/Views/Viewport.h

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

Editor/src/app.cpp

@@ -0,0 +1,59 @@
+#include "../../YoggieEngine/src/EntryPoint.h"
+#include <stack>
+#include "EditorLayer.h"
+
+
+using namespace YoggieEngine;
+
+class Editor : public Application {
+public:
+    Editor() : Application("Editor"){}
+
+    void Run() override
+    {
+
+
+        // Create EditorLayer
+        EditorLayer* firstLayer = new EditorLayer();
+   
+        firstLayer->OnStartup();
+        
+
+        double previous = glfwGetTime();
+        double lag = 0.0;
+        while (!appWindow->WindowShouldClose()) {
+            PollEvents();
+            double now = glfwGetTime();
+            double elapsed = now - previous;
+            previous = now;
+            lag += elapsed;
+            GuiBegin();
+            firstLayer->OnUpdate();
+            firstLayer->OnUI();
+            GuiEnd();
+
+            SwapBuffers();
+        }
+
+        firstLayer->OnDestroy();
+        
+
+    }
+
+
+
+private:
+
+
+    std::vector<Layer*> layers = std::vector<Layer*>();
+ 
+
+};
+
+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
+    - Vulkan 
-
+    - Metal (Possibly)
 - Logging
-    - Different for debug and release
+    - Different for debug and release    
-    - Different per OS
-    
 - Physics
     -  PhysX
-    - Alternative for non-nvidia stuff?!
+    -  Jolt Physics
-
+- Entity Component system
-- Basic Entity Component system
+- Graphical scripting (Possibly)
-
+- Scripting support
-- Graphical scripting ??
-
-- Scripting support ( idk what language)
     - LUA
+    - C# (for object orientated approaches to gamedev)
 - Configuration options 
-    - JSON 
+    - JSON
-    - LUA
+    - YAML
-    - others ?!?!?
+    - INI
 
-## Screenshots
+## More docs
-
+[Todo list](TODO.md)    \
-<img src="Screenshots/screen1.png" width="300"></img>
+[Planning](https://git.barink.dev/Nigel/MyGameEngine/projects)\
-<img src="Screenshots/screen2.png" width="300"></img>
+[Development](DEVELOPMENT.md)\
-
+[Show case](SHOWCASE.md)
-## 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
-```

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/models/Cube.mtl

@@ -1,12 +1,12 @@
-# Blender 3.1.2 MTL File: 'None'
+# Blender 3.1.2 MTL File: 'None'
-# www.blender.org
+# www.blender.org
-
+
-newmtl Material
+newmtl Material
-Ns 360.000000
+Ns 360.000000
-Ka 1.000000 1.000000 1.000000
+Ka 1.000000 1.000000 1.000000
-Kd 0.800000 0.800000 0.800000
+Kd 0.800000 0.800000 0.800000
-Ks 0.500000 0.500000 0.500000
+Ks 0.500000 0.500000 0.500000
-Ke 0.000000 0.000000 0.000000
+Ke 0.000000 0.000000 0.000000
-Ni 1.450000
+Ni 1.450000
-d 1.000000
+d 1.000000
-illum 2
+illum 2

SandboxApp/models/Cube.obj

@@ -1,40 +1,40 @@
-# Blender 3.1.2
+# Blender 3.1.2
-# www.blender.org
+# www.blender.org
-mtllib Cube.mtl
+mtllib Cube.mtl
-o Cube
+o Cube
-v 1.000000 1.000000 -1.000000
+v 1.000000 1.000000 -1.000000
-v 1.000000 -1.000000 -1.000000
+v 1.000000 -1.000000 -1.000000
-v 1.000000 1.000000 1.000000
+v 1.000000 1.000000 1.000000
-v 1.000000 -1.000000 1.000000
+v 1.000000 -1.000000 1.000000
-v -1.000000 1.000000 -1.000000
+v -1.000000 1.000000 -1.000000
-v -1.000000 -1.000000 -1.000000
+v -1.000000 -1.000000 -1.000000
-v -1.000000 1.000000 1.000000
+v -1.000000 1.000000 1.000000
-v -1.000000 -1.000000 1.000000
+v -1.000000 -1.000000 1.000000
-vn -0.0000 1.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
-vn -0.0000 -0.0000 1.0000
+vn -0.0000 -0.0000 1.0000
-vn -1.0000 -0.0000 -0.0000
+vn -1.0000 -0.0000 -0.0000
-vn -0.0000 -1.0000 -0.0000
+vn -0.0000 -1.0000 -0.0000
-vn 1.0000 -0.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
-vn -0.0000 -0.0000 -1.0000
+vn -0.0000 -0.0000 -1.0000
-vt 0.625000 0.500000
+vt 0.625000 0.500000
-vt 0.375000 0.500000
+vt 0.375000 0.500000
-vt 0.625000 0.750000
+vt 0.625000 0.750000
-vt 0.375000 0.750000
+vt 0.375000 0.750000
-vt 0.875000 0.500000
+vt 0.875000 0.500000
-vt 0.625000 0.250000
+vt 0.625000 0.250000
-vt 0.125000 0.500000
+vt 0.125000 0.500000
-vt 0.375000 0.250000
+vt 0.375000 0.250000
-vt 0.875000 0.750000
+vt 0.875000 0.750000
-vt 0.625000 1.000000
+vt 0.625000 1.000000
-vt 0.625000 0.000000
+vt 0.625000 0.000000
-vt 0.375000 1.000000
+vt 0.375000 1.000000
-vt 0.375000 0.000000
+vt 0.375000 0.000000
-vt 0.125000 0.750000
+vt 0.125000 0.750000
-s 0
+s 0
-usemtl Material
+usemtl Material
-f 1/1/1 5/5/1 7/9/1 3/3/1
+f 1/1/1 5/5/1 7/9/1 3/3/1
-f 4/4/2 3/3/2 7/10/2 8/12/2
+f 4/4/2 3/3/2 7/10/2 8/12/2
-f 8/13/3 7/11/3 5/6/3 6/8/3
+f 8/13/3 7/11/3 5/6/3 6/8/3
-f 6/7/4 2/2/4 4/4/4 8/14/4
+f 6/7/4 2/2/4 4/4/4 8/14/4
-f 2/2/5 1/1/5 3/3/5 4/4/5
+f 2/2/5 1/1/5 3/3/5 4/4/5
-f 6/8/6 5/6/6 1/1/6 2/2/6
+f 6/8/6 5/6/6 1/1/6 2/2/6