diff --git a/Editor/Editor.cpp b/Editor/Editor.cpp
index f2853d71..18a6cabd 100644
--- a/Editor/Editor.cpp
+++ b/Editor/Editor.cpp
@@ -1,4 +1,5 @@
 #include <Engine.h>
+#include "src/Core/Maths.h"
 #include <src/Scene/Entities/Entity.h>
 
 #include <src/Scene/Scene.h>
@@ -7,9 +8,9 @@
 #include <src/Vendors/imgui/ImGuizmo.h>
 #include <src/Scene/Components/Components.h>
 #include <src/Core/Physics/PhysicsManager.h>
-#include "../Scene/Components/BoxCollider.h"
+#include "src/Scene/Components/BoxCollider.h"
 #include "src/EditorInterface.h"
-#include "../Core/Input.h"
+#include "src/Core/Input.h"
 #include <GLFW/glfw3.h>
 #include <src/Vendors/glm/trigonometric.hpp>
 #include <src/Scripting/ScriptingEngine.h>
diff --git a/Editor/resources/Shaders/basic.shader b/Editor/resources/Shaders/basic.shader
index 0e284b2f..27325761 100644
--- a/Editor/resources/Shaders/basic.shader
+++ b/Editor/resources/Shaders/basic.shader
@@ -17,7 +17,6 @@ out vec3 v_Bitangent;
 uniform mat4 u_Projection;
 uniform mat4 u_View;
 uniform mat4 u_Model;
-uniform mat3 u_NormalMatrix;
 
 void main()
 {
@@ -77,25 +76,18 @@ struct Light {
 // Debug
 uniform int u_ShowNormal;
 
+// Lights
 const int MaxLight = 24;
 uniform int LightCount = 0;
 uniform Light Lights[MaxLight];
 
-// Lighting
-uniform vec3 u_AmbientColor;
-uniform vec4 u_LightColor;
-uniform vec3 u_LightDirection;
-uniform float u_Exposure;
-uniform float u_FogAmount;
-
-// Specular
-uniform samplerCube u_Skybox;
-uniform samplerCube u_IrradianceMap;
-uniform float u_Strength;
+// Camera
 uniform vec3 u_EyePosition;
+uniform float u_Exposure;
 
-// IBL
-uniform samplerCube irradianceMap;
+// Environmnent
+uniform float u_FogAmount;
+uniform samplerCube u_IrradianceMap;
 uniform samplerCube prefilterMap;
 uniform sampler2D   brdfLUT;
 
diff --git a/Editor/src/EditorInterface.cpp b/Editor/src/EditorInterface.cpp
index c96193e4..d9ee3377 100644
--- a/Editor/src/EditorInterface.cpp
+++ b/Editor/src/EditorInterface.cpp
@@ -1,28 +1,33 @@
-#include "EditorInterface.h"
-#include "src/Vendors/imgui/imgui.h"
-#include <src/Vendors/imgui/ImGuizmo.h>
-#include <src/Rendering/Textures/Texture.h>
-#include <Engine.h>
-#include <src/Scene/Components/LightComponent.h>
-#include <src/Core/Physics/PhysicsManager.h>
-#include <src/Scene/Components/Components.h>
-#include <src/Vendors/glm/gtc/type_ptr.hpp>
-#include <src/Vendors/glm/gtx/matrix_decompose.hpp>
-#include "src/Scene/Entities/ImGuiHelper.h"
 #include <map>
-#include <src/Core/MaterialManager.h>
-
-#include "../Resource/FontAwesome5.h"
-#include <src/Scene/Components/BoxCollider.h>
 #include <algorithm>
-#include <Dependencies/GLEW/include/GL/glew.h>
-#include "src/Resource/Project.h"
-#include <src/Scene/Components/LuaScriptComponent.h>
-#include <src/Core/Logger.h>
-#include <src/Scene/Components/WrenScriptComponent.h>
 
 #include "ProjectInterface.h"
-#include <src/Scene/Systems/QuakeMapBuilder.h>
+#include "EditorInterface.h"
+
+#include "Engine.h"
+#include "src/Core/Logger.h"
+
+#include "src/Vendors/imgui/imgui.h"
+#include "src/Vendors/imgui/ImGuizmo.h"
+#include "src/Scene/Entities/ImGuiHelper.h"
+
+#include "src/Rendering/Textures/Texture.h"
+#include "src/Rendering/Textures/MaterialManager.h"
+
+#include "src/Core/Physics/PhysicsManager.h"
+
+#include "src/Vendors/glm/gtc/type_ptr.hpp"
+#include "src/Vendors/glm/gtx/matrix_decompose.hpp"
+#include "src/Resource/FontAwesome5.h"
+
+#include "Dependencies/GLEW/include/GL/glew.h"
+
+#include "src/Scene/Components/Components.h"
+#include "src/Scene/Components/BoxCollider.h"
+#include "src/Scene/Components/LuaScriptComponent.h"
+#include "src/Scene/Components/WrenScriptComponent.h"
+#include "src/Scene/Systems/QuakeMapBuilder.h"
+#include "src/Scene/Components/LightComponent.h"
 
 namespace Nuake {
     Ref<UI::UserInterface> userInterface;
@@ -367,8 +372,8 @@ namespace Nuake {
                     if (ImGui::MenuItem("Light Component") && !m_SelectedEntity.HasComponent<LightComponent>())
                         m_SelectedEntity.AddComponent<LightComponent>();
                     ImGui::Separator();
-                    if (ImGui::MenuItem("Model Component") && !m_SelectedEntity.HasComponent<ModelComponent>())
-                        m_SelectedEntity.AddComponent<ModelComponent>();
+                    if (ImGui::MenuItem("Mesh Component") && !m_SelectedEntity.HasComponent<MeshComponent>())
+                        m_SelectedEntity.AddComponent<MeshComponent>();
                     if (ImGui::MenuItem("Quake map Component") && !m_SelectedEntity.HasComponent<QuakeMapComponent>())
                         m_SelectedEntity.AddComponent<QuakeMapComponent>();
                     ImGui::Separator();
@@ -411,12 +416,12 @@ namespace Nuake {
                 ImGui::Separator();
             }
 
-            if (m_SelectedEntity.HasComponent<ModelComponent>()) {
+            if (m_SelectedEntity.HasComponent<MeshComponent>()) {
                 std::string icon = ICON_FA_MALE;
-                if (ImGui::CollapsingHeader((icon + " " + "Model").c_str(), ImGuiTreeNodeFlags_DefaultOpen))
+                if (ImGui::CollapsingHeader((icon + " " + "Mesh").c_str(), ImGuiTreeNodeFlags_DefaultOpen))
                 {
-                    ImGui::TextColored(ImGui::GetStyleColorVec4(1), "Model properties");
-                    auto& component = m_SelectedEntity.GetComponent<ModelComponent>();
+                    ImGui::TextColored(ImGui::GetStyleColorVec4(1), "Mesh properties");
+                    auto& component = m_SelectedEntity.GetComponent<MeshComponent>();
                     // Path
                     std::string path = component.ModelPath;
                     char pathBuffer[256];
diff --git a/Editor/src/FileSystemUI.cpp b/Editor/src/FileSystemUI.cpp
index 7bbd045b..1dcd14c4 100644
--- a/Editor/src/FileSystemUI.cpp
+++ b/Editor/src/FileSystemUI.cpp
@@ -3,10 +3,10 @@
 #include <src/Vendors/imgui/imgui.h>
 
 #include <src/Vendors/imgui/imgui_internal.h>
-#include <src/Resource/FontAwesome5.h>
+#include "src/Resource/FontAwesome5.h"
 #include "src/Scene/Components/ParentComponent.h"
-#include <src/Rendering/Textures/Texture.h>
-#include <src/Core/TextureManager.h>
+#include "src/Rendering/Textures/Texture.h"
+#include "src/Rendering/Textures/TextureManager.h"
 #include "EditorInterface.h"
 
 namespace Nuake {
diff --git a/Nuake/Engine.cpp b/Nuake/Engine.cpp
index 3202b4db..c5a75122 100644
--- a/Nuake/Engine.cpp
+++ b/Nuake/Engine.cpp
@@ -2,12 +2,12 @@
 #include "src/Core/Physics/PhysicsManager.h"
 #include <GLFW/glfw3.h>
 
-#include "../Core/Input.h"
+#include "src/Core/Input.h"
 #include "src/Core/FileSystem.h"
 #include "src/Scripting/ScriptingEngine.h"
 
-#include "../Rendering/Renderer.h"
-#include "../Rendering/Renderer2D.h"
+#include "src/Rendering/Renderer.h"
+#include "src/Rendering/Renderer2D.h"
 
 #include <imgui/imgui_impl_glfw.h>
 #include <imgui/imgui_impl_opengl3.h>
@@ -45,7 +45,6 @@ namespace Nuake
 		if (!CurrentWindow->GetScene())
 			return;
 
-		// Calculate delta time
 		float time = (float)glfwGetTime();
 		Timestep timestep = time - m_LastFrameTime;
 		m_LastFrameTime = time;
@@ -74,11 +73,13 @@ namespace Nuake
 	void Engine::EnterPlayMode()
 	{
 		// Dont trigger init if already in player mode.
-		if (!IsPlayMode)
-			if (GetCurrentScene()->OnInit())
-				IsPlayMode = true;
-			else
-				GetCurrentScene()->OnExit();
+		if (IsPlayMode)
+			return;
+
+		if (GetCurrentScene()->OnInit())
+			IsPlayMode = true;
+		else
+			GetCurrentScene()->OnExit();
 	}
 
 	void Engine::ExitPlayMode()
@@ -90,7 +91,6 @@ namespace Nuake
 		}
 
 		Input::ShowMouse();
-
 		IsPlayMode = false;
 	}
 
@@ -107,7 +107,6 @@ namespace Nuake
 
 	void Engine::EndDraw()
 	{
-		// Swap buffer and draw imgui
 		Window::Get()->EndDraw();
 	}
 
diff --git a/Nuake/Engine.h b/Nuake/Engine.h
index e75d4527..a4710c06 100644
--- a/Nuake/Engine.h
+++ b/Nuake/Engine.h
@@ -8,16 +8,12 @@
 /* TODOS:
 * 
 * Engine:
-*	Scripting API for all component
 *	Scripting API for editing UI maybe
 *	Launch game standalone
 *	Fix physics system
-*	trenchbroom physics element
-*	
-*   
 */
 
-// Welcome to the Nuake source code. This is the entry point for the engine.
+// Welcome to the Nuake source code.
 namespace Nuake
 {
 	class Engine {
@@ -30,7 +26,7 @@ namespace Nuake
 		static float m_FixedUpdateRate;
 		static float m_FixedUpdateDifference;
 	public:
-		static bool IsPlayMode; // True if currently playing the game.
+		static bool IsPlayMode; // Is currently in runtime..
 
 		static void Init();  // Initialize the engine.
 		static void Tick();  // Updates everything, called everyframe.
@@ -45,11 +41,9 @@ namespace Nuake
 
 		static Ref<Window> GetCurrentWindow();
 
-		// Load a specific scene
 		static bool LoadScene(Ref<Scene> scene);
 		static Ref<Scene> GetCurrentScene();
 
-		// Loads a project and the default scene.
 		static bool LoadProject(Ref<Project> project);
 		static Ref<Project> GetProject();
 	};
diff --git a/Nuake/src/Core/String.cpp b/Nuake/src/Core/String.cpp
new file mode 100644
index 00000000..b37ae72c
--- /dev/null
+++ b/Nuake/src/Core/String.cpp
@@ -0,0 +1,40 @@
+#include "String.h"
+#include <iostream>
+#include <sstream>
+
+namespace Nuake {
+	bool String::BeginsWith(const std::string& string, const std::string& begin)
+	{
+		if (string.rfind(begin, 0) == 0)
+			return true;
+
+		return false;
+	}
+
+	bool String::EndsWith(const std::string& string, const std::string& end)
+	{
+		if (string.length() >= end.length())
+			return (0 == string.compare(string.length() - end.length(), end.length(), end));
+		else
+			return false;
+	}
+
+	std::vector<std::string> String::Split(const std::string& string, char delimiter)
+	{
+		std::vector<std::string> result;
+		std::stringstream ss(string);
+		std::string item;
+
+		while (getline(ss, item, delimiter))
+		{
+			result.push_back(item);
+		}
+
+		return result;
+	}
+
+	float String::ToFloat(const std::string& string)
+	{
+		return std::stof(string);
+	}
+}
\ No newline at end of file
diff --git a/Nuake/src/Core/String.h b/Nuake/src/Core/String.h
new file mode 100644
index 00000000..643028ee
--- /dev/null
+++ b/Nuake/src/Core/String.h
@@ -0,0 +1,18 @@
+#pragma once
+#include <string>
+#include <vector>
+
+/*
+	This class purpose is to provide helper methods related to strings.
+	It is not meant to be a replacement for std::string.
+*/
+namespace Nuake {
+	class String {
+	public:
+		static bool BeginsWith(const std::string& string, const std::string& begin);
+		static bool EndsWith(const std::string& string, const std::string& end);
+		static std::vector<std::string> Split(const std::string& string, char delimiter);
+
+		static float ToFloat(const std::string& string);
+	};
+}
diff --git a/Nuake/src/Rendering/Materials/Material.h b/Nuake/src/Rendering/Materials/Material.h
new file mode 100644
index 00000000..a6c5b523
--- /dev/null
+++ b/Nuake/src/Rendering/Materials/Material.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace Nuake {
+	class Material 
+	{
+	public:
+		virtual void Bind();
+	private:
+
+	};
+}
\ No newline at end of file
diff --git a/Nuake/src/Rendering/Materials/PBRMaterial.h b/Nuake/src/Rendering/Materials/PBRMaterial.h
new file mode 100644
index 00000000..8c87f303
--- /dev/null
+++ b/Nuake/src/Rendering/Materials/PBRMaterial.h
@@ -0,0 +1,16 @@
+#pragma once
+#include "src/Core/Core.h"
+#include "src/Rendering/Shaders/Shader.h"
+
+namespace Nuake {
+	class PBRMaterial 
+	{
+	public:
+		static Ref<Shader> mShader;
+
+		PBRMaterial();
+
+		void Bind();
+	private:
+	};
+}
\ No newline at end of file
diff --git a/Nuake/src/Rendering/Mesh/Mesh.cpp b/Nuake/src/Rendering/Mesh/Mesh.cpp
index 498b4093..38276770 100644
--- a/Nuake/src/Rendering/Mesh/Mesh.cpp
+++ b/Nuake/src/Rendering/Mesh/Mesh.cpp
@@ -1,8 +1,6 @@
 #include "Mesh.h"
-#include <GL\glew.h>
-
 #include "src/Rendering/Renderer.h"
-#include "src/Core/MaterialManager.h"
+#include "src/Rendering/Textures/MaterialManager.h"
 
 namespace Nuake
 {
diff --git a/Nuake/src/Rendering/RenderList.h b/Nuake/src/Rendering/RenderList.h
index b5dae854..8e8b2deb 100644
--- a/Nuake/src/Rendering/RenderList.h
+++ b/Nuake/src/Rendering/RenderList.h
@@ -1,16 +1,17 @@
 #pragma once
 #include <vector>
 #include <map>
-
+#include "src/Core/Maths.h"
 #include "src/Core/Core.h"
 #include "src/Rendering/Textures/Material.h"
 #include "src/Rendering/Mesh/Mesh.h"
-
+#include "src/Rendering/Shaders/ShaderManager.h"
 namespace Nuake
 {
 	struct RenderMesh
 	{
 		Ref<Mesh> Mesh;
+		Matrix4 transform;
 	};
 
 	class RenderList
@@ -18,15 +19,36 @@ namespace Nuake
 	public:
 		RenderList()
 		{
-			this->m_RenderList = std::map<Ref<Material>, std::vector<Ref<Mesh>>>();
+			this->m_RenderList = std::map<Ref<Material>, std::vector<RenderMesh>>();
 		}
 
-		void AddToRenderList(Ref<Mesh> mesh)
+		void AddToRenderList(Ref<Mesh> mesh, Matrix4 transform)
 		{
+			if (m_RenderList.find(mesh->m_Material) == m_RenderList.end())
+				m_RenderList[mesh->m_Material] = std::vector<RenderMesh>();
 
+			m_RenderList[mesh->m_Material].push_back({mesh, transform});
+		}
+
+		void Flush()
+		{
+			Ref<Shader> pbrShader = ShaderManager::GetShader("resources/Shaders/basic.shader");
+			pbrShader->Bind();
+			for (auto& i : m_RenderList)
+			{
+				i.first->Bind();
+
+				for (auto& m : i.second)
+				{
+					pbrShader->SetUniformMat4f("u_Model", m.transform);
+					m.Mesh->Draw(false);
+				}
+			}
+
+			m_RenderList.clear();
 		}
 
 	private:
-		std::map<Ref<Material>, std::vector<Ref<Mesh>>> m_RenderList;
+		std::map<Ref<Material>, std::vector<RenderMesh>> m_RenderList;
 	};
 }
diff --git a/Nuake/src/Rendering/Renderer.cpp b/Nuake/src/Rendering/Renderer.cpp
index 7a04ad7c..9f576937 100644
--- a/Nuake/src/Rendering/Renderer.cpp
+++ b/Nuake/src/Rendering/Renderer.cpp
@@ -30,11 +30,10 @@ namespace Nuake
 
     VertexArray* Renderer::QuadVertexArray;
     VertexBuffer* Renderer::QuadVertexBuffer;
+    VertexArray*  Renderer::CubeVertexArray;
+    VertexBuffer* Renderer::CubeVertexBuffer;
 
-    unsigned int CubeVAO;
-    unsigned int CubeVBO;
-    unsigned int QuadVAO;
-    unsigned int QuadVBO;
+    RenderList Renderer::m_RenderList = RenderList();
 
     glm::vec3 CubeVertices[36]{
            glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(0.5f,  -0.5f, -0.5f), glm::vec3(0.5f,   0.5f, -0.5f),
@@ -67,29 +66,22 @@ namespace Nuake
 
         LoadShaders();
 
-        m_Shader->Bind();
-
-        // TODO: Use buffer abstraction.
-        // Setup buffers
-        glGenVertexArrays(1, &CubeVAO);
-        glBindVertexArray(CubeVAO);
-
-        glGenBuffers(1, &CubeVBO);
-        glBindBuffer(GL_ARRAY_BUFFER, CubeVBO);
-
-        glBufferData(GL_ARRAY_BUFFER, sizeof(CubeVertices), CubeVertices, GL_STATIC_DRAW);
-
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)0);
-        glEnableVertexAttribArray(0);
-
-        // Create quad buffer
-        QuadVertexArray = new VertexArray();
-        QuadVertexArray->Bind();
-
-        QuadVertexBuffer = new VertexBuffer(QuadVertices, sizeof(QuadVertices));
+        // Cube buffer
+        CubeVertexArray = new VertexArray();
+        CubeVertexArray->Bind();
+        CubeVertexBuffer = new VertexBuffer(CubeVertices, sizeof(CubeVertices));
 
         VertexBufferLayout vblayout = VertexBufferLayout();
         vblayout.Push<float>(3);
+        CubeVertexArray->AddBuffer(*CubeVertexBuffer, vblayout);
+
+        // Quad buffer
+        QuadVertexArray = new VertexArray();
+        QuadVertexArray->Bind();
+        QuadVertexBuffer = new VertexBuffer(QuadVertices, sizeof(QuadVertices));
+
+        vblayout = VertexBufferLayout();
+        vblayout.Push<float>(3);
         vblayout.Push<float>(2);
         QuadVertexArray->AddBuffer(*QuadVertexBuffer, vblayout);
     }
@@ -106,6 +98,16 @@ namespace Nuake
         m_Shader            = ShaderManager::GetShader("resources/Shaders/basic.shader");
     }
 
+    void Renderer::SubmitMesh(Ref<Mesh> mesh, Matrix4 transform)
+    {
+        m_RenderList.AddToRenderList(mesh, transform);
+    }
+
+    void Renderer::Flush()
+    {
+        m_RenderList.Flush();
+    }
+
     void Renderer::BeginDraw(Ref<Camera> camera)
     {
         RenderCommand::Clear();
@@ -118,7 +120,7 @@ namespace Nuake
 
     void Renderer::EndDraw()
     {
-        m_Lights.clear(); // Clean up lights.
+        m_Lights.clear();
     }
 
     // List of all lights queued to be used for rendering this frame.
@@ -131,12 +133,11 @@ namespace Nuake
 
         m_Lights.push_back({ transform , light });
 
-        // What light idx is this?
         int idx = m_Lights.size();
 
-        glm::vec3 direction = light.GetDirection();
-        glm::vec3 pos = transform.GlobalTranslation;
-        glm::mat4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
+        Vector3 direction = light.GetDirection();
+        Vector3 pos = transform.GlobalTranslation;
+        Matrix4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
 
         //light.m_Framebuffer->GetTexture(GL_DEPTH_ATTACHMENT)->Bind(17);
 
@@ -173,12 +174,11 @@ namespace Nuake
     {
         m_Lights.push_back({ transform , light });
 
-        // What light idx is this?
         int idx = m_Lights.size();
 
-        glm::vec3 direction = light.GetDirection();
-        glm::vec3 pos = transform.Translation;
-        glm::mat4 lightView = glm::lookAt(pos, pos - direction, glm::vec3(0.0f, 1.0f, 0.0f));
+        Vector3 direction = light.GetDirection();
+        Vector3 pos = transform.Translation;
+        Matrix4 lightView = glm::lookAt(pos, pos - direction, Vector3(0.0f, 1.0f, 0.0f));
 
         light.m_Framebuffer->GetTexture()->Bind(11);
 
@@ -201,25 +201,24 @@ namespace Nuake
     void Renderer::DrawCube(TransformComponent transform, glm::vec4 color)
     {
         //glDisable(GL_DEPTH_TEST);
-        Ref<Window> window = Engine::GetCurrentWindow();
-        Ref<FrameBuffer> fb = window->GetFrameBuffer();
-
-
         m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
         m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, color.a);
-        glBindVertexArray(CubeVAO);
-        glDrawArrays(GL_TRIANGLES, 0, 36);
 
-        m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, 1.0f);
+        CubeVertexArray->Bind();
+        RenderCommand::DrawArrays(0, 36);
+        //glBindVertexArray(CubeVAO);
+        //glDrawArrays(GL_TRIANGLES, 0, 36);
 
-        glPolygonMode(GL_FRONT, GL_LINE);
-        glPolygonMode(GL_BACK, GL_LINE);
-        glLineWidth(4);
-        glDrawArrays(GL_TRIANGLES, 0, 36);
+        //m_DebugShader->SetUniform4f("u_Color", color.r, color.g, color.b, 1.0f);
 
-        // Turn off wireframe mode
-        glPolygonMode(GL_FRONT, GL_FILL);
-        glPolygonMode(GL_BACK, GL_FILL);
+        //glPolygonMode(GL_FRONT, GL_LINE);
+        //glPolygonMode(GL_BACK, GL_LINE);
+        //glLineWidth(4);
+        //glDrawArrays(GL_TRIANGLES, 0, 36);
+        //
+        //// Turn off wireframe mode
+        //glPolygonMode(GL_FRONT, GL_FILL);
+        //glPolygonMode(GL_BACK, GL_FILL);
         //glEnable(GL_DEPTH_TEST);
 
     }
diff --git a/Nuake/src/Rendering/Renderer.h b/Nuake/src/Rendering/Renderer.h
index 5a31dc13..5e1ec312 100644
--- a/Nuake/src/Rendering/Renderer.h
+++ b/Nuake/src/Rendering/Renderer.h
@@ -3,6 +3,7 @@
 #include "src/Scene/Components/Components.h"
 #include "src/Core/Core.h"
 #include "Buffers/VertexArray.h"
+#include "RenderList.h"
 
 namespace Nuake
 {
@@ -14,9 +15,13 @@ namespace Nuake
 
 	class Renderer 
 	{
+	private:
+		static RenderList m_RenderList;
 	public:
 		static VertexArray* Renderer::QuadVertexArray;
 		static VertexBuffer* Renderer::QuadVertexBuffer;
+		static VertexArray* Renderer::CubeVertexArray;
+		static VertexBuffer* Renderer::CubeVertexBuffer;
 
 		static Ref<Shader> m_Shader;
 		static Ref<Shader> m_ShadowmapShader;
@@ -31,6 +36,7 @@ namespace Nuake
 		static void LoadShaders();
 
 		static void BeginScene();
+		static void SubmitMesh(Ref<Mesh> mesh, Matrix4 transform);
 		static void Flush();
 
 		// Drawing states
@@ -42,7 +48,7 @@ namespace Nuake
 		static void RegisterLight(TransformComponent transform, LightComponent light, Ref<Camera> cam);
 		static void RegisterDeferredLight(TransformComponent transform, LightComponent light, Camera* cam);
 
-		static void SubmitMesh(Ref<Mesh> mesh);
+		
 
 		// Debug
 		static void DrawDebugLine(glm::vec3 start, glm::vec3 end, glm::vec4 color);
diff --git a/Nuake/src/Rendering/Textures/Material.cpp b/Nuake/src/Rendering/Textures/Material.cpp
index c16c6f60..27ccf2ef 100644
--- a/Nuake/src/Rendering/Textures/Material.cpp
+++ b/Nuake/src/Rendering/Textures/Material.cpp
@@ -1,4 +1,4 @@
-#include "../Core/MaterialManager.h"
+#include "src/Rendering/Textures/MaterialManager.h"
 #include "Material.h"
 
 #include "src/Core/Maths.h"
diff --git a/Nuake/src/Rendering/Textures/Material.h b/Nuake/src/Rendering/Textures/Material.h
index cc3c349e..1c71abd2 100644
--- a/Nuake/src/Rendering/Textures/Material.h
+++ b/Nuake/src/Rendering/Textures/Material.h
@@ -1,5 +1,5 @@
 #pragma once
-#include "src/Core/TextureManager.h"
+#include "src/Rendering/Textures/TextureManager.h"
 #include "Texture.h"
 
 #include "src/Core/Core.h"
diff --git a/Nuake/src/Core/MaterialManager.cpp b/Nuake/src/Rendering/Textures/MaterialManager.cpp
similarity index 100%
rename from Nuake/src/Core/MaterialManager.cpp
rename to Nuake/src/Rendering/Textures/MaterialManager.cpp
diff --git a/Nuake/src/Core/MaterialManager.h b/Nuake/src/Rendering/Textures/MaterialManager.h
similarity index 100%
rename from Nuake/src/Core/MaterialManager.h
rename to Nuake/src/Rendering/Textures/MaterialManager.h
diff --git a/Nuake/src/Core/TextureManager.cpp b/Nuake/src/Rendering/Textures/TextureManager.cpp
similarity index 100%
rename from Nuake/src/Core/TextureManager.cpp
rename to Nuake/src/Rendering/Textures/TextureManager.cpp
diff --git a/Nuake/src/Core/TextureManager.h b/Nuake/src/Rendering/Textures/TextureManager.h
similarity index 100%
rename from Nuake/src/Core/TextureManager.h
rename to Nuake/src/Rendering/Textures/TextureManager.h
diff --git a/Nuake/src/Resource/FGD/FGDClass.h b/Nuake/src/Resource/FGD/FGDClass.h
index 157690bc..0d7e5f8d 100644
--- a/Nuake/src/Resource/FGD/FGDClass.h
+++ b/Nuake/src/Resource/FGD/FGDClass.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "ClassProperty.h"
 #include "src/Resource/Serializable.h"
-#include <string>
+#include "src/Core/String.h"
 #include <vector>
 
 namespace Nuake {
@@ -18,12 +18,13 @@ namespace Nuake {
 	public:
 		std::string Name;
 		std::string Description;
+		std::string Script = "";
+		std::string Class = "";
 
 		bool Visible = false;
 		bool Solid = false;
 		bool IsTrigger = false;
-		std::string Script = "";
-		std::string Class = "";
+
 		std::vector<ClassProperty> Properties;
 
 		FGDBrushEntity()
@@ -41,13 +42,15 @@ namespace Nuake {
 		json Serialize() override
 		{
 			BEGIN_SERIALIZE();
-			SERIALIZE_VAL(Name);
-			SERIALIZE_VAL(Description);
-			SERIALIZE_VAL(Visible);
-			SERIALIZE_VAL(Solid);
-			SERIALIZE_VAL(IsTrigger);
-			SERIALIZE_VAL(Script);
-			SERIALIZE_VAL(Class);
+			{
+				SERIALIZE_VAL(Name);
+				SERIALIZE_VAL(Description);
+				SERIALIZE_VAL(Script);
+				SERIALIZE_VAL(Class);
+				SERIALIZE_VAL(Visible);
+				SERIALIZE_VAL(Solid);
+				SERIALIZE_VAL(IsTrigger);
+			}
 			END_SERIALIZE();
 		}
 
diff --git a/Nuake/src/Resource/FGD/FGDFile.h b/Nuake/src/Resource/FGD/FGDFile.h
index 5b8ac105..9f5f007d 100644
--- a/Nuake/src/Resource/FGD/FGDFile.h
+++ b/Nuake/src/Resource/FGD/FGDFile.h
@@ -73,7 +73,7 @@ namespace Nuake {
 		{
 			for (auto& b : BrushEntities)
 			{
-				if (b.Name == name)
+				if (name == b.Name)
 					return b;
 			}
 		}
diff --git a/Nuake/src/Scene/Components/BSPBrushComponent.h b/Nuake/src/Scene/Components/BSPBrushComponent.h
index 5400a555..92e1692e 100644
--- a/Nuake/src/Scene/Components/BSPBrushComponent.h
+++ b/Nuake/src/Scene/Components/BSPBrushComponent.h
@@ -1,14 +1,14 @@
 #pragma once
-#include "../Core/Core.h"
-#include "../Core/Maths.h"
+#include "src/Core/Core.h"
+#include "src/Core/Maths.h"
 
-#include "../Rendering/Textures/Material.h"
-#include "../Rendering/Mesh/Mesh.h"
-#include <src/Core/Physics/Rigibody.h>
+#include "src/Rendering/Textures/Material.h"
+#include "src/Rendering/Mesh/Mesh.h"
+#include "src/Core/Physics/Rigibody.h"
 
-namespace Nuake
-{
-	class BSPBrushComponent {
+namespace Nuake {
+	class BSPBrushComponent 
+	{
 	public:
 		std::vector<Ref<Mesh>> Meshes;
 		std::vector< Ref<Material>> Materials;
diff --git a/Nuake/src/Scene/Components/BoxCollider.cpp b/Nuake/src/Scene/Components/BoxCollider.cpp
deleted file mode 100644
index df4b7a01..00000000
--- a/Nuake/src/Scene/Components/BoxCollider.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "BoxCollider.h"
-
diff --git a/Nuake/src/Scene/Components/Components.cpp b/Nuake/src/Scene/Components/Components.cpp
deleted file mode 100644
index c1778696..00000000
--- a/Nuake/src/Scene/Components/Components.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-#include "Components.h"
-
-
-
diff --git a/Nuake/src/Scene/Components/Components.h b/Nuake/src/Scene/Components/Components.h
index 1ef74617..356dd7e8 100644
--- a/Nuake/src/Scene/Components/Components.h
+++ b/Nuake/src/Scene/Components/Components.h
@@ -1,12 +1,12 @@
 #pragma once
 #include <glm\ext\matrix_float4x4.hpp>
 #include <string>
+
 #include "BaseComponent.h"
 #include "TransformComponent.h"
 #include "LightComponent.h"
 #include "CameraComponent.h"
 #include "MeshComponent.h"
-#include "ModelComponent.h"
 #include "QuakeMap.h"
 #include "RigidbodyComponent.h"
 #include "SphereCollider.h"
@@ -15,10 +15,6 @@
 #include "CharacterControllerComponent.h"
 #include "ParentComponent.h"
 #include "NameComponent.h"
-#include <imgui/imgui.h>
 #include "../Entities/Entity.h"
 
 
-// TODO: include components here.
-
-
diff --git a/Nuake/src/Scene/Components/MeshComponent.cpp b/Nuake/src/Scene/Components/MeshComponent.cpp
index 74ca53a5..997f7007 100644
--- a/Nuake/src/Scene/Components/MeshComponent.cpp
+++ b/Nuake/src/Scene/Components/MeshComponent.cpp
@@ -1,178 +1,138 @@
 #include "MeshComponent.h"
-#include <GL\glew.h>
+#include "src/Rendering/Textures/Material.h"
 #include "src/Rendering/Renderer.h"
-#include "src/Rendering/Vertex.h"
-#include "src/Core/MaterialManager.h"
-#include <imgui\imgui.h>
+#include "src/Rendering/Textures/TextureManager.h"
 
 namespace Nuake {
-    Vertex vertices[] = {
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f, -0.5f),  glm::vec2(1.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f, -0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f, -0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f, -0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, -1), glm::vec3(0, 1, 0), glm::vec3(-1, 0, 0), 1.0f  },
-
-            Vertex{ glm::vec3(-0.5f, -0.5f,  0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f,  0.5f),  glm::vec2(1.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f,  0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f,  0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(0, 0, 1), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), 1.0f  },
-
-            Vertex{ glm::vec3(-0.5f,  0.5f,  0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f, -0.5f), glm::vec2(1.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f,  0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f,  0.5f), glm::vec2(1.0f, 0.0f), glm::vec3(-1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1), 1.0f  },
-
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f, -0.5f),  glm::vec2(1.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f, -0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f, -0.5f),  glm::vec2(0.0f, 1.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f,  0.5f),  glm::vec2(0.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, -1), 1.0f  },
-
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f, -0.5f),  glm::vec2(1.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f, -0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f,  0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, -1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-
-            Vertex{ glm::vec3(-0.5f,  0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f, -0.5f),  glm::vec2(1.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(0.5f,  0.5f,  0.5f),  glm::vec2(1.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f,  0.5f), glm::vec2(0.0f, 0.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-            Vertex{ glm::vec3(-0.5f,  0.5f, -0.5f), glm::vec2(0.0f, 1.0f), glm::vec3(0, 1, 0), glm::vec3(1, 0, 0), glm::vec3(0, 0, 1), 1.0f  },
-    };
-
-    void MeshComponent::LoadModel(const std::string path) {
-        //Assimp::Importer import;
-        //const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
-        //
-        //if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
-        //{
-        //    printf("ERROR::ASSIMP::");
-        //    return;
-        //}
-        //
-        //ProcessNode(scene->mRootNode, scene);
+    void MeshComponent::Draw()
+    {
+        for (auto m : meshes)
+            m->Draw();
     }
 
-    unsigned int sphereVAO = 0;
-    unsigned int indexCount;
-    
-
-    //void MeshComponent::ProcessNode(aiNode * node, const aiScene* scene)
-    //{
-        /// process all the node's meshes (if any)
-        //or (unsigned int i = 0; i < node->mNumMeshes; i++)
-        //
-        //   aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
-        //   meshes.push_back(ProcessNode(mesh, scene));
-        //
-        /// then do the same for each of its children
-        //or (unsigned int i = 0; i < node->mNumChildren; i++)
-        //
-        //   ProcessNode(node->mChildren[i], scene);
-        //
-    //}
-
-    MeshComponent::MeshComponent() {
-        //BuildTangents();
-
-        // Setup buffers
-        glGenVertexArrays(1, &VAO);
-        glBindVertexArray(VAO);
-
-        glGenBuffers(1, &VBO);
-        glBindBuffer(GL_ARRAY_BUFFER, VBO);
-
-        glBindBuffer(GL_ARRAY_BUFFER, VBO);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-
-        // Position
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
-        glEnableVertexAttribArray(0);
-    
-        // UV
-        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 3));
-        glEnableVertexAttribArray(1);
-
-        // Normal
-        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 5));
-        glEnableVertexAttribArray(2);
-
-        // Tangent
-        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 8));
-        glEnableVertexAttribArray(3);
-
-        // Bitangent
-        glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 11));
-        glEnableVertexAttribArray(4);
-
-        // Texture
-        glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 14));
-        glEnableVertexAttribArray(5);
-
-        //m_Material = MaterialManager::Get()->LoadMaterial("Planks");
-
-    } 
-
-    void MeshComponent::BuildTangents()
+    void MeshComponent::LoadModel()
     {
-        for (int i = 0; i < 36; i += 3) {
-            glm::vec3 pos1 = vertices[i].position;
-            glm::vec3 pos2 = vertices[i + 1].position;
-            glm::vec3 pos3 = vertices[i + 2].position;
+        this->meshes.clear();
+        Assimp::Importer import;
+        import.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", 90);
+        const aiScene* scene = import.ReadFile(FileSystem::Root + ModelPath, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
 
-            glm::vec2 uv1 = vertices[i].uv;
-            glm::vec2 uv2 = vertices[i + 1].uv;
-            glm::vec2 uv3 = vertices[i + 2].uv;
+        if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
+        {
+            Logger::Log("ASSIMP! Failed to load model" + std::string(import.GetErrorString()), CRITICAL);
+            return;
+        }
 
-            glm::vec3 edge1 = pos2 - pos1;
-            glm::vec3 edge2 = pos3 - pos1;
-            glm::vec2 deltaUV1 = uv2 - uv1;
-            glm::vec2 deltaUV2 = uv3 - uv1;
+        ProcessNode(scene->mRootNode, scene);
+    }
 
-            float f = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV2.x * deltaUV1.y);
-
-            for (int j = 0; i < 3; i++)
-            {
-                vertices[i + j].tangent.x = f * (deltaUV2.y * edge1.x - deltaUV1.y * edge2.x);
-                vertices[i + j].tangent.y = f * (deltaUV2.y * edge1.y - deltaUV1.y * edge2.y);
-                vertices[i + j].tangent.z = f * (deltaUV2.y * edge1.z - deltaUV1.y * edge2.z);
-
-                vertices[i + j].bitangent.x = f * (-deltaUV2.x * edge1.x + deltaUV1.x * edge2.x);
-                vertices[i + j].bitangent.y = f * (-deltaUV2.x * edge1.y + deltaUV1.x * edge2.y);
-                vertices[i + j].bitangent.z = f * (-deltaUV2.x * edge1.z + deltaUV1.x * edge2.z);
-            }
+    void MeshComponent::ProcessNode(aiNode* node, const aiScene* scene)
+    {
+        // process all the node's meshes (if any)
+        for (unsigned int i = 0; i < node->mNumMeshes; i++)
+        {
+            aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+            meshes.push_back(ProcessMesh(mesh, scene));
+        }
+        // then do the same for each of its children
+        for (unsigned int i = 0; i < node->mNumChildren; i++)
+        {
+            ProcessNode(node->mChildren[i], scene);
         }
     }
 
-    void MeshComponent::SetMaterial(const std::string materialName) 
+    Ref<Mesh> MeshComponent::ProcessMesh(aiMesh* mesh, const aiScene* scene)
     {
-        m_Material = MaterialManager::Get()->LoadMaterial(materialName);
+        std::vector<Vertex> vertices;
+        std::vector<unsigned int> indices;
+        std::vector<Texture> textures;
+
+        for (unsigned int i = 0; i < mesh->mNumVertices; i++)
+        {
+            Vertex vertex;
+            vertex.texture = 1.0f;
+
+            glm::vec3 vector;
+            vector.x = mesh->mVertices[i].x;
+            vector.y = mesh->mVertices[i].y;
+            vector.z = mesh->mVertices[i].z;
+            vertex.position = vector;
+
+            vector.x = mesh->mNormals[i].x;
+            vector.y = mesh->mNormals[i].y;
+            vector.z = mesh->mNormals[i].z;
+            vertex.normal = vector;
+
+            vector.x = mesh->mTangents[i].x;
+            vector.y = mesh->mTangents[i].y;
+            vector.z = mesh->mTangents[i].z;
+            vertex.tangent = vector;
+
+            vector.x = mesh->mBitangents[i].x;
+            vector.y = mesh->mBitangents[i].y;
+            vector.z = mesh->mBitangents[i].z;
+            vertex.bitangent = vector;
+
+            if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
+            {
+                glm::vec2 vec;
+                vec.x = mesh->mTextureCoords[0][i].x;
+                vec.y = mesh->mTextureCoords[0][i].y;
+                vertex.uv = vec;
+            }
+            else
+                vertex.uv = glm::vec2(0.0f, 0.0f);
+
+            vertices.push_back(vertex);
+        }
+        // process indices
+        for (unsigned int i = 0; i < mesh->mNumFaces; i++)
+        {
+            aiFace face = mesh->mFaces[i];
+            for (unsigned int j = 0; j < face.mNumIndices; j++)
+                indices.push_back(face.mIndices[j]);
+        }
+        // process material
+        if (mesh->mMaterialIndex >= 0)
+        {
+            aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
+            aiString str;
+            std::string directory = FileSystem::Root + this->ModelPath + "/../";
+            material->GetTexture(aiTextureType_DIFFUSE, 0, &str);
+            Ref<Material> newMaterial = CreateRef<Material>(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+
+            //material->GetTexture(aiTextureType_NORMALS, 0, &str);
+            //newMaterial->SetNormal(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+            //
+            //material->GetTexture(aiTextureType_METALNESS, 0, &str);
+            //newMaterial->SetMetalness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+            //
+            //material->GetTexture(aiTextureType_DIFFUSE_ROUGHNESS, 0, &str);
+            //newMaterial->SetRoughness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+
+            //material->GetTexture(aiTextureType_DISPLACEMENT, 0, &str);
+            //newMaterial->SetDisplacement(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+
+            //material->GetTexture(aiTextureType_AMBIENT_OCCLUSION, 0, &str);
+            //newMaterial->SetAO(TextureManager::Get()->GetTexture(directory + str.C_Str()));
+
+            return CreateRef<Mesh>(vertices, indices, newMaterial);
+        }
     }
 
-    void MeshComponent::Draw(glm::mat4 projection, glm::mat4 view, glm::mat4 transform) {
+    std::vector<Texture*> MeshComponent::LoadMaterialTextures(aiMaterial* mat, aiTextureType type)
+    {
+        std::vector<Texture*> textures;
+        for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
+        {
+            aiString str;
+            mat->GetTexture(type, i, &str);
+            std::string fixedStr = std::string(str.C_Str());
 
-        Renderer::m_Shader->SetUniformMat4f("u_Model", transform);
-
-        m_Material->Bind();
-
-        //RenderSphere();
-       glBindVertexArray(VAO);
-       glDrawArrays(GL_TRIANGLES, 0, 36);
-    }
-
-    void MeshComponent::DrawEditor() {
-        int choice = 0;
-        ImGui::Combo("Material", (int*)&choice, "Marble\0Copper\0Gold\0Paving\0Planks\0Default Material");
+            Texture* texture = new Texture(directory + fixedStr);
+            textures.push_back(texture);
+        }
+        return textures;
     }
 }
 
diff --git a/Nuake/src/Scene/Components/MeshComponent.h b/Nuake/src/Scene/Components/MeshComponent.h
index 1cf6e0c9..dfc35cf4 100644
--- a/Nuake/src/Scene/Components/MeshComponent.h
+++ b/Nuake/src/Scene/Components/MeshComponent.h
@@ -1,24 +1,30 @@
 #pragma once
-#include "../Rendering/Textures/Material.h"
 #include <glm\ext\matrix_float4x4.hpp>
-#include "BaseComponent.h"
+#include <vector>
+#include "src/Rendering/Mesh/Mesh.h"
 
-namespace Nuake {
-	class MeshComponent {
+#include "assimp/Importer.hpp"
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+#include <string>
 
-	private:
-		unsigned int VAO;
-		unsigned int VBO;
-		Ref<Material> m_Material;
+namespace Nuake
+{
+    struct MeshComponent
+    {
+        std::string ModelPath;
 
-		void BuildTangents();
-	public:
-		void LoadModel(const std::string path);
-		//void ProcessNode(aiNode* node, const aiScene* scene);
-		MeshComponent();
+        MeshComponent()
+        {
+            //loadModel(path);
+        }
+        void LoadModel();
+        void Draw();
+        std::vector<Ref<Mesh>> meshes;
+        std::string directory;
 
-		void SetMaterial(const std::string materialName);
-		void Draw(glm::mat4 projection, glm::mat4 view, glm::mat4 transform);
-		void DrawEditor();
-	};
+        void ProcessNode(aiNode* node, const aiScene* scene);
+        Ref<Mesh> ProcessMesh(aiMesh* mesh, const aiScene* scene);
+        std::vector<Texture*> LoadMaterialTextures(aiMaterial* mat, aiTextureType type);
+    };
 }
diff --git a/Nuake/src/Scene/Components/ModelComponent.cpp b/Nuake/src/Scene/Components/ModelComponent.cpp
deleted file mode 100644
index 4cbf7b19..00000000
--- a/Nuake/src/Scene/Components/ModelComponent.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-#include "ModelComponent.h"
-#include "src/Rendering/Textures/Material.h"
-#include "src/Rendering/Renderer.h"
-#include "src/Core/TextureManager.h"
-
-namespace Nuake {
-    void ModelComponent::Draw()
-    {
-        for (auto m : meshes) {
-            m.Draw();
-        }
-    }
-
-    void ModelComponent::LoadModel()
-    {
-        this->meshes.clear();
-        Assimp::Importer import;
-        import.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", 90);
-        const aiScene* scene = import.ReadFile(FileSystem::Root + ModelPath, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_CalcTangentSpace);
-
-        if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
-        {
-            Logger::Log("ASSIMP! Failed to load model" + std::string(import.GetErrorString()), CRITICAL);
-            return;
-        }
-
-        ProcessNode(scene->mRootNode, scene);
-    }
-
-    void ModelComponent::ProcessNode(aiNode* node, const aiScene* scene)
-    {
-        // process all the node's meshes (if any)
-        for (unsigned int i = 0; i < node->mNumMeshes; i++)
-        {
-            aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
-            meshes.push_back(ProcessMesh(mesh, scene));
-        }
-        // then do the same for each of its children
-        for (unsigned int i = 0; i < node->mNumChildren; i++)
-        {
-            ProcessNode(node->mChildren[i], scene);
-        }
-    }
-
-    Mesh ModelComponent::ProcessMesh(aiMesh* mesh, const aiScene* scene)
-    {
-        std::vector<Vertex> vertices;
-        std::vector<unsigned int> indices;
-        std::vector<Texture> textures;
-
-        for (unsigned int i = 0; i < mesh->mNumVertices; i++)
-        {
-            Vertex vertex;
-            vertex.texture = 1.0f;
-
-            glm::vec3 vector;
-            vector.x = mesh->mVertices[i].x;
-            vector.y = mesh->mVertices[i].y;
-            vector.z = mesh->mVertices[i].z;
-            vertex.position = vector;
-
-            vector.x = mesh->mNormals[i].x;
-            vector.y = mesh->mNormals[i].y;
-            vector.z = mesh->mNormals[i].z;
-            vertex.normal = vector;
-
-            vector.x = mesh->mTangents[i].x;
-            vector.y = mesh->mTangents[i].y;
-            vector.z = mesh->mTangents[i].z;
-            vertex.tangent = vector;
-
-            vector.x = mesh->mBitangents[i].x;
-            vector.y = mesh->mBitangents[i].y;
-            vector.z = mesh->mBitangents[i].z;
-            vertex.bitangent = vector;
-
-            if (mesh->mTextureCoords[0]) // does the mesh contain texture coordinates?
-            {
-                glm::vec2 vec;
-                vec.x = mesh->mTextureCoords[0][i].x;
-                vec.y = mesh->mTextureCoords[0][i].y;
-                vertex.uv = vec;
-            }
-            else
-                vertex.uv = glm::vec2(0.0f, 0.0f);
-
-            vertices.push_back(vertex);
-        }
-        // process indices
-        for (unsigned int i = 0; i < mesh->mNumFaces; i++)
-        {
-            aiFace face = mesh->mFaces[i];
-            for (unsigned int j = 0; j < face.mNumIndices; j++)
-                indices.push_back(face.mIndices[j]);
-        }
-        // process material
-        if (mesh->mMaterialIndex >= 0)
-        {
-            aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
-            aiString str;
-            std::string directory = FileSystem::Root + this->ModelPath + "/../";
-            material->GetTexture(aiTextureType_DIFFUSE, 0, &str);
-            Ref<Material> newMaterial = CreateRef<Material>(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-
-            //material->GetTexture(aiTextureType_NORMALS, 0, &str);
-            //newMaterial->SetNormal(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-            //
-            //material->GetTexture(aiTextureType_METALNESS, 0, &str);
-            //newMaterial->SetMetalness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-            //
-            //material->GetTexture(aiTextureType_DIFFUSE_ROUGHNESS, 0, &str);
-            //newMaterial->SetRoughness(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-
-            //material->GetTexture(aiTextureType_DISPLACEMENT, 0, &str);
-            //newMaterial->SetDisplacement(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-
-            //material->GetTexture(aiTextureType_AMBIENT_OCCLUSION, 0, &str);
-            //newMaterial->SetAO(TextureManager::Get()->GetTexture(directory + str.C_Str()));
-
-            return Mesh(vertices, indices, newMaterial);
-        }
-    }
-
-    std::vector<Texture*> ModelComponent::LoadMaterialTextures(aiMaterial* mat, aiTextureType type)
-    {
-        std::vector<Texture*> textures;
-        for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
-        {
-            aiString str;
-            mat->GetTexture(type, i, &str);
-            std::string fixedStr = std::string(str.C_Str());
-
-            Texture* texture = new Texture(directory + fixedStr);
-            textures.push_back(texture);
-        }
-        return textures;
-    }
-}
-
diff --git a/Nuake/src/Scene/Components/ModelComponent.h b/Nuake/src/Scene/Components/ModelComponent.h
deleted file mode 100644
index 606caad5..00000000
--- a/Nuake/src/Scene/Components/ModelComponent.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-#include <glm\ext\matrix_float4x4.hpp>
-#include <vector>
-#include "src/Rendering/Mesh/Mesh.h"
-
-#include "assimp/Importer.hpp"
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-#include <string>
-
-namespace Nuake
-{
-    class ModelComponent
-    {
-    public:
-        std::string ModelPath;
-
-        ModelComponent()
-        {
-            //loadModel(path);
-        }
-        void LoadModel();
-        void Draw();
-    private:
-        std::vector<Mesh> meshes;
-        std::string directory;
-
-        void ProcessNode(aiNode* node, const aiScene* scene);
-        Mesh ProcessMesh(aiMesh* mesh, const aiScene* scene);
-        std::vector<Texture*> LoadMaterialTextures(aiMaterial* mat, aiTextureType type);
-    };
-}
diff --git a/Nuake/src/Scene/Components/NameComponent.h b/Nuake/src/Scene/Components/NameComponent.h
index f64a2d68..b66c7507 100644
--- a/Nuake/src/Scene/Components/NameComponent.h
+++ b/Nuake/src/Scene/Components/NameComponent.h
@@ -1,6 +1,6 @@
 #pragma once
-#include "src/Resource/Serializable.h"
 #include "src/Core/OS.h"
+#include "src/Resource/Serializable.h"
 
 namespace Nuake {
     class NameComponent 
diff --git a/Nuake/src/Scene/Components/QuakeMap.cpp b/Nuake/src/Scene/Components/QuakeMap.cpp
index ff309095..1a8212dc 100644
--- a/Nuake/src/Scene/Components/QuakeMap.cpp
+++ b/Nuake/src/Scene/Components/QuakeMap.cpp
@@ -1,6 +1,4 @@
 #include "QuakeMap.h"
-#include "src/Core/Core.h"
-#include "src/Core/MaterialManager.h"
 
 namespace Nuake {
 	void QuakeMapComponent::Draw()
diff --git a/Nuake/src/Scene/Components/QuakeMap.h b/Nuake/src/Scene/Components/QuakeMap.h
index ced79ff5..60b852a0 100644
--- a/Nuake/src/Scene/Components/QuakeMap.h
+++ b/Nuake/src/Scene/Components/QuakeMap.h
@@ -1,10 +1,10 @@
 #pragma once
 #include <string>
 #include <vector>
-#include "../Rendering/Mesh/Mesh.h"
-#include "../Resource/TrenchbroomMap.h"
-#include "../Resource/Serializable.h"
-#include <src/Scene/Systems/QuakeMapBuilder.h>
+
+#include "src/Rendering/Mesh/Mesh.h"
+#include "src/Resource/Serializable.h"
+#include "src/Scene/Systems/QuakeMapBuilder.h"
 
 namespace Nuake {
 	class QuakeMapComponent
@@ -13,7 +13,6 @@ namespace Nuake {
 
 	public:
 		std::vector<Ref<Mesh>> m_Meshes;
-		Ref<TrenchbroomMap> Map;
 		std::string Path;
 		bool HasCollisions = false;
 		void Load(std::string path, bool collisions);
diff --git a/Nuake/src/Scene/Scene.cpp b/Nuake/src/Scene/Scene.cpp
index e8d78fca..e878ef4f 100644
--- a/Nuake/src/Scene/Scene.cpp
+++ b/Nuake/src/Scene/Scene.cpp
@@ -1,23 +1,24 @@
 #pragma once
-#include <src/Scene/Systems/ScriptingSystem.h>
-#include <src/Scene/Systems/PhysicsSystem.h>
-#include <src/Scene/Systems/TransformSystem.h>
+#include "src/Scene/Systems/ScriptingSystem.h"
+#include "src/Scene/Systems/PhysicsSystem.h"
+#include "src/Scene/Systems/TransformSystem.h"
 
-#include <src/Scene/Systems/QuakeMapBuilder.h>
-#include <src/Scene/Components/BSPBrushComponent.h>
+#include "src/Scene/Systems/QuakeMapBuilder.h"
+#include "src/Scene/Components/BSPBrushComponent.h"
 
 #include "Scene.h"
 #include "Entities/Entity.h"
 
-#include "../Rendering/Renderer.h"
-#include "../Core/MaterialManager.h"
-#include "../Core/Physics/PhysicsManager.h"
-#include "../Core/Core.h"
+#include "src/Rendering/Renderer.h"
+#include "src/Rendering/Textures/MaterialManager.h"
+#include "src/Core/Physics/PhysicsManager.h"
+#include "src/Core/Core.h"
 
 #include <GL/glew.h>
 
-#include "../../Engine.h"
-#include "../Core/FileSystem.h"
+#include "Engine.h"
+#include "Engine.h"
+#include "src/Core/FileSystem.h"
 #include "Components/Components.h"
 #include "Components/BoxCollider.h"
 #include "Components/LuaScriptComponent.h"
@@ -26,7 +27,7 @@
 #include <fstream>
 #include <streambuf>
 #include <chrono>
-#include <src/Core/OS.h>
+#include "src/Core/OS.h"
 
 namespace Nuake {
 	Ref<Scene> Scene::New()
@@ -157,7 +158,7 @@ namespace Nuake {
 
 	void Scene::DrawShadows()
 	{
-		auto modelView = m_Registry.view<TransformComponent, ModelComponent>();
+		auto meshView = m_Registry.view<TransformComponent, MeshComponent>();
 		auto quakeView = m_Registry.view<TransformComponent, QuakeMapComponent>();
 		auto view = m_Registry.view<TransformComponent, LightComponent>();
 
@@ -185,12 +186,12 @@ namespace Nuake {
 				light.m_Framebuffers[i]->Bind();
 				light.m_Framebuffers[i]->Clear();
 				Renderer::m_ShadowmapShader->SetUniformMat4f("lightSpaceMatrix", light.mViewProjections[i]);
-				for (auto e : modelView)
+				for (auto e : meshView)
 				{
-					auto [transform, model] = modelView.get<TransformComponent, ModelComponent>(e);
+					auto [transform, mesh] = meshView.get<TransformComponent, MeshComponent>(e);
 
 					Renderer::m_ShadowmapShader->SetUniformMat4f("model", transform.GetTransform());
-					model.Draw();
+					mesh.Draw();
 				}
 				std::vector<BSPDrawObject> sortedBrushes = std::vector<BSPDrawObject>();
 
@@ -288,13 +289,18 @@ namespace Nuake {
 		{
 			Renderer::m_Shader->SetUniform1f("u_Exposure", cam->Exposure);
 
-			auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
+			auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
 			for (auto e : view) {
-				auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
+				auto [transform, model, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
 				Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
 				Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
 				Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
 
+				for (auto& m : model.meshes)
+				{
+					Renderer::SubmitMesh(m, transform.GetTransform());
+				}
+
 				model.Draw();
 			}
 
@@ -306,29 +312,22 @@ namespace Nuake {
 				if (model.IsTransparent)
 					continue;
 
-				float dist = glm::length(transform.GlobalTranslation - cam->GetTranslation());
-				sortedBrushes.push_back({
-					dist,
-					model,
-					transform.GetTransform()
-					});
-			}
-
-			std::sort(sortedBrushes.begin(), sortedBrushes.end(), DepthSort);
-
-			for (auto& b : sortedBrushes)
-			{
 				Renderer::m_Shader->SetUniformMat4f("u_View", cam->GetTransform());
 				Renderer::m_Shader->SetUniformMat4f("u_Projection", cam->GetPerspective());
-				Renderer::m_Shader->SetUniformMat4f("u_Model", b.transform);
 
-				for (auto& e : b.brush.Meshes)
-					e->Draw();
+				for (auto& b : model.Meshes)
+				{
+					Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
+
+					Renderer::SubmitMesh(b, transform.GetTransform());
+				}
 			}
 
 			Renderer::m_DebugShader->SetUniformMat4f("u_View", cam->GetTransform());
 			Renderer::m_DebugShader->SetUniformMat4f("u_Projection", cam->GetPerspective());
 
+			Renderer::Flush();
+
 			PhysicsManager::Get()->DrawDebug();
 		}
 	}
@@ -340,26 +339,23 @@ namespace Nuake {
 
 		glDisable(GL_CULL_FACE);
 		if (env->ProceduralSkybox)
-		{
 			env->ProceduralSkybox->Draw(m_EditorCamera);
-		}
 
 		Renderer::m_Shader->Bind();
 		env->Push();
 		glEnable(GL_DEPTH_TEST);
 
-		// Push lights
+		auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
+		for (auto l : view) 
 		{
-			auto view = m_Registry.view<TransformComponent, LightComponent, ParentComponent>();
-			for (auto l : view) {
-				auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
+			auto [transform, light, parent] = view.get<TransformComponent, LightComponent, ParentComponent>(l);
 
-				if (light.SyncDirectionWithSky)
-					light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
+			if (light.SyncDirectionWithSky)
+				light.Direction = GetEnvironment()->ProceduralSkybox->GetSunDirection();
 
-				light.Draw(transform, m_EditorCamera);
-			}
+			light.Draw(transform, m_EditorCamera);
 		}
+
 		glEnable(GL_CULL_FACE);
 		glCullFace(GL_FRONT);
 		Renderer::m_Shader->Bind();
@@ -368,50 +364,38 @@ namespace Nuake {
 		{
 			Renderer::m_Shader->SetUniform1f("u_Exposure", m_EditorCamera->Exposure);
 			Renderer::m_Shader->SetUniform3f("u_EyePosition", m_EditorCamera->GetTranslation().x, m_EditorCamera->GetTranslation().y, m_EditorCamera->GetTranslation().z);
-			auto view = m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
-			for (auto e : view) {
-				auto [transform, model, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
+			auto view = m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
+			for (auto e : view) 
+			{
+				auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
 
 				Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
 				Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
 				Renderer::m_Shader->SetUniformMat4f("u_Model", transform.GetTransform());
-				model.Draw();
+
+				for(auto& m : mesh.meshes)
+					Renderer::SubmitMesh(m, transform.GetTransform());
 			}
 
-			std::vector<BSPDrawObject> sortedBrushes = std::vector<BSPDrawObject>();
-
-
 			auto quakeView = m_Registry.view<TransformComponent, BSPBrushComponent, ParentComponent>();
-			for (auto e : quakeView) {
+			for (auto e : quakeView) 
+			{
 				auto [transform, model, parent] = quakeView.get<TransformComponent, BSPBrushComponent, ParentComponent>(e);
 
 				if (model.IsTransparent)
 					continue;
 
-				float dist = glm::length(transform.GlobalTranslation - m_EditorCamera->GetTranslation());
-				sortedBrushes.push_back({
-					dist,
-					model,
-					transform.GetTransform()
-					});
+				for (auto& b : model.Meshes)
+					Renderer::SubmitMesh(b, transform.GetTransform());
 
 				Renderer::m_Shader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
 				Renderer::m_Shader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
 			}
 
-			std::sort(sortedBrushes.begin(), sortedBrushes.end(), DepthSort);
-
-			for (auto& b : sortedBrushes)
-			{
-				Renderer::m_Shader->SetUniformMat4f("u_Model", b.transform);
-
-				for (auto& d : b.brush.Meshes)
-					d->Draw();
-			}
-
 			Renderer::m_DebugShader->Bind();
 			auto boxCollider = m_Registry.view<TransformComponent, BoxColliderComponent, ParentComponent>();
-			for (auto e : boxCollider) {
+			for (auto e : boxCollider) 
+			{
 				auto [transform, box, parent] = boxCollider.get<TransformComponent, BoxColliderComponent, ParentComponent>(e);
 				Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
 				Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
@@ -424,7 +408,8 @@ namespace Nuake {
 			}
 
 			auto sphereCollider = m_Registry.view<TransformComponent, SphereColliderComponent, ParentComponent>();
-			for (auto e : sphereCollider) {
+			for (auto e : sphereCollider) 
+			{
 				auto [transform, box, parent] = sphereCollider.get<TransformComponent, SphereColliderComponent, ParentComponent>(e);
 
 				Renderer::m_DebugShader->SetUniformMat4f("u_View", m_EditorCamera->GetTransform());
@@ -450,10 +435,12 @@ namespace Nuake {
 				Renderer::m_DebugShader->SetUniformMat4f("u_Projection", m_EditorCamera->GetPerspective());
 				Renderer::m_DebugShader->SetUniformMat4f("u_Model", transform.GetTransform());
 				Renderer::m_DebugShader->SetUniform4f("u_Color", 1.f, 0.0f, 0.1f, 0.5f);
-				for (auto& e : model.Meshes) {
-					e->Draw();
-				}
+
+				for (auto& e : model.Meshes)
+					Renderer::SubmitMesh(e, transform.GetTransform());
 			}
+
+			Renderer::Flush();
 		}
 	}
 
@@ -495,12 +482,14 @@ namespace Nuake {
 		}
 	}
 
-	Entity Scene::CreateEmptyEntity() {
+	Entity Scene::CreateEmptyEntity() 
+	{
 		Entity entity = { m_Registry.create(), this };
 		return entity;
 	}
 
-	Entity Scene::CreateEntity(const std::string& name) {
+	Entity Scene::CreateEntity(const std::string& name) 
+	{
 		Entity entity = { m_Registry.create(), this };
 
 		// Must have transform
diff --git a/Nuake/src/Scene/Scene.h b/Nuake/src/Scene/Scene.h
index e9890e42..131456c4 100644
--- a/Nuake/src/Scene/Scene.h
+++ b/Nuake/src/Scene/Scene.h
@@ -1,15 +1,18 @@
 #pragma once
-#include "../Rendering/Camera.h"
-#include "Lighting/Environment.h"
 #include <vector>
+#include "src/Core/Core.h"
+#include "src/Core/Maths.h"
+
 #include "entt/entt.hpp"
 
-#include "../Core/Core.h"
+#include "src/Rendering/Camera.h"
+#include "Lighting/Environment.h"
+
 #include "EditorCamera.h"
-#include "../Resource/Serializable.h"
+#include "src/Resource/Serializable.h"
 #include "src/UI/UserInterface.h"
-#include "../Core/Maths.h"
-#include <src/Scene/Systems/System.h>
+
+#include "src/Scene/Systems/System.h"
 
 namespace Nuake {
 	class Entity;
diff --git a/Nuake/src/Scene/Systems/PhysicsSystem.cpp b/Nuake/src/Scene/Systems/PhysicsSystem.cpp
index 7b4097e0..3e904eef 100644
--- a/Nuake/src/Scene/Systems/PhysicsSystem.cpp
+++ b/Nuake/src/Scene/Systems/PhysicsSystem.cpp
@@ -89,7 +89,6 @@ namespace Nuake
 
 	void PhysicsSystem::Update(Timestep ts)
 	{
-		// Update rigidbodies
 		PhysicsManager::Get()->Step(ts);
 
 		auto brushes = m_Scene->m_Registry.view<TransformComponent, BSPBrushComponent>();
diff --git a/Nuake/src/Scene/Systems/QuakeMapBuilder.cpp b/Nuake/src/Scene/Systems/QuakeMapBuilder.cpp
index ca7ede8f..f57606af 100644
--- a/Nuake/src/Scene/Systems/QuakeMapBuilder.cpp
+++ b/Nuake/src/Scene/Systems/QuakeMapBuilder.cpp
@@ -1,12 +1,12 @@
 #include "QuakeMapBuilder.h"
-#include <src/Scene/Scene.h>
-#include <src/Scene/Entities/Entity.h>
-#include <src/Scene/Components/QuakeMap.h>
-#include <src/Scene/Components/ParentComponent.h>
-#include <vector>
-#include <iostream>
-#include <sstream>
 #include "src/Core/FileSystem.h"
+#include "src/Core/String.h"
+#include "src/Scene/Scene.h"
+#include "src/Scene/Entities/Entity.h"
+#include "src/Scene/Components/QuakeMap.h"
+#include "src/Scene/Components/ParentComponent.h"
+#include <vector>
+
 
 extern "C" {
     #include <libmap/h/map_parser.h>
@@ -14,32 +14,21 @@ extern "C" {
     #include <libmap/h/surface_gatherer.h>
 }
 
-#include <src/Core/MaterialManager.h>
-#include <src/Scene/Components/BSPBrushComponent.h>
-#include <src/Scene/Components/TransformComponent.h>
-#include <src/Scene/Components/LightComponent.h>
-#include <src/Scene/Components/NameComponent.h>
-#include <src/Scene/Components/TriggerZone.h>
-#include <src/Resource/FGD/FGDClass.h>
-#include <src/Scene/Components/WrenScriptComponent.h>
+#include "src/Rendering/Textures/MaterialManager.h"
+#include "src/Scene/Components/BSPBrushComponent.h"
+#include "src/Scene/Components/TransformComponent.h"
+#include "src/Scene/Components/LightComponent.h"
+#include "src/Scene/Components/NameComponent.h"
+#include "src/Scene/Components/TriggerZone.h"
+#include "src/Resource/FGD/FGDClass.h"
+#include "src/Scene/Components/WrenScriptComponent.h"
 
 namespace Nuake {
     Ref<Material> DefaultMaterial;
-    std::vector<std::string> split(const std::string& s, char delim)
-    {
-        std::vector<std::string> result;
-        std::stringstream ss(s);
-        std::string item;
 
-        while (getline(ss, item, delim))
-        {
-            result.push_back(item);
-        }
-
-        return result;
-    }
-
-    void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
+    void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst, 
+                                        Scene* scene, Entity& parent, 
+                                        const std::string& target, const std::string& targetname)
     {
         std::vector<Vertex> vertices;
         std::vector<unsigned int> indices;
@@ -98,7 +87,9 @@ namespace Nuake {
         bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
     }
 
-    void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname)
+    void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst, 
+                                        Scene* scene, Entity& parent, 
+                                        const std::string& target, const std::string& targetname)
     {
         std::vector<Vertex> vertices;
         std::vector<unsigned int> indices;
@@ -191,7 +182,9 @@ namespace Nuake {
             bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
     }
 
-    void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname, FGDBrushEntity fgdBrush)
+    void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst, 
+                                            Scene* scene, Entity& parent, 
+        const std::string& target, const std::string& targetname, FGDBrushEntity fgdBrush)
     {
         std::vector<Vertex> vertices;
         std::vector<unsigned int> indices;
@@ -373,12 +366,11 @@ namespace Nuake {
 
                 if (key == "origin")
                 {
-                    // Positon split with space.
-                    std::vector<std::string> splits = split(value, ' ');
+                    std::vector<std::string> splits = String::Split(value, ' ');
 
-                    float x = std::stof(splits[1]) * (1.f / 64.f);
-                    float y = std::stof(splits[2]) * (1.f / 64.f);
-                    float z = std::stof(splits[0]) * (1.f / 64.f);
+                    float x = String::ToFloat(splits[1]) * (1.f / 64.f);
+                    float y = String::ToFloat(splits[2]) * (1.f / 64.f);
+                    float z = String::ToFloat(splits[0]) * (1.f / 64.f);
 
                     Vector3 position = Vector3(x, y, z);
                     newEntity.GetComponent<TransformComponent>().Translation = position;
diff --git a/Nuake/src/Scene/Systems/QuakeMapBuilder.h b/Nuake/src/Scene/Systems/QuakeMapBuilder.h
index 8ee50b80..be17ecbb 100644
--- a/Nuake/src/Scene/Systems/QuakeMapBuilder.h
+++ b/Nuake/src/Scene/Systems/QuakeMapBuilder.h
@@ -12,9 +12,17 @@ namespace Nuake {
 	class QuakeMapBuilder
 	{
 	private:
-		void CreateTrigger(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname);
-		void CreateBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname);
-		void CreateFuncBrush(brush* brush, brush_geometry* brush_inst, Scene* scene, Entity& parent, std::string target, std::string targetname, FGDBrushEntity fgdBrush);
+		void CreateTrigger(brush* brush, brush_geometry* brush_inst,
+			Scene* scene, Entity& parent,
+			const std::string& target, const std::string& targetname);
+
+		void CreateBrush(brush* brush, brush_geometry* brush_inst,
+			Scene* scene, Entity& parent,
+			const std::string& target, const std::string& targetname);
+
+		void CreateFuncBrush(brush* brush, brush_geometry* brush_inst,
+			Scene* scene, Entity& parent,
+			const std::string& target, const std::string& targetname, FGDBrushEntity fgdBrush);
 	public:
 		QuakeMapBuilder() {}
 
diff --git a/Nuake/src/Window.cpp b/Nuake/src/Window.cpp
index 4b41278c..f40d698e 100644
--- a/Nuake/src/Window.cpp
+++ b/Nuake/src/Window.cpp
@@ -147,7 +147,6 @@ namespace Nuake {
         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 5, (void*)(sizeof(float) * 3));
         glEnableVertexAttribArray(1);
 
-        // TODO: Style should move to editor
         ImGui::CreateContext();
         ImGuiIO& io = ImGui::GetIO(); (void)io;
         //io.Fonts->AddFontDefault();
diff --git a/Nuake/src/Window.h b/Nuake/src/Window.h
index 0fff514c..b58e1e40 100644
--- a/Nuake/src/Window.h
+++ b/Nuake/src/Window.h
@@ -30,7 +30,6 @@ namespace Nuake
 		static Ref<Window> Get(); // Get the window instance
 		GLFWwindow* GetHandle();
 
-
 		bool ShouldClose();
 
 		int Init();
@@ -40,8 +39,6 @@ namespace Nuake
 		void EndDraw();
 
 		Ref<FrameBuffer> GetFrameBuffer() const;
-		Ref<Texture> GetSceneRenderTexture();
-		void DrawQuad();
 
 		Ref<Scene> GetScene();
 		bool SetScene(Ref<Scene> scene);