Base layout for the input manager

.gitignore

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

.gitmodules

@@ -4,14 +4,12 @@
 [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
-	ignore = untracked
 [submodule "GorrillaAudio"]
 	path = libs/GorillaAudio
 	url = https://github.com/mewspring/gorilla-audio.git
@@ -24,13 +22,6 @@
 [submodule "libs/steam-audio"]
 	path = libs/steam-audio
 	url = https://github.com/ValveSoftware/steam-audio.git
-	ignore = untracked
 [submodule "libs/physx"]
 	path = libs/physx
 	url = https://git.barink.dev/Nigel/PhysX.git
-[submodule "libs/entt"]
-	path = libs/entt
-	url = https://github.com/skypjack/entt.git
-[submodule "libs/guizmo"]
-	path = libs/guizmo
-	url = https://github.com/CedricGuillemet/ImGuizmo.git

.vscode/settings.json

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

BarinkEngine/BarinkEngine.cpp

@@ -0,0 +1,82 @@
+#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,4 +1,4 @@
-#include "EventEmitter.h"
+#include "../Include/EventSystem/EventEmitter.h"
 
 
 void EventEmitter::Subscribe(EventListener& subscriber)

BarinkEngine/Include/AssetManager/ModelImporter.h

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

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

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

BarinkEngine/Include/EventSystem/Event.h

@@ -5,7 +5,5 @@ struct Event
 {
   public:
     std::string name;
-    int argc;
-    void** argv;
     
 };

BarinkEngine/Include/EventSystem/EventEmitter.h

@@ -6,10 +6,12 @@ class EventEmitter {
 public: 
   void Subscribe (EventListener& subscriber);
   void Unsubscribe(EventListener& subscriber);
+  void EmitEvent(Event& incident);
+
 
 protected:
   std::list<EventListener*> subscribers;
-  void EmitEvent(Event& incident);
+
 
   EventEmitter();
 

BarinkEngine/Include/EventSystem/EventListener.cpp

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

BarinkEngine/Include/EventSystem/EventListener.h

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

BarinkEngine/Include/EventSystem/InputSystemEvents.h

@@ -0,0 +1,18 @@
+#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,7 +1,8 @@
 #pragma once
 #include <glad/glad.h>
 class Buffer {
-
+private:
+	unsigned int id;
 public:
 
 	int getBufferID();
@@ -15,7 +16,4 @@ public:
 
 	void Delete();
 
-private:
-	unsigned int id;
-
 };

BarinkEngine/Include/Graphics/GUI/GUIManager.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "../Platform/Window.h"
+#include "Graphics/Window.h"
 
 
 class GUIManager {

BarinkEngine/Include/Graphics/Material.h

@@ -7,8 +7,13 @@ class Material {
 public:
 	Material(const Shader& shader);
 	
-	void Apply()const;
+	void Apply();
+	
 	glm::vec3 Color;
+
+
+private:
 	const Shader& shader;
 	
+
 };

BarinkEngine/Include/Graphics/Mesh.h

@@ -0,0 +1,20 @@
+#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,8 +1,6 @@
 #pragma once
-#include "../BarinkEngine.h"
-#include "../Graphics/Memory/Buffer.h"
-#include "../Graphics/Memory/VertexArray.h"
-#include <vector>
+#include "BarinkEngine.h"
+#include <vector>;
 class RenderSurface 
 {
 public:

BarinkEngine/Include/Graphics/Renderable.h

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

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

@@ -14,7 +14,7 @@ class Shader {
         char* readFile (const char* filePath);
     public:
         Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath);
-        void Use() const;
+        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;

BarinkEngine/Include/Graphics/VertexArray.h

@@ -10,8 +10,6 @@ void Create();
 void Bind();
 void Unbind();
 
-unsigned int getID() { return id; }
-
 void Delete();
 
 void AttachAttribute(unsigned int index, int size, int stride);

BarinkEngine/Include/Graphics/Window.h

@@ -2,15 +2,12 @@
 #define GLFW_STATIC
 
 #include <glad/glad.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <iostream>
-
 #include <GLFW/glfw3.h>
-#include <spdlog/spdlog.h>
+#include "../Include/EventSystem/EventListener.h"
+
+
+
 
-#include "../EventSystem/Event.h"
-#include "../EventSystem/EventListener.h"
 
 class BarinkWindow : EventListener {
     private:
@@ -21,13 +18,16 @@ class BarinkWindow : EventListener {
 
         static bool InitGLFW();
 
+
+
+
     public:
         BarinkWindow(const int width, const int height);
         ~BarinkWindow();
 
         GLFWwindow* windowptr();
 
-        void ReceiveEvent(Event& incident) override ;
+        void ReceiveEvent(Event& incident) override;
         bool WindowShouldClose();
 
         void Poll();

BarinkEngine/Include/Input/GLFWInput.h

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

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

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

@@ -0,0 +1,47 @@
+#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/Input/GLFWInput.cpp

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

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

@@ -0,0 +1,52 @@
+#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,4 +1,4 @@
-#include "LuaScript.h"
+#include "Scripting/LuaScript.h"
 /*
 LuaScript::LuaScript(const std::string& path)
 : filePath(path) {

BarinkEngine/Scripting/LuaScriptingManager.cpp

@@ -1,4 +1,4 @@
-#include "LuaScriptingManager.h"
+#include "Scripting/LuaScriptingManager.h"
 /*
 LuaScriptingManager::LuaScriptingManager()
 {

BarinkEngine/graphics/Buffer.cpp

@@ -1,4 +1,4 @@
-#include "Buffer.h"
+#include "Graphics/Buffer.h"
 
 
 int Buffer::getBufferID() {

BarinkEngine/graphics/Camera.cpp

@@ -1,4 +1,4 @@
-#include "Camera.h"
+#include "Graphics/Camera.h"
 
 Camera::Camera(glm::vec3 position, glm::vec3 rotation, float zoom)
 : Position(position), Rotation(rotation), Zoom(zoom) {

BarinkEngine/graphics/GUI/GUIManager.cpp

@@ -0,0 +1,38 @@
+#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,11 +1,10 @@
-#include "Material.h"
+#include "../Include/Graphics/Material.h"
 
 Material::Material(const Shader& shader) :
 shader(shader) {
 }
 
-void Material::Apply() const  {
 
-	shader.Use();
+void Material::Apply() {
 	shader.setUniformVec3("Color", Color);
 }

BarinkEngine/graphics/ModelImporter.cpp

@@ -1,32 +1,17 @@
-#include "ModelImporter.h"
-#include "spdlog/spdlog.h"
+#include "AssetManager/ModelImporter.h"
 
-BarinkEngine::SceneObject* BarinkEngine::ModelImporter::Import(const std::string path)
+
+std::vector<BarinkEngine::Mesh> ModelImporter::Import(std::string path)
 {
-    SceneObject* root = new SceneObject(std::string(path), nullptr);
-
     Assimp::Importer importer;
-    const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
-
+    const aiScene* scene = importer.ReadFile(path.c_str(), aiProcess_Triangulate | aiProcess_FlipUVs);
     aiNode* currentNode = scene->mRootNode;
 
-    std::vector<BarinkEngine::Mesh> meshes =  processNode(currentNode, scene);
-    
-    std::cout << "[DEBUG]: Loaded "<< meshes.size() << " meshes!" << std::endl;
-    
-    // create a renderable (per mesh ?? ) 
-    root->renderable = new Renderable();
-    root->renderable->mesh = new Mesh(meshes[0]);
-
-    return root;   
-
+    return processNode(currentNode, scene);
 }
 
-std::vector<BarinkEngine::Mesh> BarinkEngine::ModelImporter::processNode(aiNode* node, const aiScene* 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));
@@ -43,24 +28,10 @@ std::vector<BarinkEngine::Mesh> BarinkEngine::ModelImporter::processNode(aiNode*
     return meshes;
 }
 
-BarinkEngine::Mesh BarinkEngine::ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
+BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
     std::vector<unsigned int> indices;
     std::vector<BarinkEngine::Vertex> vertices;
 
-    ProcessVertices(mesh, vertices);
-    
-    ProcessIndices(mesh, indices);
-
-    BarinkEngine::Mesh result;
-    result.vertices = vertices;
-    result.elements = indices;
-
-
-    return result;
-
-}
-
-void ProcessVertices(aiMesh* mesh, std::vector<BarinkEngine::Vertex>& out_vertices) {
     // Process vertices
     for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
         BarinkEngine::Vertex v{};
@@ -82,18 +53,28 @@ void ProcessVertices(aiMesh* mesh, std::vector<BarinkEngine::Vertex>& out_vertic
 
         }
     
-        out_vertices.push_back(v);
+        vertices.push_back(v);
     }
-}
 
-void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices) {
     // 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++) {
-            out_indices.push_back(face.mIndices[j]);
+            indices.push_back(face.mIndices[j]);
         }
     }
+
+    
+
+    BarinkEngine::Mesh result;
+    
+
+    result.vertices = vertices;
+    result.elements = indices;
+
+
+    return result;
+
 }

BarinkEngine/graphics/RenderSurface.cpp

@@ -1,4 +1,4 @@
-#include "RenderSurface.h";
+#include "Graphics/RenderSurface.h";
 
 RenderSurface::RenderSurface(){
 	shader = new Shader("build/SandboxAppliction/Debug/renderSuface.vs", "build/SandboxApplication/Debug/renderSurface.fs");

BarinkEngine/graphics/Renderable.cpp

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

@@ -0,0 +1,25 @@
+#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,6 +1,5 @@
-#include "Shader.h"
+#include "Graphics/Shader.h"
 #include "spdlog/spdlog.h"
-
 Shader::Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath)
 {
     char infoLog[512];
@@ -58,12 +57,8 @@ Shader::Shader(const std::string vertexShaderPath, const std::string fragmentSha
 
 
 }
-
 char* Shader::readFile (const char* filePath){
 
-    spdlog::info("Opening {} ", filePath);
-
-
     std::ifstream file ;
     file.open(filePath);
 
@@ -95,7 +90,7 @@ char* Shader::readFile (const char* filePath){
     return FileBuffer;
 }
 
-void Shader::Use() const
+void Shader::Use()
 {
     glUseProgram(id);
 }

BarinkEngine/graphics/Texture.cpp

@@ -1,8 +1,8 @@
-#include "Texture.h"
+#include "../Include/Graphics/Texture.h"
 #include <glad/glad.h>
 #include <GLFW/glfw3.h>
 #define STB_IMAGE_IMPLEMENTATION
-#include "../stb_image.h"
+#include "Graphics/stb_image.h"
 #include <iostream>
 
 Texture::Texture(const std::string texturePath) {

BarinkEngine/graphics/VertexArray.cpp

@@ -1,4 +1,4 @@
-#include "VertexArray.h"
+#include "Graphics/VertexArray.h"
 #include <glad/glad.h>
 
 void VertexArray::Create(){

BarinkEngine/graphics/shaders/fragment.shader

@@ -7,5 +7,5 @@ uniform sampler2D Texture;
 
 
 void main(){
-	FragColor = vec4(color , 1.0f); // mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 1.0f);
+	FragColor = mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 0.5f);
 }

BarinkEngine/graphics/window.cpp

@@ -1,4 +1,10 @@
-#include "Window.h"
+#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())
@@ -11,21 +17,11 @@ bool BarinkWindow::InitGLFW(){
 }
 
 BarinkWindow::BarinkWindow(const int width, const int height) :
-Width(width), Height(height), FullScreen(false)
-{
+Width(width), Height(height), FullScreen(false){
 	if (InitGLFW()==false) {
 		exit(-1);
 	}
 
-	glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE);
-	glfwWindowHint(GLFW_FOCUS_ON_SHOW, GLFW_TRUE);
-	// No window decorations such as a border, a close widget
-	// glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);
-	// glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);
-	// Disable resizing the window
-	//glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
-
-
 	window = glfwCreateWindow(Width, Height, "BarinkEngine", NULL, NULL);
 
 	if( !window)
@@ -55,6 +51,7 @@ Width(width), Height(height), FullScreen(false)
 
 }
 
+
 BarinkWindow::~BarinkWindow(){
 
 	glfwTerminate();
@@ -79,8 +76,12 @@ void BarinkWindow::SwapBuffers()
 	glfwSwapBuffers(window);
 }
 
+
 void BarinkWindow::ReceiveEvent(Event& incident)
 {
-	//std::cout << "EVENT RECEIVED: " <<  incident.name << std::endl;
-}
 
+	
+
+	std::cout << "EVENT RECEIVED: " <<  incident.name << std::endl;
+
+}

BarinkEngine/premake5.lua

@@ -4,24 +4,24 @@ project "BarinkEngine"
   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/glad/include",
-
-
-    "../libs/assimp/include",
-    "../libs/entt/src",
-    
-    "../libs/physx/physx/include",
-    
-    "../libs/lua/include",
-
-    "../libs/GorillaAudio/include",
-    "../libs/steam-audio/include",
-
+    "../libs/glm",
     
     "../libs/ImGui",
   }
@@ -33,7 +33,11 @@ project "BarinkEngine"
     "spdlog",
     "assimp-vc143-mtd",
     "glfw3",
-    "ImGui",
+
+    "ImGUI_Opengl3",
+
+    
+
   }
 
 
@@ -48,16 +52,32 @@ project "BarinkEngine"
   files {
     "../libs/glad/src/glad.c",
 
-    "./src/*.cpp",
-    "./src/*.h",
-    "./src/**/*.cpp",
-    "./src/**/*.h"
+    "./*.cpp",
+    "./*.h",
+    "./**/*.cpp",
+    "./**/*.h"
   }
 
-  prebuildcommands 
-  {
-    ok,err = os.copyfile("BarinkEngine/src/Graphics/shaders/*" ,"SandboxApp/build/Debug/")
-  }
+
+
+  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')
-include("../ImGuizmo")

BarinkEngine/src/AssetManager/ModelImporter.h

@@ -1,35 +0,0 @@
-#pragma once
-#define STB_IMAGE_IMPLEMENTATION
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-
-#define TINYGLTF_IMPLEMENTATION
-#define TINYGLTF_NO_EXTERNAL_IMAGE
-
-#include "../Graphics/Primitives/Mesh.h"
-#include <assimp/Importer.hpp>
-#include <assimp/scene.h>
-#include <assimp/postprocess.h> 
-#include <string>
-#include "../Scene/TransformTree/SceneNodeTypes.h"
-
-
-void ProcessVertices(aiMesh* mesh, std::vector<BarinkEngine::Vertex>& out_vertices);
-void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices);
-
-namespace BarinkEngine {
-	class ModelImporter {
-
-	public:
-
-		BarinkEngine::SceneObject* Import(const 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/src/BarinkEngine.cpp

@@ -1,88 +0,0 @@
-#include "BarinkEngine.h"
-
-extern EngineStatistics ES;
-BarinkEngine::Renderer renderer;
-const unsigned int MS_PER_UPDATE = 2;
-int main(int argc, char* argv[]) {
-	// Setup performance sampler 
-	EngineInstrumentation::PerfomanceSamplerInit();
-
-	// Startup services 
-	BarinkWindow MainWindow =  BarinkWindow(1200, 700);
-
-	renderer = BarinkEngine::Renderer();
-	InputSystem = BarinkEngine::InputManager();
-
-	ES = EngineStatistics{};
-	InputSystem.attach(&MainWindow);
-
-	GUIManager GUISystem = GUIManager(&MainWindow);
-
-	glEnable(GL_DEPTH_TEST);
-
-	// First call to setup game
-	{
-		PerfSampler("Start");
-		Start();
-	}
-
-
-	double previous = glfwGetTime();
-	double lag = 0.0;
-
-	// Runtime loop
-	while (!MainWindow.WindowShouldClose()) 
-	{
-	
-		double current = glfwGetTime();
-		double elapsed = current - previous;
-		previous = current;
-		lag += elapsed;
-
-		//EngineInstrumentation::Update(); // Todo this does nothing right now and is therefor disabled
-
-		// Execute main logic 
-		{
-			PerfSampler("PollEvents");
-			InputSystem.PollEvents();
-
-		}
-		
-		{
-			PerfSampler("Update");
-			while (lag >= MS_PER_UPDATE) {
-				Update();
-				lag -= MS_PER_UPDATE;
-			}
-		}
-
-		{
-			PerfSampler("Render");
-			Render();
-		}
-		
-		{
-			PerfSampler("GUI-Render");
-			GUISystem.Render();
-		}
-		
-
-		{
-			PerfSampler("BufferSwap");
-			MainWindow.SwapBuffers();
-			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		}
-		
-	}
-
-	// Shutdown game
-	{
-		PerfSampler("Stop");
-		Stop();
-	}
-	
-	// Shutdown Services
-
-	return 0;
-}
-

BarinkEngine/src/BarinkEngine.h

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

BarinkEngine/src/EventSystem/EventListener.h

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

BarinkEngine/src/GUI/GUIManager.cpp

@@ -1,61 +0,0 @@
-#include "GUIManager.h"
-#include "imgui.h"
-#include "backends/imgui_impl_opengl3.h"
-#include <backends/imgui_impl_glfw.h>
-#include "../../libs/guizmo/ImGuizmo.h"
-#include "../BarinkEngine.h"
-
-GUIManager::GUIManager(BarinkWindow* window)
-    : currentwindow(window)
-{
-    IMGUI_CHECKVERSION();
-    ImGui::CreateContext();
-    ImGuiIO& io = ImGui::GetIO();
-    io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_ViewportsEnable;
-    io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_DockingEnable;
-    
-    ImGui::StyleColorsDark();
-
-    ImGui_ImplGlfw_InitForOpenGL(currentwindow->windowptr(), true);
-    ImGui_ImplOpenGL3_Init("#version 440");
-
-
-}
-
-GUIManager::~GUIManager()
-{
-    ImGui_ImplOpenGL3_Shutdown();
-    ImGui_ImplGlfw_Shutdown();
-    ImGui::DestroyContext();
-}
-
-void GUIManager::Render()
-{
-    ImGui_ImplGlfw_NewFrame();
-    ImGui_ImplOpenGL3_NewFrame();
-
-    ImGui::NewFrame();
-
-    ImGuizmo::SetOrthographic(true);
-    ImGuizmo::BeginFrame();
- 
-    
-
-    ImmediateGraphicsDraw();
-  
-    
-
-    ImGui::EndFrame();
-
-
-    ImGui::Render();
-    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-
-    if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
-    {
-        GLFWwindow* last_context = glfwGetCurrentContext();
-        ImGui::UpdatePlatformWindows();
-        ImGui::RenderPlatformWindowsDefault();
-        glfwMakeContextCurrent(last_context);
-    }
-}

BarinkEngine/src/Graphics/Memory/FrameBuffer.cpp

@@ -1,71 +0,0 @@
-#include "Framebuffer.h"
-#include <iostream>
-
-Framebuffer::Framebuffer() 
-{
-	glGenFramebuffers(1, &Id);
-	glBindFramebuffer(GL_FRAMEBUFFER, Id);
-
-	// Create a colour texture!
-	glGenTextures(1, &ColourAttachment);
-	glBindTexture(GL_TEXTURE_2D, ColourAttachment);
-
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ColourAttachment, 0);
-
-
-
-	// Create a depth buffer 
-	glGenTextures(1, &DepthAttachment);
-	glBindTexture(GL_TEXTURE_2D, DepthAttachment);
-
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, NULL);
-	
-	glBindTexture(GL_TEXTURE_2D, 0);
-
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, DepthAttachment, 0);
-
-
-	/*
-	* // Render buffer 
-		glGenRenderbuffers(1, &DepthAttachment);
-		glBindRenderbuffer(GL_RENDERBUFFER, DepthAttachment);
-
-		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 800, 600);
-
-
-		glBindRenderbuffer(GL_RENDERBUFFER, 0);
-		
-		glFramebufferRenderbuffer(GL_RENDERBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, DepthAttachment);
-
-	*/
-	
-	
-
-
-
-	if (!glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE)
-	{
-		std::cout << "Framebuffer is incomplete!" << std::endl;
-	}
-	else {
-		std::cout << "Framebuffer is complete!" << std::endl;
-	}
-
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	
-
-}
-
-Framebuffer::~Framebuffer() 
-{
-	glDeleteTextures(1, &ColourAttachment);
-	glDeleteRenderbuffers(1, &DepthAttachment);
-	glDeleteFramebuffers(1, &Id);
-}

BarinkEngine/src/Graphics/Memory/Framebuffer.h

@@ -1,21 +0,0 @@
-#pragma once
-#include <glad/glad.h>
-#include <glm/glm.hpp>
-
-class Framebuffer {
-
-public:
-	Framebuffer();
-	~Framebuffer();
-
-	GLuint GetId() { return Id; }
-	GLuint GetColourAttachment() { return ColourAttachment; }
-	GLuint GetDepthAttachment() { return DepthAttachment; }
-
-private:
-	GLuint Id = 0;
-	GLuint ColourAttachment = 0;
-	GLuint DepthAttachment = 0;
-	
-
-};

BarinkEngine/src/Graphics/Memory/UniformBuffer.cpp

@@ -1,31 +0,0 @@
-#include "UniformBuffer.h"
-#include <glad/glad.h>
-UniformBuffer::UniformBuffer(unsigned int size)
-{
-	glGenBuffers(1, &Id );
-	glBindBuffer(GL_ARRAY_BUFFER, Id);
-	glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_DYNAMIC_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-UniformBuffer::~UniformBuffer() 
-{
-	glDeleteBuffers(1, &Id);
-}
-
-
-void UniformBuffer::setData( unsigned int offset , unsigned int size , void* data)
-{
-	glBindBuffer(GL_ARRAY_BUFFER, Id);
-	glBufferSubData(GL_ARRAY_BUFFER, offset , size, data);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-void UniformBuffer::setDescriptor(unsigned int index, unsigned int size , unsigned int stride, void* pointer)
-{
-	glBindBuffer(GL_ARRAY_BUFFER, Id);
-	glVertexAttribPointer(index, size, GL_FLOAT, GL_FALSE, stride, pointer);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-

BarinkEngine/src/Graphics/Memory/UniformBuffer.h

@@ -1,15 +0,0 @@
-#pragma once
-
-class UniformBuffer {
-public:
-
-	UniformBuffer (unsigned int size);
-	~UniformBuffer();
-	void setData(unsigned int offset, unsigned int size, void* data);
-	void setDescriptor(unsigned int index, unsigned int size, unsigned int stride, void* pointer);
-
-
-private:
-	unsigned int Id;
-
-};

BarinkEngine/src/Graphics/Primitives/Mesh.h

@@ -1,12 +0,0 @@
-#pragma once
-#include <vector>
-#include <glm/glm.hpp>
-#include "Vertex.h"
-
-namespace BarinkEngine {
-	struct Mesh {
-		std::vector<Vertex> vertices;
-		std::vector<unsigned int> elements;
-	};
-
-}

BarinkEngine/src/Graphics/Primitives/Vertex.h

@@ -1,9 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-
-namespace BarinkEngine {
-	struct Vertex {
-		glm::vec3 vertices;
-		glm::vec2 uv;
-	};
-}

BarinkEngine/src/Graphics/Renderable.h

@@ -1,14 +0,0 @@
-#pragma once
-#include "Primitives/Mesh.h"
-#include "Primitives/Material.h"
-#include "Primitives/Texture.h"
-#include "../Scene/Scene.h"
-
-namespace BarinkEngine {
-
-	struct  Renderable {
-		BarinkEngine::Mesh* mesh;
-		Material* material;
-		Texture* texture;
-	};
-}

BarinkEngine/src/Graphics/Renderer.cpp

@@ -1,93 +0,0 @@
-#include "Renderer.h"
-#include "../Scene/Components.h"
-#include "../Graphics/Memory/VertexArray.h"
-#include "../Graphics/Memory/Buffer.h"
-#include <glad/glad.h>
-
-float Angle = 0.0;
-Camera cam = Camera(glm::vec3(12.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), 90.0f);
-glm::mat4 projection = glm::perspective(glm::radians(cam.Zoom), (800.0f / 600.0f), 0.001f, 100.0f);
-
-BarinkEngine::Renderer::Renderer(){}
-
-BarinkEngine::Renderer::~Renderer(){}
-
-void BarinkEngine::Renderer::Prepare(Scene& scene ) {
-	auto group = scene.getReg().view<BarinkEngine::Render3DComponent>();
-	group.each([](auto enity, BarinkEngine::Render3DComponent& renderComponent) {
-		VertexArray va = VertexArray();
-		Buffer vertexBuffer = Buffer();
-		Buffer elementBuffer = Buffer();
-
-		va.Create();
-		va.Bind();
-
-		vertexBuffer.createBuffer();
-		vertexBuffer.Bind(false);
-		vertexBuffer.setBufferData((void*)&renderComponent.mesh.vertices[0], renderComponent.mesh.vertices.size() * sizeof(BarinkEngine::Vertex), false);
-
-		elementBuffer.createBuffer();
-		elementBuffer.Bind(true);
-		elementBuffer.setBufferData((void*)&renderComponent.mesh.elements[0], renderComponent.mesh.elements.size() * sizeof(unsigned int), true);
-
-		va.AttachAttribute(0, 3, sizeof(BarinkEngine::Vertex));
-
-		glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(BarinkEngine::Vertex), (void*)0);
-		glEnableVertexAttribArray(0);
-		glEnableVertexAttribArray(1);
-
-		va.Unbind();
-		vertexBuffer.Unbind(false);
-		elementBuffer.Unbind(true);
-
-		renderComponent.VAO = va.getID();
-		renderComponent.IBO = elementBuffer.getBufferID();
-	});
-}
-
-
-
-void BarinkEngine::Renderer::Render(Scene& scene)
-{
-	auto group = scene.getReg().view<TransformComponent, Render3DComponent>();
-	group.each([&](auto entity , TransformComponent& trans, Render3DComponent& renderComponent) 
-		{
-		glBindVertexArray(renderComponent.VAO);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderComponent.IBO);
-
-		renderComponent.shader.Use();
-
-		auto lights = scene.getReg().view<LightComponent>();
-		lights.each([&](auto entity, LightComponent& light) {
-		  	renderComponent.shader.setUniformVec3("lighting.color", light.Color);
-			renderComponent.shader.setUniformFloat("lighting.strength", light.Strength);
-		});
-
-		renderComponent.shader.setUniformVec3("Color", renderComponent.color);
-		renderComponent.shader.setUniformMat4("M", trans.transform);
-		renderComponent.shader.setUniformMat4("V", cam.GetViewMatrix());
-		renderComponent.shader.setUniformMat4("P", projection);
-
-		//std::cout << "Draw " << renderComponent.mesh.elements.size() << " elements" << std::endl;
-		glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(renderComponent.mesh.elements.size()) ,
-			GL_UNSIGNED_INT, NULL);
-
-		glBindVertexArray(0);
-	});
-
-}
-
-void BarinkEngine::Renderer::Render(Framebuffer& framebuffer, Scene& scene)
-{
-
-	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer.GetId());
-
-	glClearColor(.5f, .0f, .5f, 1.0f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-	Render(scene);
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-
-

BarinkEngine/src/Graphics/Renderer.h

@@ -1,27 +0,0 @@
-#pragma once
-#include <vector>
-#include <iostream>
-#include <glm/gtc/matrix_transform.hpp>
-#include "glad/glad.h"
-#include "GLFW/glfw3.h"
-
-#include "../PerfCounter.h"
-
-#include "Primitives/Camera.h"
-#include "Renderable.h"
-#include "Memory/Framebuffer.h"
-#include "../Scene/Components.h"
-
-namespace BarinkEngine {
-
-	class Renderer {
-	public:
-		Renderer();
-		~Renderer();
-
-		void Prepare(Scene& scene);
-		void Render(Scene& scene );
-
-		void Render(Framebuffer& framebuffer, Scene& scene);
-	};
-}

BarinkEngine/src/Input/InputManager.cpp

@@ -1,119 +0,0 @@
-#include "InputManager.h"
-
-BarinkEngine::InputManager InputSystem;
-
-void BarinkEngine::InputManager::PollEvents()
-{
-	for (auto it = windows.begin(); it != windows.end(); ++it) {
-		auto window = *it;
-		window->Poll();
-
-	}
-}
-
-void BarinkEngine::InputManager::KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) 
-{
-
-	Event KeyEvent{};
-	KeyEvent.name = "KEY";
-	 
-	InputSystem.EmitEvent(KeyEvent);
-
-
-	if (key == GLFW_KEY_A && action == GLFW_PRESS)
-	{
-		
-		std::cout << "'a' key was pressed" << std::endl;
-	}
-
-}
-
-void BarinkEngine::InputManager::CursorPositionCallback(GLFWwindow* window, double x, double y) 
-{
-	//std::cout << "Cursor Position  x: " << x << ", y: " << y << std::endl;
-	Event CursorPosUpdate{};
-	CursorPosUpdate.name = "UPDATE::CURSOR:POSITION";
-
-	InputSystem.EmitEvent(CursorPosUpdate);
-
-
-
-}
-
-void BarinkEngine::InputManager::CursorEnterCallback(GLFWwindow* window, int entered)
-{
-	if (entered) {
-		Event mouseEntered {};
-		mouseEntered.name = "Mouse Entered Window's confines!";
-		mouseEntered.argc = 0;
-		
-		InputSystem.EmitEvent(mouseEntered);
-
-		
-
-	}
-	else {
-		Event mouseLeft{};
-		mouseLeft.name = "Mouse Left Window's confines!";
-		mouseLeft.argc = 0;
-
-		InputSystem.EmitEvent(mouseLeft);
-
-
-	}
-}
-
-
-void BarinkEngine::InputManager::MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
-{
-
-	Event MouseButtonEvent{};
-	MouseButtonEvent.name = "MOUSEBUTTON";
-
-	InputSystem.EmitEvent(MouseButtonEvent);
-
-
-	if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
-		std::cout << "Right mouse button was pressed!" << std::endl;
-	}
-
-}
-
-void BarinkEngine::InputManager::ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
-{
-	std::cout << "Scroll: x: " << xoffset << ", y: " << yoffset << std::endl;
-	
-	Event ScrollEvent{};
-	ScrollEvent.name = "SCROLL";
-
-	InputSystem.EmitEvent(ScrollEvent);
-
-
-}
-
-
-void BarinkEngine::InputManager::attach(BarinkWindow* window)
-{
-	
-	windows.push_back(window);
-
-	// Attach callbacks
-	glfwSetKeyCallback(window->windowptr(), KeyCallback);
-	glfwSetCursorPosCallback(window->windowptr(), CursorPositionCallback);
-	glfwSetCursorEnterCallback(window->windowptr(), CursorEnterCallback);
-	glfwSetMouseButtonCallback(window->windowptr(), MouseButtonCallback);
-	glfwSetScrollCallback(window->windowptr(), ScrollCallback);
-
-	this->Subscribe( (EventListener&)(*window));
-
-
-
-}
-
-BarinkEngine::InputManager::InputManager() : EventEmitter ()
-{
-	windows = std::vector<BarinkWindow*>();
-}
-
-
-

BarinkEngine/src/Input/InputManager.h

@@ -1,31 +0,0 @@
-#pragma once
-#include <vector>
-#include <iostream>
-
-#include "spdlog/spdlog.h"
-#include "../EventSystem/EventEmitter.h"
-#include "../EventSystem/EventListener.h"
-#include "../Platform/Window.h"
-
-namespace BarinkEngine {
-
-	class InputManager : EventEmitter {
-	public:
-		InputManager();
-
-		void PollEvents();
-		void attach(BarinkWindow* window);
-
-		// GLFW Handlers
-		static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
-		static void CursorPositionCallback(GLFWwindow* window, double x, double y);
-		static void CursorEnterCallback(GLFWwindow* window, int entered);
-		static void MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
-		static void ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
-	private:
-		std::vector<BarinkWindow*> windows;
-
-	};
-}
-
-extern BarinkEngine::InputManager InputSystem;

BarinkEngine/src/PerfCounter.cpp

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

BarinkEngine/src/PerfCounter.h

@@ -1,37 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-#include <chrono>
-struct EngineStatistics {
-	float frameTime;
-	uint32_t verts;
-	uint32_t DC;
-
-	int64_t frames;
-	int64_t  FPS;
-
-};
-
-class EngineInstrumentation {
-public:
-
-	//static int64_t lastSampleTime;
-
-	static uint64_t GetPrecisionTime();
-	static void PerfomanceSamplerInit();
-
-	static void Update();
-	static void ShowStats();
-
-};
-
-class PerfSampler {
-public:
-
-	PerfSampler(const std::string& name);
-	~PerfSampler();
-	void Stop();
-private:
-	const std::string& name;
-	std::chrono::time_point<std::chrono::high_resolution_clock> startTime;
-};

BarinkEngine/src/Scene/Components.h

@@ -1,46 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include "../Graphics/Primitives/Shader.h"
-#include "../Graphics/Primitives/Mesh.h"
-namespace BarinkEngine {
-	struct IdentifierComponent {
-		std::string name;
-	};
-
-	struct TransformComponent {
-		glm::mat4 transform = glm::mat4(1.0f);
-
-	};
-
-	struct LightComponent {
-		float Strength = 1.0f;
-		glm::vec3 Color = glm::vec3(1.0f, 1.0f, 1.0f);
-
-	};
-
-
-	struct CameraComponent {
-		glm::mat4 view;
-
-	};
-
-	struct Render3DComponent {
-		unsigned int VAO = 0;
-		unsigned int IBO = 0;
-		Mesh mesh;
-		// TODO: becomes a material 
-		glm::vec3 color;
-		Shader shader;
-
-		Render3DComponent()
-			: shader(Shader("build/Debug/test.vs", "build/Debug/test.fs")),
-			  color(glm::vec3(1.0f, 0.0f, 0.0f))
-		{ 
-		}
-	};
-
-	struct Render2DComponent {
-		glm::vec3 Colour;
-		
-	};
-};

BarinkEngine/src/Scene/Entity.cpp

@@ -1,7 +0,0 @@
-#include "Entity.h"
-
-Entity::Entity(entt::entity e, Scene* scene)
-	: m_entity(e), m_scene(scene)
-{
-}
-

BarinkEngine/src/Scene/Entity.h

@@ -1,27 +0,0 @@
-#pragma once
-#include <entt/entt.hpp>
-class Scene;
-
-class Entity {
-public:
-	Entity() = default;
-	Entity(entt::entity e, Scene* scene);
-	Entity(const Entity& other) = default;
-
-
-	template<class T >
-	T& AddComponent() {
-		return m_scene->m_registry.emplace<T>(m_entity);
-	}
-
-	template<class T> 
-	T& GetComponent() {
-		return m_scene->m_registry.get<T>(m_entity);
-	}
-
-private:
-	entt::entity m_entity;
-	Scene* m_scene;
-
-};
-

BarinkEngine/src/Scene/Scene.cpp

@@ -1,23 +0,0 @@
-#include "Scene.h"
-#include "Entity.h"
-#include "Components.h"
-Scene::Scene()
-{
-	m_registry = entt::basic_registry();
-}
-
-Scene::~Scene()
-{}
-
-Entity Scene::AddEntity(std::string name)
-{
-	Entity entity = { m_registry.create(), this };
-
-	auto& ident = entity.AddComponent<BarinkEngine::IdentifierComponent>();
-	ident.name = name;
-	entity.AddComponent<BarinkEngine::TransformComponent>();
-
-
-	return entity;
-}
-

BarinkEngine/src/Scene/Scene.h

@@ -1,22 +0,0 @@
-#pragma once
-#include <string>
-#include <entt/entt.hpp>
-class Entity;
-
-class Scene
-{
-public:
-	Scene();
-	~Scene();
-
-	Entity AddEntity(std::string name);
-
-	entt::registry& getReg() { return m_registry; }
-
-private:
-	entt::registry m_registry;
-
-	friend class Entity;
-};
-
-

BarinkEngine/src/Scene/TransformTree/Node.cpp

@@ -1,7 +0,0 @@
-#include "Node.h"
-
-Node::Node(const std::string& name) 
-	: name(name), parent(nullptr), children(std::vector<Node*>()) {}
-
-Group::Group(const std::string& name ) 
-	: Node(name) {}

BarinkEngine/src/Scene/TransformTree/Node.h

@@ -1,22 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-class Node {
-	public:
-		Node(const std::string& name);
-		std::string name;
-		Node* parent;
-		std::vector<Node*> children;
-
-		void addChild(Node& node);
-
-};
-
-
-
-class Group : public Node {
-public:
-	Group(const std::string& name);
-
-};

BarinkEngine/src/Scene/TransformTree/SceneNodeTypes.cpp

@@ -1,12 +0,0 @@
-#include "SceneNodeTypes.h"
-
-BarinkEngine::SceneCamera::SceneCamera()
-	: Group(std::string("Camera")), camera(Camera(glm::vec3(0.0f), glm::vec3(0.0f), 0))
-{}
-
-BarinkEngine::SceneObject::SceneObject(std::string name, Renderable* visual)
-	: Group(name), renderable(visual)
-{}
-
-BarinkEngine::SceneObject::~SceneObject() 
-{}

BarinkEngine/src/Scene/TransformTree/SceneNodeTypes.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "../../Graphics/Primitives/Camera.h"
-#include "../../Graphics/Renderable.h"
-#include "Node.h"
-
-namespace BarinkEngine {
-	class SceneCamera : public Group
-	{
-	public:
-		Camera& camera;
-		SceneCamera();
-	};
-
-
-	class SceneObject : public Group
-	{
-	public:
-		SceneObject(std::string name, Renderable* visual);
-		~SceneObject();
-		Renderable* renderable;
-	};
-}

Editor/premake5.lua

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

Editor/src/main.cpp

@@ -1,130 +0,0 @@
-#include "../../BarinkEngine/src/BarinkEngine.h"
-#include "../../BarinkEngine/src/AssetManager/ModelImporter.h"
-#include "../../BarinkEngine/src/Graphics/Memory/Framebuffer.h"
-#include <imgui.h>
-#include "../../BarinkEngine/src/PerfCounter.cpp"
-#include "../../BarinkEngine/src/Scene/Entity.h"
-#include "stb_image.h"
-#include "../../libs/guizmo/ImGuizmo.h"
-#include "../../libs/glm/glm/gtc/type_ptr.hpp"
-#include <glm/gtc/matrix_transform.hpp>
-#include "widgets/widgets.h"
-/*
-* Define globals
-*/
-
-Framebuffer* framebuffer;
-Scene Level1;
-BarinkEngine::SceneObject* Model;
-Entity cube;
-
-/*
-* Runs once at startup
-* - USe to initialize the game/sandbox/demo
-*/
-void Start() {
-
-
-    auto io = ImGui::GetIO();
-    io.Fonts->AddFontFromFileTTF("build/Debug/Fonts/Roboto-Regular.ttf", 18);
-    framebuffer = new Framebuffer();
-    // Build a basic test scene 
-    // NOTE: This will later be done through an editor 
-
-    // Create a level and load it as the current level
-    auto importer = BarinkEngine::ModelImporter();
-    
-    // Create a cube 
-    Model = importer.Import("build/Debug/Models/Cube.obj");
-    cube = Level1.AddEntity("cube");
-    auto& render3DComponent = cube.AddComponent<BarinkEngine::Render3DComponent>();
-    render3DComponent.mesh = *(Model->renderable->mesh);
-
-    cube.GetComponent<BarinkEngine::TransformComponent>().transform = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f, 0.0f, 5.0f));
-    renderer.Prepare(Level1);
-    
-
-    // create an ambient light source
-    auto AmbientLight = Level1.AddEntity("AmbientLight");
-    AmbientLight.AddComponent<BarinkEngine::LightComponent>();
-
-    std::cout << "Colour attachment id; " << framebuffer->GetColourAttachment() << std::endl;   
-
-    renderer.Prepare(Level1);
-
-
-}
-/*
-* Runs every frame
-* - Use to draw Immediate mode graphics (Not meant for HUD's )
-*/
-void ImmediateGraphicsDraw()
-{   ImGui::DockSpaceOverViewport(ImGui::GetMainViewport());
-     
-    // Show a menu bar
-    ImGui::BeginMainMenuBar();
-
-    if (ImGui::BeginMenu("Application")) {
-
-        if (ImGui::MenuItem("Preferences")) {
-
-        }
-
-        if (ImGui::MenuItem("Exit")) {
-            // TODO: Exit application
-        }
-
-        ImGui::EndMenu();
-    }
-
-    ImGui::EndMainMenuBar();
-
-
-    // Show internal BarinkEngine stats
-    //ShowStats();
-    Viewport(*framebuffer , Level1);
-    Inspector();
-    SceneExplorer(Level1);
-    Settings();
-    AssetsFinder();
-    Console();
-
-
-
-
-   ImGui::ShowMetricsWindow();
-   
-
-}
-
-void Render() 
-{
-    renderer.Render( *framebuffer, Level1);
-}
-
-
-/*
-* Runs every frame
-* - Meant for game logic ( non-physics related)
-*/
-void Update()
-{
-
-}
-
-/*
-* Runs every physics update
-*/
-void fixed_update() 
-{
-    
-}
-
-/*
-* Runs at the end of the program
-* - Meant for cleanup
-*/
-void Stop()
-{
-    delete framebuffer;
-}

Editor/src/widgets/widgets.h

@@ -1,79 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-#include <imgui.h>
-
-inline void Inspector ()  {
-    ImGui::Begin("Inspector");
-    static float Zoom = 90;
-    static glm::vec3 Position = glm::vec3(0.0f, 0.0f, 0.0f);
-    static glm::vec3 Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
-
-    ImGui::BeginChild("Camera");
-
-    ImGui::SliderFloat("Zoom", &Zoom, 10, 190);
-    ImGui::InputFloat3("Position:", &Position[0]);
-
-    ImGui::InputFloat3("Rotation:", &Rotation[0]);
-    ImGui::EndChild();
-
-
-    ImGui::BeginChild("Scripting");
-    ImGui::Text("Hello world!");
-    ImGui::EndChild();
-    ImGui::End();
-}
-
-inline void SceneExplorer(Scene& scene) 
-{
-
-    ImGui::Begin("Scene Explorer");
-
-    scene.getReg().each([&](auto entity) {
-        auto id = scene.getReg().get<BarinkEngine::IdentifierComponent>(entity);
-        ImGui::LabelText("##myObject", "%s", id.name.c_str());
-        });
-
-
-    ImGui::End();
-}
-
-inline void Viewport(Framebuffer& framebuffer , Scene& scene ) {
-
-    unsigned int viewportWindowFlags = ImGuiWindowFlags_NoTitleBar 
-        | ImGuiWindowFlags_NoDecoration 
-        | ImGuiWindowFlags_NoScrollbar
-        | ImGuiWindowFlags_NoMove
-        | ImGuiWindowFlags_NoCollapse;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0,0 });
-    ImGui::Begin("Viewport", false, viewportWindowFlags );
-    ImGui::Image((void*)(intptr_t)framebuffer.GetColourAttachment(), ImVec2{ (float)800,(float)600 });
-
-    ImGuizmo::SetDrawlist();
-    ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
-    ImGuizmo::Enable(true);
-    auto cam = glm::mat4(1.0f);
-    //ImGuizmo::Manipulate(glm::value_ptr(static_cam), glm::value_ptr(static_projection), ImGuizmo::TRANSLATE, ImGuizmo::WORLD, glm::value_ptr(trans));
-    ImGuizmo::ViewManipulate(glm::value_ptr(cam), 8.0f, ImVec2{ 0.0f,0.0f }, ImVec2{ 128.0f,128.0f }, 0x10101010);
-    ImGui::End();
-    ImGui::PopStyleVar();
-
-}
-
-inline void Settings() {
-    ImGui::Begin("Settings");
-    ImGui::LabelText("##title-settings", "Fine grain control over your engine... ");
-    ImGui::End();
-}
-
-inline void Console() {
-    ImGui::Begin("Console", false );
-    ImGui::Dummy(ImVec2{ 128, 128 });
-    ImGui::End();
-}
-
-inline void AssetsFinder() {
-    ImGui::Begin("Asset-Finder", false );
-    ImGui::Dummy(ImVec2{ 128, 128 });
-    ImGui::End();
-}

ImGui/premake5.lua

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

ImGuizmo/premake5.lua

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

Runtime/premake5.lua

@@ -1,39 +0,0 @@
-project "Runtime"
-kind "ConsoleApp"
-
-buildmessage "Building the runtime ..."
-
-links{
-  "BarinkEngine"
-}
-
-includedirs{
-  "./../BarinkEngine/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 {
-  './../build/BarinkEngine/Debug'
-}
-
-files { 
-  "./src/*.h",
-  "./src/*.cpp"
-}

Runtime/src/main.cpp

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

SandboxApp/premake5.lua

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

SandboxApp/src/GUI.cpp

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

SandboxApp/src/GUI.h

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

SandboxApp/src/Sandbox.cpp

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

SandboxApp/src/Util.h

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

SandboxApplication/GUI.cpp

@@ -0,0 +1,41 @@
+#include "GUI.h"
+
+void CameraTool(Camera* cam) {
+
+    ImGui::Begin("Camera");
+
+    ImGui::SliderFloat("Zoom:", &cam->Zoom, 10, 190);
+
+    ImGui::InputFloat3("Position:", &cam->Position[0]);
+
+    ImGui::InputFloat3("Rotation:", &cam->Rotation[0]);
+
+    ImGui::End();
+}
+
+void ScriptingTool(char* code) {
+    ImGui::Begin("Scripting");
+
+    ImGui::InputTextMultiline("Lua Script", code, 255);
+    bool runCode = ImGui::Button("Run");
+
+
+    ImGui::End();
+
+}
+
+
+void transformWindow(Transform& transform, std::string PanelName) {
+    ImGui::Begin(PanelName.c_str());
+    ImGui::InputFloat3("Position:", (float*)&transform.Position[0]);
+    ImGui::InputFloat3("Rotation:", (float*)&transform.Rotation[0]);
+    ImGui::InputFloat3("Scale:", (float*)&transform.Scale[0]);
+    ImGui::End();
+
+}
+
+void materialWindow(Material& material, std::string PanelName) {
+    ImGui::Begin(PanelName.c_str());
+    ImGui::ColorPicker3("Color:", &material.Color[0]);
+    ImGui::End();
+}

SandboxApplication/GUI.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "imgui.h"
+#include <BarinkEngine.h>
+
+void CameraTool(Camera* camera);
+void ScriptingTool(char* code);
+void transformWindow(Transform& transform, std::string PanelName);
+void materialWindow(Material& material, std::string PanelName);

SandboxApplication/Sandbox.cpp

@@ -0,0 +1,176 @@
+#include "BarinkEngine.h"
+#include "imgui.h"
+#include "GUI.h"
+#include "Util.h"
+
+/*
+* Define globals
+*/
+Camera* cam;
+
+
+Shader* shader;
+
+Renderable* Cube;
+Material* matCube;
+Texture* textureCube;
+
+Renderable* Cube2;
+Material* matCube2;
+
+char* code = new char[254];
+
+
+const std::string vertexShaderSource = "build/SandboxApplication/Debug/test.vs";
+const std::string fragmentShaderSource = "build/SandboxApplication/Debug/test.fs";
+
+
+
+/*
+* Runs once at startup 
+* - USe to initialize the game/sandbox/demo
+*/
+void Start() {
+
+    /*
+        Building a very basic scene graph
+    */
+    SceneNode MyCube = SceneNode();
+    MyCube.name = "MyCube";
+
+    SceneNode MyBaby = SceneNode();
+    MyBaby.name = "Baby";
+
+    SceneNode MySecondCube = SceneNode();
+    MySecondCube.name = "MySecondCube";
+
+
+    MyCube.addChild(MyBaby);
+
+    
+    Scene scene = Scene("My awesome Game Scene");
+    scene.GetRoot().addChild(MyCube);
+    scene.GetRoot().addChild(MySecondCube);
+
+
+   // Walk scene graph
+    PrintSceneTree(scene.GetRoot(),0);
+
+    shader = new Shader(vertexShaderSource, fragmentShaderSource);
+
+    textureCube = new Texture("build/SandboxApplication/Debug/Textures/wall.jpg");
+
+    matCube = new Material(*shader);
+    matCube->Color = glm::vec3(1.0, 0.0, 0.0);
+
+    matCube2 = new Material(*shader);
+    matCube2->Color = glm::vec3(0.0, 1.0f, 0.0);
+
+    std::string cubePath = "build/SandboxApplication/Debug/Models/Cube.obj";
+    std::string lanternPath = "build/SandboxApplication/Debug/Models/Latern.gltf";
+    /*
+    * load meshes 
+    */
+    Cube = Renderable::Load(lanternPath);
+    Cube2 = Renderable::Load(cubePath);
+    Cube->addChild(*Cube2);
+
+    Cube->shader = shader;
+    Cube2->shader = shader;
+
+    Cube->texture = textureCube;
+    Cube2->texture = textureCube;
+
+    Cube2->transform.Position = glm::vec3(-9.0f, 0.0f, 0.0f);
+
+    Cube->transform.Position = glm::vec3(-8.0f, 0.0f, -2.0f);
+
+    cam = new Camera(glm::vec3(0.0f, 1.5f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), 90.0f);
+
+    memset(code, '\0', 254);
+
+}
+
+
+/*
+* Runs every frame
+* - Use to draw Immediate mode graphics (Not meant for HUD's )
+*/
+void ImmediateGraphicsDraw() {
+    ImGui::NewFrame();
+
+    // Show ImGui demo such that I can easily look
+    // at possible GUI elements to use
+    ImGui::ShowDemoWindow();
+
+
+    // Show internal BarinkEngine stats
+    ShowStats();
+
+
+    // Show different tooling for this specific sandbox
+    CameraTool(cam);
+    ScriptingTool(code);
+
+    transformWindow(Cube->transform, "Transform (Cube)");
+
+    transformWindow(Cube2->transform, "Transform (Cube2)");
+
+    materialWindow(*matCube, "Material Cube");
+    materialWindow(*matCube2, "Material Cube2");
+
+
+
+}
+
+/*
+* Runs every frame
+* - Meant for game logic ( non-physics related) 
+*/
+void Update()
+{
+
+
+    /*
+    * NOTE: this needs to move to the renderer
+    * Render code should not appear in the sandbox file
+    */
+    glm::mat4 projection = glm::perspective(glm::radians(cam->Zoom), (800.0f / 600.0f), 0.001f, 100.0f);
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+    shader->Use();
+    shader->setUniformMat4("P", projection);
+    shader->setUniformMat4("M", CalculateModelMat(Cube->transform));
+    shader->setUniformMat4("V", cam->GetViewMatrix());
+    matCube->Apply();
+
+    Cube->Draw();
+
+    shader->setUniformMat4("M", CalculateModelMat(Cube2->transform));
+    matCube2->Apply();
+
+    Cube2->Draw();
+
+}
+
+/*
+* Runs at the end of the program
+* - Meant for cleanup
+*/
+void Stop() {
+    // Cleanup
+    Cube->VAO.Delete();
+    Cube->elementBuffer.Delete();
+
+    Cube2->VAO.Delete();
+    Cube2->elementBuffer.Delete();
+
+    delete Cube2;
+    delete Cube;
+
+    delete matCube;
+    delete matCube2;
+
+    delete shader;
+}