Merge remote-tracking branch 'origin/master' into PlayerMovement

# Conflicts:
#	include/Engine/Collision/Collision.h
#	include/Engine/Collision/CollisionSystem.h
#	include/Engine/Collision/TriggerSystem.h
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/CollisionTestLevel.xml
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Collision/Collision.cpp
#	src/Game/Game.cpp

include/Engine/Core/Ray.h

@@ -2,7 +2,7 @@
 #define Ray_h__
 
 #include "../GLM.h"
-#include "Common.h"
+#include "../Common.h"
 
 class Ray
 {

include/Engine/Core/ResourceManager.h

@@ -12,7 +12,6 @@
 /** Base Resource class.
 
 	Implement this class for every resource to be handled by the resource manager.
-	Implement Create() to return a new object of that type.
 */
 class Resource
 {
@@ -22,6 +21,23 @@ protected:
 	Resource() { }
 
 public:
+    //Should be thrown in a Resource's constructor if it cannot complete because another resource is still loading.
+    //Not actually an error, just a message to the ResourceManager.
+    struct StillLoadingException : public std::exception
+    {
+        virtual const char* what() const throw()
+        {
+            return "Resource is still loading.";
+        }
+    };
+    struct FailedLoadingException : public std::exception
+    {
+        virtual const char* what() const throw()
+        {
+            return "Resource is failed to load.";
+        }
+    };
+
 	// Pretend that this is a pure virtual function that you have to implement
 	// FIXME: Why did we do this again instead of just using the constructor?
 	// static Resource* Create(std::string resourceName);
@@ -33,6 +49,15 @@ public:
 	unsigned int ResourceID;
 };
 
+//Any class inheriting from this class will always be loaded on the master thread, not on a parallel worker thread.
+//This is important in case some instructions must be executed on the main thread, e.g. OpenGL commands, like glBindBuffer.
+//This resource can still be loaded asyncronously, but it will not be loaded in a thread, instead it's constructor will 
+//be called once on every ResourceManager::Load, just throw StillLoadingException in the constructor if it is not done yet.
+class ThreadUnsafeResource : public Resource
+{
+    friend class ResourceManager;
+};
+
 /** Singleton resource manager to keep track of and cache any external engine assets */
 class ResourceManager
 {
@@ -40,6 +65,7 @@ private:
 	ResourceManager();
 
 public:
+    static bool UseThreading;
 	/*static ResourceManager& Instance()
 	{
 	static ResourceManager s;
@@ -49,15 +75,6 @@ public:
 	template <typename T>
 	static void RegisterType(std::string typeName);
 
-	/** Preloads a resource and caches it for future use
-
-		@tparam T Resource type.
-		@param resourceName Fully qualified name of the resource to preload.
-	*/
-	template <typename T>
-	static void Preload(std::string resourceName);
-	static void Preload(std::string resourceType, std::string resourceName);
-
 	/** Checks if a resource is in cache
 
 		@param resourceType Resource type as string.
@@ -65,15 +82,20 @@ public:
 	*/
 	// TODO: Templateify
 	static bool IsResourceLoaded(std::string resourceType, std::string resourceName);
+    
+	/** Return value should always be a valid pointer, will throw an exception on error.
+        If the resource has been loaded already, returns a pointer to it.
 
-	/** Hot-loads a resource and caches it for future use
+        If Async is false: Hot-loads a resource, caches it for future use, and returns a pointer to it. 
+        If Async is true: If the resource is not loaded yet, starts loading the resource 
+        in the background and throws Resource::StillLoadingException immediately.
 
 		@tparam T Resource type.
+		@tparam async Set this to true if the resource should be loaded asyncronously.
 		@param resourceName Fully qualified name of the resource to load.
 	*/
-	template <typename T>
-	static T* Load(std::string resourceName, Resource* parent = nullptr);
-	static Resource* Load(std::string resourceType, std::string resourceName, Resource* parent = nullptr);
+    template <typename T, bool async = false>
+    static T* Load(const std::string& resourceName, Resource* parent = nullptr);
 
 	/** Reloads an already loaded resource, keeping its resource ID intact.
 
@@ -87,19 +109,31 @@ public:
 	static void Update();
 
 private:
+    //This is a haxy way to make sure that IsMainThread is run when the program starts, so the master thread id is set.
+    struct MasterThreadChecker
+    {
+        MasterThreadChecker()
+        {
+            ResourceManager::IsMainThread();
+        }
+    };
+    const static MasterThreadChecker m_Checker;
+
 	static std::unordered_map<std::string, std::string> m_CompilerTypenameToResourceType;
     static std::unordered_map<std::string, std::function<Resource*(std::string)>> m_FactoryFunctions; // type -> factory function
 	static std::unordered_map<std::pair<std::string, std::string>, Resource*> m_ResourceCache; // (type, name) -> resource
 	static std::unordered_map<std::string, Resource*> m_ResourceFromName; // name -> resource
 	static std::unordered_map<Resource*, Resource*> m_ResourceParents; // resource -> parent resource
 
+	static std::unordered_map<std::pair<std::string, std::string>, boost::thread> m_LoadingThreads; // (type, name) -> loading thread
+	static std::unordered_map<std::pair<std::string, std::string>, std::exception_ptr> m_LoadingThreadExceptions; // (type, name) -> exceptions
+    static boost::recursive_mutex m_Mutex;
+
 	// TODO: Getters for IDs
 	static unsigned int m_CurrentResourceTypeID;
 	static std::unordered_map<std::string, unsigned int> m_ResourceTypeIDs;
 	// Number of resources of a type. Doubles as local ID.
 	static std::unordered_map<unsigned int, unsigned int> m_ResourceCount;
-	// Flag to suppress hot-load warnings when a preloading resource chain loads another resource
-	static bool m_Preloading;
 
 	static FileWatcher m_FileWatcher;
 	static void fileWatcherCallback(std::string path, FileWatcher::FileEventFlags flags);
@@ -108,22 +142,13 @@ private:
 	static unsigned int GetNewResourceID(unsigned int typeID);
 
 	// Internal: Create a resource and cache it
-	static Resource* CreateResource(std::string resourceType, std::string resourceName, Resource* parent);
+    static Resource* createResourceThrowing(const std::string& resourceType, const std::string& resourceName, Resource* parent);
+	static Resource* createResource(const std::string& resourceType, const std::string& resourceName, Resource* parent, std::exception_ptr& exception);
+    static Resource* cacheResource(Resource* resource, const std::string& resourceType, const std::string& resourceName, Resource* parent);
+
+    static bool IsMainThread();
 };
 
-template <typename T>
-T* ResourceManager::Load(std::string resourceName, Resource* parent /* = nullptr */)
-{
-	auto resourceTypename = typeid(T).name();
-	auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
-	if (it == m_CompilerTypenameToResourceType.end()) {
-		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
-		return nullptr;
-	}
-
-	return static_cast<T*>(Load(it->second, resourceName, parent));
-}
-
 template <typename T>
 void ResourceManager::RegisterType(std::string typeName)
 {
@@ -131,17 +156,85 @@ void ResourceManager::RegisterType(std::string typeName)
 	m_FactoryFunctions[typeName] = [](std::string resourceName) { return new T(resourceName); };
 }
 
-template <typename T>
-void ResourceManager::Preload(std::string resourceName)
+template <typename T, bool async>
+static T* ResourceManager::Load(const std::string& resourceName, Resource* parent /* = nullptr */)
 {
-	auto resourceTypename = typeid(T).name();
-	auto it = m_CompilerTypenameToResourceType.find(resourceTypename);
-	if (it == m_CompilerTypenameToResourceType.end()) {
-		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
-		return;
-	}
+    auto resourceTypename = typeid(T).name();
+    auto iter = m_CompilerTypenameToResourceType.find(resourceTypename);
+    if (iter == m_CompilerTypenameToResourceType.end()) {
+        LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceTypename);
+        throw Resource::FailedLoadingException();
+    }
 
-	Preload(it->second, resourceName);
+    std::string resourceType = iter->second;
+    constexpr bool mustNotLoadInThread = std::is_base_of<ThreadUnsafeResource, T>::value;
+    if (mustNotLoadInThread && !IsMainThread()) {
+        LOG_ERROR("Failed to Load \"%s\": ThreadUnsafeResource type \"%s\" load in the constructor of another resource that is loaded asyncronously.", resourceName.c_str(), iter->second.c_str());
+        throw Resource::FailedLoadingException();
+    }
+
+    auto cacheKey = std::make_pair(resourceType, resourceName);
+    decltype(m_ResourceCache)::iterator it;
+    //If a thread has already been launched to load this resource.
+    auto tIt = m_LoadingThreads.find(cacheKey);
+    if (UseThreading && tIt != m_LoadingThreads.end()) {
+        if (async) {
+            //Throw StillLoadingException if the thread is still working.
+            if (!tIt->second.try_join_for(boost::chrono::nanoseconds(1))) {
+                throw Resource::StillLoadingException();
+            }
+            //Else we know the thread has completed.
+        } else {
+            //Wait for the thread to finish loading.
+            tIt->second.join();
+        }
+        //When the thread is done, delete the thread.
+        m_LoadingThreads.erase(tIt);
+        //Rethrow the thread exception if it threw any.
+        auto excIt = m_LoadingThreadExceptions.find(cacheKey);
+        std::exception_ptr exception = excIt->second;
+        m_LoadingThreadExceptions.erase(excIt);
+        if (exception) {
+            std::rethrow_exception(exception);
+        }
+    }
+
+    //If resource has already been cached and completely loaded.
+    it = m_ResourceCache.find(cacheKey);
+    if (it != m_ResourceCache.end()) {
+        if (it->second != nullptr) {
+            return static_cast<T*>(it->second);
+        } else {
+            //Don't return null on failure, exception instead.
+            throw Resource::FailedLoadingException();
+        }
+    }
+
+    //If resource is not cached..
+    if (UseThreading && async) {
+        if (mustNotLoadInThread) {
+            try {
+                return static_cast<T*>(createResourceThrowing(resourceType, resourceName, parent));
+            } catch (const Resource::StillLoadingException&) {
+                throw;
+            }
+        } else {
+            //Create a thread that loads the resource into cache.
+            m_LoadingThreads[cacheKey] = boost::thread(createResource, resourceType, resourceName, parent, m_LoadingThreadExceptions[cacheKey]);
+            throw Resource::StillLoadingException();
+        }
+    } else {
+        //load and return the resource.
+        while (true) {
+            try {
+                return static_cast<T*>(createResourceThrowing(resourceType, resourceName, parent));
+            } catch (const Resource::StillLoadingException&) {
+                continue;
+            } catch (const std::exception&) {
+                throw;
+            }
+        }
+    }
 }
 
 #endif

include/Engine/Rendering/BaseTexture.h

@@ -3,7 +3,7 @@
 
 #include "../Core/ResourceManager.h"
 
-class BaseTexture : public Resource
+class BaseTexture : public ThreadUnsafeResource
 {
 	friend class ResourceManager;
 

include/Engine/Rendering/DrawFinalPass.h

@@ -0,0 +1,38 @@
+#ifndef DrawFinalPass_h__
+#define DrawFinalPass_h__
+
+#include "IRenderer.h"
+#include "DrawFinalPassState.h"
+#include "LightCullingPass.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawFinalPass
+{
+public:
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
+    ~DrawFinalPass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(RenderScene& scene);
+
+    //Getters
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    Texture* m_WhiteTexture;
+
+    const IRenderer* m_Renderer;
+    const LightCullingPass* m_LightCullingPass;
+
+    ShaderProgram* m_ForwardPlusProgram;
+
+};
+
+#endif 

include/Engine/Rendering/DrawFinalPassState.h

@@ -0,0 +1,15 @@
+#ifndef DrawFinalPassState_h__
+#define DrawFinalPassState_h__
+
+#include "Rendering/RenderState.h"
+
+class DrawFinalPassState : public RenderState
+{
+public:
+    DrawFinalPassState();
+    ~DrawFinalPassState();
+private:
+
+};
+
+#endif

include/Engine/Rendering/IRenderer.h

@@ -9,6 +9,8 @@
 #include "Camera.h"
 #include "RenderQueue.h"
 #include "Model.h"
+#include "../Core/World.h" //So temp
+
 
 struct PickData
 {
@@ -43,6 +45,8 @@ public:
 	virtual void Draw(RenderFrame& rq) = 0;
     virtual PickData Pick(glm::vec2 screenCord) = 0;
 
+    World* m_World; //Temp world, untill viktor merge.
+
 protected:
 	Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
 	bool m_Fullscreen = false;

include/Engine/Rendering/LightCullingPass.h

@@ -0,0 +1,83 @@
+#ifndef LightCullingPass_h__
+#define LightCullingPass_h__
+
+#define TILE_SIZE 16 
+#define MAX_LIGHTS_PER_TILE 200
+
+#include "IRenderer.h"
+#include "LightCullingPassState.h"
+#include "ShaderProgram.h"
+#include "RenderQueue.h"
+
+
+class LightCullingPass
+{
+public:
+    LightCullingPass(IRenderer* renderer);
+    ~LightCullingPass();
+
+    void GenerateNewFrustum(RenderScene& scene);
+    void OnResolutionChange();
+    void SetSSBOSizes();
+    void CullLights(RenderScene& scene);
+    void FillLightList(RenderScene& scene);
+
+    GLuint FrustumSSBO() const { return m_FrustumSSBO; }
+    GLuint LightSSBO() const { return m_LightSSBO; }
+    GLuint LightGridSSBO() const { return m_LightGridSSBO; }
+    GLuint LightOffsetSSBO() const { return m_LightOffsetSSBO; }
+    GLuint LightIndexSSBO() const { return m_LightIndexSSBO; }
+private:
+
+    void InitializeSSBOs();
+    void InitializeShaderPrograms();
+
+    const IRenderer* m_Renderer;
+
+    GLuint m_FrustumSSBO = 0;
+    GLuint m_LightSSBO = 0;
+    GLuint m_LightGridSSBO = 0;
+    GLuint m_LightOffsetSSBO = 0;
+    GLuint m_LightIndexSSBO = 0;
+
+    ShaderProgram* m_CalculateFrustumProgram;
+    ShaderProgram* m_LightCullProgram;
+
+    int m_NumberOfTiles = 0;
+
+    struct Plane {
+        glm::vec3 Normal;
+        float d;
+    };
+
+    struct Frustum {
+        Plane Planes[4];
+    };
+    Frustum* m_Frustums;
+
+    //This should be a component
+    struct PointLight {
+        glm::vec4 Position = glm::vec4(0.f);
+        glm::vec4 Color = glm::vec4(1.f);
+        float Radius = 5.f;
+        float Intensity = 0.8f;
+        float Falloff = 0.3f;
+        float Padding = 1337;
+    };
+    std::vector<PointLight> m_PointLights;
+
+    struct LightGrid {
+        float Start;
+        float Amount;
+        glm::vec2 Padding;
+    };
+
+    LightGrid* m_LightGrid;
+
+    int m_LightOffset = 0;
+
+    float* m_LightIndex;
+};
+
+
+#endif

include/Engine/Rendering/Model.h

@@ -4,7 +4,7 @@
 #include "RawModel.h"
 #include "../OpenGL.h"
 
-class Model : public RawModel
+class Model : public ThreadUnsafeResource
 {
 	friend class ResourceManager;
 
@@ -13,11 +13,15 @@ private:
 
 public:
 	~Model();
+    const std::vector<RawModel::MaterialGroup>& MaterialGroups() const { return m_RawModel->MaterialGroups; }
+    const glm::mat4& Matrix() const { return m_RawModel->m_Matrix; }
+    const std::vector<RawModel::Vertex>& Vertices() const { return m_RawModel->m_Vertices; }
 
 	GLuint VAO;
 	GLuint ElementBuffer;
 
 private:
+    RawModel* m_RawModel;
 	GLuint VertexBuffer;
 	GLuint DiffuseVertexColorBuffer;
 	GLuint SpecularVertexColorBuffer;

include/Engine/Rendering/ModelJob.h

@@ -15,16 +15,16 @@
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::Model::MaterialGroup texGroup, ComponentWrapper modelComponent, World* world)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world)
         : RenderJob()
     {
         Model = model;
-        TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-        DiffuseTexture = texGroup.Texture.get();
-        NormalTexture = texGroup.NormalMap.get();
-        SpecularTexture = texGroup.SpecularMap.get();
-        StartIndex = texGroup.StartIndex;
-        EndIndex = texGroup.EndIndex;
+        TextureID = (matGroup.Texture) ? matGroup.Texture->ResourceID : 0;
+        DiffuseTexture = matGroup.Texture.get();
+        NormalTexture = matGroup.NormalMap.get();
+        SpecularTexture = matGroup.SpecularMap.get();
+        StartIndex = matGroup.StartIndex;
+        EndIndex = matGroup.EndIndex;
         Matrix = matrix;
         Color = modelComponent["Color"];
         Entity = modelComponent.EntityID;
@@ -44,7 +44,7 @@ struct ModelJob : RenderJob
     const ::Model* Model = nullptr;
     unsigned int StartIndex = 0;
     unsigned int EndIndex = 0;
-    const World* World;
+    World* World;
 
     void CalculateHash() override
     {

include/Engine/Rendering/PickingPass.h

@@ -1,6 +1,8 @@
 #ifndef PickingPass_h__
 #define PickingPass_h__
 
+
+
 #include "IRenderer.h"
 #include "PickingPassState.h"
 #include "FrameBuffer.h"
@@ -9,6 +11,8 @@
 #include "../Core/EventBroker.h"
 #include "../Core/World.h"
 
+
+
 class PickingPass
 {
 public:
@@ -21,7 +25,6 @@ public:
     void Draw(RenderScene& scene);
     void ClearPicking();
 
-
     //Getters
     const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
     //const std::unordered_map<glm::ivec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }

include/Engine/Rendering/PointLightJob.h

@@ -0,0 +1,39 @@
+#ifndef PointLightJob_h__
+#define PointLightJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "RenderJob.h"
+#include "../Core/Transform.h"
+#include "../Core/World.h"
+
+struct PointLightJob : RenderJob
+{
+    PointLightJob(ComponentWrapper transformComponent, ComponentWrapper pointLightComponent, World* m_World)
+        : RenderJob()
+    {
+        Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
+        Position = glm::vec4(Transform::AbsolutePosition(m_World, transformComponent.EntityID), 1.f);
+        Color = (glm::vec4)pointLightComponent["Color"];
+        Radius = (double)pointLightComponent["Radius"];
+        Intensity = (double)pointLightComponent["Intensity"];
+        Falloff = (double)pointLightComponent["Falloff"];
+    };
+
+    glm::vec4 Position;
+    glm::vec4 Color;
+    float Radius;
+    float Intensity;
+    float Falloff;
+    float padding = 123;
+
+    void CalculateHash() override
+    {
+        Hash = 0;
+    }
+};
+
+#endif

include/Engine/Rendering/RawModel.h

@@ -47,14 +47,17 @@ public:
 	{
 		float Shininess;
         float Transparency;
+        std::string TexturePath;
 		std::shared_ptr<::Texture> Texture;
+        std::string NormalMapPath;
 		std::shared_ptr<::Texture> NormalMap;
+        std::string SpecularMapPath;
 		std::shared_ptr<::Texture> SpecularMap;
 		unsigned int StartIndex;
 		unsigned int EndIndex;
 	};
 
-	std::vector<MaterialGroup> TextureGroups;
+	std::vector<MaterialGroup> MaterialGroups;
 
 	std::vector<Vertex> m_Vertices;
 	std::vector<unsigned int> m_Indices;

include/Engine/Rendering/RenderQueue.h

@@ -11,7 +11,7 @@
 #include "Camera.h"
 #include "RenderJob.h"
 #include "ModelJob.h"
-
+#include "PointLightJob.h"
 
 
 /*
@@ -34,11 +34,12 @@ struct SpriteJob : RenderJob
 
 struct PointLightJob : RenderJob
 {
-	glm::vec3 Position;
-	glm::vec3 SpecularColor = glm::vec3(1, 1, 1);
-	glm::vec3 DiffuseColor = glm::vec3(1, 1, 1);
-	float Radius = 1.f;
-    float Intensity = 0.8f;
+    glm::vec4 Position;
+	glm::vec4 Color;
+	float Radius;
+    float Intensity;
+    float Falloff;
+    float padding = 123;
 
 	void CalculateHash() override
 	{
@@ -51,13 +52,13 @@ struct RenderScene
 {
     ::Camera* Camera;
     std::list<std::shared_ptr<RenderJob>> ForwardJobs;
-    std::list<std::shared_ptr<RenderJob>> LightJobs;
+    std::list<std::shared_ptr<RenderJob>> PointLightJobs;
     Rectangle Viewport;
 
 	void Clear()
 	{
         ForwardJobs.clear();
-        LightJobs.clear();
+        PointLightJobs.clear();
 	}
 };
 

include/Engine/Rendering/RenderSystem.h

@@ -13,6 +13,7 @@
 #include "Camera.h"
 #include "ModelJob.h"
 #include "Renderer.h"
+#include "PointLightJob.h"
 #include "../Core/Transform.h"
 #include "DebugCameraInputController.h"
 
@@ -45,6 +46,7 @@ private:
     void updateProjectionMatrix(ComponentWrapper& cameraComponent);
     
     void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    void fillLight(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
 
     EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);

include/Engine/Rendering/Renderer.h

@@ -12,9 +12,12 @@
 #include "../Core/World.h"
 #include "PickingPass.h"
 #include "DrawScenePass.h"
+#include "LightCullingPass.h"
+#include "DrawFinalPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
+#include "../Core/Transform.h"
 
 class Renderer : public IRenderer
 {
@@ -44,24 +47,26 @@ private:
 
     DrawScenePass* m_DrawScenePass;
     PickingPass* m_PickingPass;
+    LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
+    DrawFinalPass* m_DrawFinalPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
     void InitializeShaders();
     void InitializeTextures();
-    void InitializeSSBOs();
     void InitializeRenderPasses();
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
     void DrawScreenQuad(GLuint textureToDraw);
 
+    static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
+    void FillDepth(RenderScene& scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
 	ShaderProgram* m_BasicForwardProgram;
     ShaderProgram* m_DrawScreenQuadProgram;
-
 };
 
 #endif

include/Engine/Sound/EContinueSound.h

@@ -0,0 +1,17 @@
+#ifndef Events_ContinueSound_h__
+#define Events_ContinueSound_h__
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace Events
+{
+// Continues to play a sound from where it was paused.
+struct ContinueSound : Event
+{
+    EntityID EmitterID;
+};
+
+}
+
+#endif

include/Engine/Sound/EPauseSound.h

@@ -0,0 +1,17 @@
+#ifndef Events_PauseSound_h__
+#define Events_PauseSound_h__
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace Events
+{
+// Pauses a playing sound
+struct PauseSound : Event
+{
+    EntityID EmitterID;
+};
+
+}
+
+#endif

include/Engine/Sound/EPlayBackgroundMusic.h

@@ -0,0 +1,18 @@
+#ifndef Events_PlayBackgroundMusic_h__
+#define Events_PlayBackgroundMusic_h__
+
+#include <string>
+#include "Core/Entity.h"
+#include "Core/Event.h"
+
+namespace Events
+{
+// Play a sound that will be heared the same anywhere
+struct PlayBackgroundMusic : public Event
+{
+    std::string FilePath = "";
+};
+
+}
+
+#endif

include/Engine/Sound/EPlaySoundOnEntity.h

@@ -0,0 +1,21 @@
+#ifndef Events_PlaySoundOnEntity_h__
+#define Events_PlaySoundOnEntity_h__
+
+#include <string>
+#include "Core/Entity.h"
+#include "Core/Event.h"
+
+namespace Events
+{
+
+// Plays a sound on an entity with a SoundEmitter component attached.
+// Sound behavior is thereby specified in the SoundEmitter component.
+struct PlaySoundOnEntity : public Event
+{
+    EntityID EmitterID = 0;
+    std::string FilePath = "";
+};
+
+}
+
+#endif

include/Engine/Sound/EPlaySoundOnPosition.h

@@ -0,0 +1,26 @@
+#ifndef Events_PlaySoundOnPosition_h__
+#define Events_PlaySoundOnPosition_h__
+
+#include <string>
+#include <glm/common.hpp>
+#include "Core/Event.h"
+
+namespace Events
+{
+
+// Plays a sound on a given position. Idk if this would be useful.
+struct PlaySoundOnPosition : public Event
+{
+    glm::vec3 Position = glm::vec3(0);
+    std::string FilePath = "";
+    float Gain = 1;
+    float Pitch = 1;
+    bool Loop = false;
+    float MaxDistance = 20;
+    float RollOffFactor = 1;
+    float ReferenceDistance = 1;
+};
+
+}
+
+#endif

include/Engine/Sound/ESetBGMGain.h

@@ -0,0 +1,16 @@
+#ifndef Events_SetBGMGain_h__
+#define Events_SetBGMGain_h__
+
+#include "Core/Event.h"
+
+namespace Events
+{
+// Set the "volume" for all background sounds
+struct SetBGMGain : public Event
+{
+    float Gain;
+};
+
+}
+
+#endif

include/Engine/Sound/ESetSFXGain.h

@@ -0,0 +1,16 @@
+#ifndef Events_SetSFXGain_h__
+#define Events_SetSFXGain_h__
+
+#include "Core/Event.h"
+
+namespace Events
+{
+// Set the "volume" for all effect sounds
+struct SetSFXGain : public Event
+{
+    float Gain;
+};
+
+}
+
+#endif

include/Engine/Sound/EStopSound.h

@@ -0,0 +1,17 @@
+#ifndef Events_StopSound_h__
+#define Events_StopSound_h__
+
+#include "Core/EventBroker.h"
+#include "Core/Entity.h"
+
+namespace Events
+{
+// Stops a sound emitter, and will also delete it.
+struct StopSound : Event
+{
+    EntityID EmitterID;
+};
+
+}
+
+#endif

include/Engine/Sound/Sound.h

@@ -0,0 +1,113 @@
+#ifndef Sound_h__
+#define Sound_h__
+
+#include "Core/ResourceManager.h"
+
+class Sound : public Resource
+{
+    friend class ResourceManager;
+public:
+    Sound(std::string path) { m_Buffer = LoadFile(path); m_Path = path; }
+    ~Sound() { ClearBuffer(); }
+    ALuint Buffer() { return m_Buffer; }
+    std::string Path() { return m_Path; }
+    float Gain() { return m_Gain; }
+    void SetGain(float value) { m_Gain = value; }
+    void ClearBuffer() { alDeleteBuffers(1, &m_Buffer); m_BufferCache.clear(); };
+
+private:
+    float m_Gain = 1;
+    ALuint m_Buffer;
+    std::string m_Path;
+
+    // File info
+    char m_Type[4];
+    unsigned long m_Size, m_ChunkSize;
+    short m_FormatType, m_Channels;
+    unsigned long m_SampleRate, m_AvgBytesPerSec;
+    short m_BytesPerSample, m_BitsPerSample;
+    unsigned int m_DataSize;
+    std::map<std::string, ALuint> m_BufferCache;
+
+    ALuint LoadFile(std::string path)
+    {
+        if (m_BufferCache.find(path) != m_BufferCache.end()) {
+            return m_BufferCache[path];
+        }
+
+        // Open file
+        FILE *fp = fopen(path.c_str(), "rb");
+        if (!fp) {
+            printf("Sound: Failed to open file %s, no such file exists", path.c_str());
+            return 0;
+        }
+
+        //CHECK FOR VALID WAVE-FILE
+        fread(m_Type, sizeof(char), 4, fp);
+        if (m_Type[0] != 'R' || m_Type[1] != 'I' || m_Type[2] != 'F' || m_Type[3] != 'F') {
+            printf("ERROR: No RIFF in WAVE-file");
+            return 0;
+        }
+
+        fread(&m_Size, 4 * sizeof(char), 1, fp);
+        fread(m_Type, sizeof(char), 4, fp);
+        if (m_Type[0] != 'W' || m_Type[1] != 'A' || m_Type[2] != 'V' || m_Type[3] != 'E') {
+            printf("ERROR: Not WAVE-file");
+            return 0;
+        }
+
+        fread(m_Type, sizeof(char), 4, fp);
+        if (m_Type[0] != 'f' || m_Type[1] != 'm' || m_Type[2] != 't' || m_Type[3] != ' ') {
+            printf("ERROR: No fmt in WAVE-file");
+            return 0;
+        }
+
+        // READ THE DATA FROM WAVE-FILE
+        fread(&m_ChunkSize, 4 * sizeof(char), 1, fp);
+        fread(&m_FormatType, 2 * sizeof(char), 1, fp);
+        fread(&m_Channels, 2 * sizeof(char), 1, fp);
+        fread(&m_SampleRate, 4 * sizeof(char), 1, fp);
+        fread(&m_AvgBytesPerSec, 4 * sizeof(char), 1, fp);
+        fread(&m_BytesPerSample, 2 * sizeof(char), 1, fp);
+        fread(&m_BitsPerSample, 2 * sizeof(char), 1, fp);
+
+        fread(m_Type, sizeof(char), 4, fp);
+        if (m_Type[0] != 'd' || m_Type[1] != 'a' || m_Type[2] != 't' || m_Type[3] != 'a') {
+            printf("ERROR: WAVE-file Missing data");
+            return 0;
+        }
+
+        fread(&m_DataSize, 4 * sizeof(char), 1, fp);
+
+        unsigned char* buf = new unsigned char[m_DataSize];
+        fread(buf, sizeof(char), m_DataSize, fp);
+        fclose(fp);
+
+        // Create buffer
+        ALuint format = 0;
+        if (m_BitsPerSample == 8) {
+            if (m_Channels == 1) {
+                format = AL_FORMAT_MONO8;
+            } else if (m_Channels == 2) {
+                format = AL_FORMAT_STEREO8;
+            }
+        }
+        if (m_BitsPerSample == 16) {
+            if (m_Channels == 1) {
+                format = AL_FORMAT_MONO16;
+            } else if (m_Channels == 2) {
+                format = AL_FORMAT_STEREO16;
+            }
+        }
+
+        ALuint buffer;
+        alGenBuffers(1, &buffer);
+        alBufferData(buffer, format, buf, m_DataSize, m_SampleRate);
+        delete[] buf;
+
+        m_BufferCache[path] = buffer;
+        return buffer;
+    }
+};
+
+#endif

include/Engine/Sound/SoundSystem.h

@@ -0,0 +1,101 @@
+#ifndef SoundSystem_h__
+#define SoundSystem_h__
+
+#include <unordered_map>
+
+#include "glm/common.hpp"
+#include "glm/gtx/rotate_vector.hpp" // Calculate Up vector
+#include "OpenAL/al.h"
+#include "OpenAL/alc.h"
+
+#include "Core/World.h"
+#include "Core/EventBroker.h"
+#include "Core/Transform.h" // Absolute transform
+#include "Sound/Sound.h"
+#include "Sound/EPlaySoundOnEntity.h"
+#include "Sound/EPlaySoundOnPosition.h"
+#include "Sound/EPlayBackgroundMusic.h"
+#include "Sound/EPauseSound.h"
+#include "Sound/EContinueSound.h"
+#include "Sound/EStopSound.h"
+#include "Sound/ESetBGMGain.h"
+#include "Sound/ESetSFXGain.h"
+
+enum class SoundType {
+    SFX,
+    BGM
+};
+
+struct Source
+{
+    Source() { }
+    Sound* SoundResource = nullptr;
+    ALuint ALsource;
+    SoundType Type;
+};
+
+class SoundSystem
+{
+public:
+    SoundSystem() { }
+    SoundSystem(World* world, EventBroker* eventBroker, bool editorMode);
+    ~SoundSystem();
+    // Update emitters / listener
+    void Update(double dt); 
+private:
+    // Help functions for working with OpenaAL
+    void setListenerPos(glm::vec3 pos) { alListener3f(AL_POSITION, pos.x, pos.y, pos.z); };
+    void setListenerVel(glm::vec3 vel) { alListener3f(AL_VELOCITY, vel.x, vel.y, vel.z); };
+    void setListenerOri(glm::vec3 ori);
+    glm::vec3 listnerPos() { glm::vec3 pos; alGetListener3f(AL_POSITION, &pos.x, &pos.y, &pos.z); return pos; };
+    glm::vec3 listenerVel() { glm::vec3 vel; alGetListener3f(AL_VELOCITY, &vel.x, &vel.y, &vel.z); return vel; };
+    glm::vec3 listenerOri() { glm::vec3 ori; alGetListener3f(AL_ORIENTATION, &ori.x, &ori.y, &ori.z); return ori; };
+    void setSourcePos(ALuint source, glm::vec3 pos) { ALfloat spos[3] = { pos.x, pos.y, pos.z };  alSourcefv(source, AL_POSITION, spos); };
+    void setSourceVel(ALuint source, glm::vec3 vel) { ALfloat svel[3] = { vel.x, vel.y, vel.z };  alSourcefv(source, AL_VELOCITY, svel); };
+
+    // Logic 
+    void initOpenAL();
+    void updateEmitters(double dt);
+    void updateListener(double dt);
+    void deleteInactiveEmitters();
+    void addNewEmitters(double dt);
+    Source* createSource(std::string filePath);
+    void playSound(Source* source);
+    void stopSound(Source* source);
+    void stopEmitters();
+    ALenum getSourceState(ALuint source);
+    void setGain(Source* source, float gain);
+    void setSoundProperties(ALuint source, ComponentWrapper* soundComponent);
+
+    // OpenAL system variables
+    ALCdevice* m_ALCdevice = nullptr;
+    ALCcontext* m_ALCcontext = nullptr;
+
+    // Logic
+    World* m_World = nullptr;
+    EventBroker* m_EventBroker = nullptr;
+    std::unordered_map<EntityID, Source*> m_Sources;
+    float m_BGMVolumeChannel = 1.0f;
+    float m_SFXVolumeChannel = 1.f;
+    bool m_EditorEnabled = false;
+
+    // Events
+    EventRelay<SoundSystem, Events::PlaySoundOnEntity> m_EPlaySoundOnEntity;
+    bool OnPlaySoundOnEntity(const Events::PlaySoundOnEntity &e);
+    EventRelay<SoundSystem, Events::PlaySoundOnPosition> m_EPlaySoundOnPosition;
+    bool OnPlaySoundOnPosition(const Events::PlaySoundOnPosition &e);
+    EventRelay<SoundSystem, Events::PlayBackgroundMusic> m_EPlayBackgroundMusic;
+    bool OnPlayBackgroundMusic(const Events::PlayBackgroundMusic &e);
+    EventRelay<SoundSystem, Events::PauseSound> m_EPauseSound;
+    bool OnPauseSound(const Events::PauseSound &e);
+    EventRelay<SoundSystem, Events::StopSound> m_EStopSound;
+    bool OnStopSound(const Events::StopSound &e);
+    EventRelay<SoundSystem, Events::ContinueSound> m_EContinueSound;
+    bool OnContinueSound(const Events::ContinueSound &e);
+    EventRelay<SoundSystem, Events::SetBGMGain> m_ESetBGMGain; 
+    bool OnSetBGMGain(const Events::SetBGMGain &e); // Not tested
+    EventRelay<SoundSystem, Events::SetSFXGain> m_ESetSFXGain; 
+    bool OnSetSFXGain(const Events::SetSFXGain &e); // Not tested
+};
+
+#endif