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

# Conflicts:
#	include/Engine/Core/InputController.h
#	include/Game/Game.h

include/Engine/Core/ComponentPool.h

@@ -54,6 +54,8 @@ public:
     ComponentWrapper Allocate(EntityID entity);
     // Get the component belonging to a specific entity
     ComponentWrapper GetByEntity(EntityID ent);
+    // Returns true if the pool contains a component for the specified entity
+    bool KnowsEntity(EntityID ent);
     // Delete a component and free its memory
     void Delete(ComponentWrapper& wrapper);
 

include/Engine/Core/ConfigFile.h

@@ -5,6 +5,7 @@
 #include <boost/filesystem.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/ini_parser.hpp>
+#include <boost/lexical_cast.hpp>
 
 #include "../Common.h"
 #include "ResourceManager.h"
@@ -19,12 +20,14 @@ private:
 public:
 	template <typename T>
 	T Get(std::string key, T defaultValue);
+    template <typename T>
+    std::vector<std::pair<std::string, T>> GetAll(std::string key);
 	template <typename T>
 	void Set(std::string key, T value);
 
 	void SaveToDisk();
 
-	private:
+private:
 	boost::filesystem::path m_Path;
 	boost::property_tree::ptree m_PTreeDefaults;
 	boost::property_tree::ptree m_PTreeOverrides;
@@ -37,6 +40,21 @@ T ConfigFile::Get(std::string key, T defaultValue)
 	return m_PTreeMerged.get<T>(key, defaultValue);
 }
 
+template <typename T>
+std::vector<std::pair<std::string, T>> ConfigFile::GetAll(std::string key)
+{
+    std::vector<std::pair<std::string, T>> out;
+    auto parent = m_PTreeMerged.find(key);
+    if (parent == m_PTreeMerged.not_found()) {
+        return out;
+    }
+    for (auto& child : parent->second) {
+        T value = boost::lexical_cast<T>(child.second.data());
+        out.push_back(std::make_pair(child.first, value));
+    }
+    return out;
+}
+
 template <typename T>
 void ConfigFile::Set(std::string key, T value)
 {

include/Engine/Core/EKeyboardChar.h

@@ -0,0 +1,17 @@
+#ifndef Events_KeyboardChar_h__
+#define Events_KeyboardChar_h__
+
+#include "EventBroker.h"
+
+namespace Events
+{
+
+struct KeyboardChar : Event
+{
+    double Timestamp = 0.f;
+	unsigned int Char = 0;
+};
+
+}
+
+#endif

include/Engine/Core/EMouseScroll.h

@@ -0,0 +1,17 @@
+#ifndef Events_MouseScroll_h__
+#define Events_MouseScroll_h__
+
+#include "EventBroker.h"
+
+namespace Events
+{
+
+struct MouseScroll : Event
+{
+    double DeltaX;
+    double DeltaY;
+};
+
+}
+
+#endif

include/Engine/Core/EventBroker.h

@@ -17,119 +17,119 @@ class EventBroker;
 
 class BaseEventRelay
 {
-friend class EventBroker;
+    friend class EventBroker;
 
 protected:
-	BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
-		: m_ContextTypeName(contextTypeName)
-		, m_EventTypeName(eventTypeName)
-		, m_Broker(nullptr) 
-	{ }
-	~BaseEventRelay();
+    BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
+        : m_ContextTypeName(contextTypeName)
+        , m_EventTypeName(eventTypeName)
+        , m_Broker(nullptr)
+    { }
+    ~BaseEventRelay();
 
 public:
-	virtual bool Receive(const std::shared_ptr<Event> event) = 0;
+    virtual bool Receive(const std::shared_ptr<Event> event) = 0;
 
 protected:
-	std::string m_ContextTypeName;
-	std::string m_EventTypeName;
-	EventBroker* m_Broker;
+    std::string m_ContextTypeName;
+    std::string m_EventTypeName;
+    EventBroker* m_Broker;
 };
 
 template <typename ContextType, typename EventType>
 class EventRelay : public BaseEventRelay
 {
 public:
-	typedef std::function<bool(const EventType&)> CallbackType;
+    typedef std::function<bool(const EventType&)> CallbackType;
 
-	EventRelay()
-		: m_Callback(nullptr)
-		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) 
-	{ }
-	EventRelay(CallbackType callback) 
-		: m_Callback(callback)
-		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) 
-	{ }
+    EventRelay()
+        : m_Callback(nullptr)
+        , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
+    { }
+    EventRelay(CallbackType callback)
+        : m_Callback(callback)
+        , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
+    { }
 
 protected:
-	bool Receive(const std::shared_ptr<Event> event) override;
+    bool Receive(const std::shared_ptr<Event> event) override;
 
 private:
-	CallbackType m_Callback;
+    CallbackType m_Callback;
 };
 
 template <typename ContextType, typename EventType>
 bool EventRelay<ContextType, EventType>::Receive(const std::shared_ptr<Event> event)
 {
-	if (m_Callback != nullptr) {
-		return m_Callback(*static_cast<const EventType*>(event.get()));
-	} else {
-		return false;
-	}
+    if (m_Callback != nullptr) {
+        return m_Callback(*static_cast<const EventType*>(event.get()));
+    } else {
+        return false;
+    }
 }
 
 class EventBroker
 {
-template <typename ContextType, typename EventType> friend class EventRelay;
+    template <typename ContextType, typename EventType> friend class EventRelay;
 
 public:
-	EventBroker()
-	{
-		m_EventQueueRead = std::make_shared<EventQueue_t>();
-		m_EventQueueWrite = std::make_shared<EventQueue_t>();
-	}
+    EventBroker()
+    {
+        m_EventQueueRead = std::make_shared<EventQueue_t>();
+        m_EventQueueWrite = std::make_shared<EventQueue_t>();
+    }
 
-	void Subscribe(BaseEventRelay &relay);
-	template <typename EventType>
-	void Publish(const EventType &event);
-	/*
-		Process all events in a given context.
-		Returns: Number of events processed
-	*/
-	template <typename ContextType>
-	int Process();
-	int Process(std::string contextTypeName);
-	void Swap();
-	void Clear();
-	void Unsubscribe(BaseEventRelay &relay);
+    void Subscribe(BaseEventRelay &relay);
+    template <typename EventType>
+    void Publish(const EventType &event);
+    /*
+        Process all events in a given context.
+        Returns: Number of events processed
+    */
+    template <typename ContextType>
+    int Process();
+    int Process(std::string contextTypeName);
+    void Swap();
+    void Clear();
+    void Unsubscribe(BaseEventRelay &relay);
 
 private:
-	bool m_IsProcessing = false;
+    bool m_IsProcessing = false;
 
-	typedef std::string ContextTypeName_t; // typeid(ContextType).name()
-	typedef std::string EventTypeName_t; // typeid(EventType).name()
+    typedef std::string ContextTypeName_t; // typeid(ContextType).name()
+    typedef std::string EventTypeName_t; // typeid(EventType).name()
 
-	typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
-	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
-	ContextRelays_t m_ContextRelays;
-	std::vector<BaseEventRelay*> m_RelaysToSubscribe;
-	std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
+    typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
+    typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
+    ContextRelays_t m_ContextRelays;
+    std::vector<BaseEventRelay*> m_RelaysToSubscribe;
+    std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
 
-	typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
-	std::shared_ptr<EventQueue_t> m_EventQueueRead;
-	std::shared_ptr<EventQueue_t> m_EventQueueWrite;
+    typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
+    std::shared_ptr<EventQueue_t> m_EventQueueRead;
+    std::shared_ptr<EventQueue_t> m_EventQueueWrite;
 
-	void subscribeImmediate(BaseEventRelay& relay);
-	void unsubscribeImmediate(BaseEventRelay& relay);
+    void subscribeImmediate(BaseEventRelay& relay);
+    void unsubscribeImmediate(BaseEventRelay& relay);
 };
 
 template <typename EventType>
 void EventBroker::Publish(const EventType &event)
 {
-	/*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
-	for (auto it = itpair.first; it != itpair.second; ++it)
-	{
-		it->second->Receive(event);
-	}*/
+    /*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
+    for (auto it = itpair.first; it != itpair.second; ++it)
+    {
+        it->second->Receive(event);
+    }*/
 
-	m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
+    m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
 }
 
 template <typename ContextType>
 int EventBroker::Process()
 {
-	const std::string contextTypeName = typeid(ContextType).name();
-	return Process(contextTypeName);
+    const std::string contextTypeName = typeid(ContextType).name();
+    return Process(contextTypeName);
 }
 
 #endif

include/Engine/Core/InputController.h

@@ -11,26 +11,23 @@ template <typename EventContext>
 class InputController
 {
 public:
-	InputController(std::shared_ptr<dd::EventBroker> eventBroker)
-		: EventBroker(eventBroker)
+	InputController(EventBroker* eventBroker)
+		: m_EventBroker(eventBroker)
 	{ Initialize(); }
 
 	virtual void Initialize()
 	{
 		EVENT_SUBSCRIBE_MEMBER(
             _EInputCommand, &InputController::OnCommand);
-		EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &InputController::OnMouseMove);
 	}
 
-	virtual bool OnCommand(const Events::InputCommand &event) { return false; }
-	virtual bool OnMouseMove(const Events::MouseMove &event) { return false; }
+	virtual bool OnCommand(const Events::InputCommand& e) { return false; }
 
 protected:
-	std::shared_ptr<dd::EventBroker> EventBroker;
+	EventBroker* m_EventBroker;
 
 private:
 	EventRelay<EventContext, Events::InputCommand> m_EInputCommand;
-	EventRelay<EventContext, Events::MouseMove> m_EMouseMove;
 };
 
 #endif

include/Engine/Core/InputManager.h

@@ -8,9 +8,11 @@
 #include "EventBroker.h"
 #include "EKeyDown.h"
 #include "EKeyUp.h"
+#include "EKeyboardChar.h"
 #include "EMousePress.h"
 #include "EMouseRelease.h"
 #include "EMouseMove.h"
+#include "EMouseScroll.h"
 #include "ELockMouse.h"
 #include "EGamepadAxis.h"
 #include "EGamepadButton.h"
@@ -64,6 +66,11 @@ private:
 
 	void PublishGamepadAxisIfChanged(int gamepadID, Gamepad::Axis axis);
 	void PublishGamepadButtonIfChanged(int gamepadID, Gamepad::Button button);
+
+    static std::vector<unsigned int> GLFWCharCallbackQueue;
+    static void GLFWCharCallback(GLFWwindow* window, unsigned int c);
+    static std::vector<std::pair<double, double>> GLFWScrollCallbackQueue;
+    static void GLFWScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
 };
 
 #endif

include/Engine/Core/System.h

@@ -6,20 +6,40 @@
 #include "ComponentWrapper.h"
 
 class System
+{
+protected:
+    System(EventBroker* eventBroker)
+        : m_EventBroker(eventBroker)
+    { }
+
+    EventBroker* m_EventBroker;
+};
+
+class PureSystem : public System
 {
     friend class SystemPipeline;
 
-public:
-    System(const EventBroker* eventBroker, std::string componentType)
-        : m_EventBroker(eventBroker)
+protected:
+    PureSystem(EventBroker* eventBroker, std::string componentType)
+        : System(eventBroker)
         , m_ComponentType(componentType)
     { }
 
-    virtual void Update(World* world, ComponentWrapper& component, double dt) = 0;
+    const std::string m_ComponentType;
 
-private:
-    const EventBroker* m_EventBroker;
-    std::string m_ComponentType;
+    virtual void UpdateComponent(World* world, ComponentWrapper& component, double dt) = 0;
+};
+
+class ImpureSystem : public System
+{
+    friend class SystemPipeline;
+
+protected:
+    ImpureSystem(EventBroker* eventBroker)
+        : System(eventBroker)
+    { }
+
+    virtual void Update(World* world, double dt) = 0;
 };
 
 #endif

include/Engine/Core/SystemPipeline.h

@@ -9,12 +9,12 @@
 class SystemPipeline
 {
 public:
-    SystemPipeline(const EventBroker* eventBroker)
+    SystemPipeline(EventBroker* eventBroker)
         : m_EventBroker(eventBroker)
     { }
     ~SystemPipeline()
     {
-        for (auto& pair : m_Systems) {
+        for (auto& pair : m_PureSystems) {
             for (auto& system : pair.second) {
                 delete system;
             }
@@ -25,17 +25,32 @@ public:
     void AddSystem(Arguments... args)
     {
         System* system = new T(m_EventBroker, args...);
-        if (!system->m_ComponentType.empty()) {
-            m_Systems[system->m_ComponentType].push_back(system);
-        } else {
-            LOG_ERROR("Failed to add system \"%s\": Missing component type!", typeid(T).name());
-            delete system;
+        m_Systems[typeid(T).name()] = system;
+
+        if (std::is_base_of<PureSystem, T>::value) {
+            PureSystem* pureSystem = static_cast<PureSystem*>(system);
+            if (!pureSystem->m_ComponentType.empty()) {
+                m_PureSystems[pureSystem->m_ComponentType].push_back(pureSystem);
+            } else {
+                LOG_ERROR("Failed to add pure system \"%s\": Missing component type!", typeid(T).name());
+            }
+        }
+
+        if (std::is_base_of<ImpureSystem, T>::value) {
+            ImpureSystem* impureSystem = static_cast<ImpureSystem*>(system);
+            m_ImpureSystems.push_back(impureSystem);
         }
     }
 
     void Update(World* world, double dt)
     {
+        // Process events
         for (auto& pair : m_Systems) {
+            m_EventBroker->Process(pair.first);
+        }
+
+        // Update
+        for (auto& pair : m_PureSystems) {
             const std::string& componentName = pair.first;
             auto& systems = pair.second;
             const ComponentPool* pool = world->GetComponents(componentName);
@@ -44,15 +59,20 @@ public:
             }
             for (auto& component : *pool) {
                 for (auto& system : systems) {
-                    system->Update(world, component, dt);
+                    system->UpdateComponent(world, component, dt);
                 }
             }
         }
+        for (auto& system : m_ImpureSystems) {
+            system->Update(world, dt);
+        }
     }
 
 private:
-    const EventBroker* m_EventBroker;
-    std::unordered_map<std::string, std::vector<System*>> m_Systems;
+    EventBroker* m_EventBroker;
+    std::map<std::string, System*> m_Systems;
+    std::map<std::string, std::vector<PureSystem*>> m_PureSystems;
+    std::vector<ImpureSystem*> m_ImpureSystems;
 };
 
 #endif

include/Engine/Core/World.h

@@ -14,17 +14,27 @@ public:
 
     // Create empty entity
     EntityID CreateEntity(EntityID parent = 0);
+    // Delete entity and all components within
+    void DeleteEntity(EntityID entity);
 
     // Register a component type and allocate space for it
     void RegisterComponent(ComponentInfo& ci);
     // Attach a component to an entity and fill it with default values
     ComponentWrapper AttachComponent(EntityID entity, std::string componentType);
+    // Check if an entity has a component
+    bool HasComponent(EntityID entity, std::string componentType);
     // Get a component of an entity
     ComponentWrapper GetComponent(EntityID entity, std::string componentType);
+    // Delete a component off an entity
+    void DeleteComponent(EntityID entity, std::string componentType);
     // Get all components of the specified type
     const ComponentPool* GetComponents(std::string componentType);
     // Get entity parent
     EntityID GetParent(EntityID entity);
+    // Get all component pools
+    const std::unordered_map<std::string, ComponentPool*>& GetComponentPools() const { return m_ComponentPools; }
+    // Get the entity children map
+    const std::unordered_multimap<EntityID, EntityID>& GetEntityChildren() const { return m_EntityChildren; }
 
 private:
     EntityID m_CurrentEntityID = 1;

include/Engine/Editor/EditorSystem.h

@@ -0,0 +1,35 @@
+#include <imgui/imgui.h>
+#include <glm/gtx/common.hpp>
+#include "../Core/System.h"
+#include "../Core/EMousePress.h"
+#include "../Core/ConfigFile.h"
+#include "../Input/EInputCommand.h"
+#include "../Rendering/EPicking.h"
+#include "../Rendering/RenderQueueFactory.h"
+
+class EditorSystem : public ImpureSystem
+{
+public:
+    EditorSystem(EventBroker* eventBroker);
+
+    virtual void Update(World* world, double dt) override;
+
+private:
+    bool m_Enabled;
+    bool m_Visible;
+    std::vector<glm::vec2> m_PickingQueue;
+    EntityID m_Widget = 0;
+    EntityID m_Selection = 0;
+    EntityID m_LastSelection = 0;
+    glm::vec3 m_Position;
+
+    EventRelay<EditorSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
+    EventRelay<EditorSystem, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e);
+    EventRelay<EditorSystem, Events::Picking> m_EPicking;
+    bool OnPicking(const Events::Picking& e);
+
+    void drawUI(World* world, double dt);
+    bool createDeleteButton(std::string componentType);
+};

include/Engine/Input/EBindGamepadAxis.h

@@ -1,24 +0,0 @@
-#ifndef Events_BindGamepadAxis_h__
-#define Events_BindGamepadAxis_h__
-
-#include "Core/EventBroker.h"
-#include "Core/EGamepadAxis.h"
-
-namespace Events
-{
-
-/** Called to bind a gamepad axis to an input command. */
-struct BindGamepadAxis : Event
-{
-	/** The axis to bind. */
-	Gamepad::Axis Axis;
-	/** The command to send. */
-	std::string Command;
-	/** The value to send for positive stimulation.
-	
-		Multiplied by the 0-1 clamped value of the axis.
-	*/
-	float Value;
-};
-
-}

include/Engine/Input/EBindGamepadButton.h

@@ -1,26 +0,0 @@
-#ifndef Events_BindGamepadButton_h__
-#define Events_BindGamepadButton_h__
-
-#include "Core/EventBroker.h"
-#include "Core/EGamepadButton.h"
-
-namespace Events
-{
-
-/** Called to bind a gamepad button to an input command. */
-struct BindGamepadButton : Event
-{
-	/** The gamepad button to bind. */
-	Gamepad::Button Button;
-	/** The command to send. */
-	std::string Command;
-	/** The value to send for positive stimulation.
-
-		Multiplied by the 0-1 clamped value of the button.
-	*/
-	float Value;
-};
-
-}
-
-#endif

include/Engine/Input/EBindKey.h

@@ -1,25 +0,0 @@
-#ifndef Events_BindKey_h__
-#define Events_BindKey_h__
-
-#include "Core/EventBroker.h"
-
-namespace Events
-{
-
-/** Called to bind a keyboard key to an input command. */
-struct BindKey : Event
-{
-	/** The GLFW key code to bind. */
-	int KeyCode;
-	/** The command to send. */
-	std::string Command;
-	/** The value to send for positive stimulation.
-
-		Multiplied by the 0-1 clamped value of the key.
-	*/
-	float Value;
-};
-
-}
-
-#endif

include/Engine/Input/EBindMouseButton.h

@@ -1,25 +0,0 @@
-#ifndef Events_BindMouseButton_h__
-#define Events_BindMouseButton_h__
-
-#include "Core/EventBroker.h"
-
-namespace Events
-{
-
-/** Called to bind a mouse button to an input command. */
-struct BindMouseButton : Event
-{
-	/** The GLFW mouse button code to bind. */
-	int Button;
-	/** The command to send. */
-	std::string Command;
-	/** The value to send for positive stimulation.
-
-		Multiplied by the 0-1 clamped value of the button.
-	*/
-	float Value;
-};
-
-}
-
-#endif

include/Engine/Input/EBindOrigin.h

@@ -0,0 +1,22 @@
+#ifndef Events_BindOrigin_h__
+#define Events_BindOrigin_h__
+
+#include "Core/EventBroker.h"
+
+namespace Events
+{
+
+/** Called to bind an input origin to an input command. */
+struct BindOrigin : Event
+{
+	/** The input origin to bind. */
+	std::string Origin;
+	/** The command to send. */
+	std::string Command;
+	/** The value to send for positive stimulation. */
+	float Value = 1.f;
+};
+
+}
+
+#endif

include/Engine/Input/EInputCommand.h

@@ -13,7 +13,7 @@ struct InputCommand : Event
 	/** The command that was sent. */
 	std::string Command;
 	/** The value of the command. */
-	float Value;
+	float Value = 0;
 };
 
 }

include/Engine/Input/FirstPersonInputController.h

@@ -0,0 +1,70 @@
+#ifndef FirstPersonInputController_h__
+#define FirstPersonInputController_h__
+
+#include "../GLM.h"
+#include "../Core/InputController.h"
+#include "../Core/ELockMouse.h"
+
+template <typename EventContext>
+class FirstPersonInputController : public InputController<EventContext>
+{
+public:
+    FirstPersonInputController(EventBroker* eventBroker, unsigned int playerID)
+        : InputController(eventBroker)
+        , m_PlayerID(playerID)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_ELockMouse, &FirstPersonInputController::OnLockMouse);
+        EVENT_SUBSCRIBE_MEMBER(m_EUnlockMouse, &FirstPersonInputController::OnUnlockMouse);
+    }
+
+    const glm::quat Orientation() const { return m_Orientation; }
+    
+    void LockMouse()
+    {
+        Events::LockMouse e;
+        m_EventBroker->Publish(e);
+        m_MouseLocked = true;
+    }
+
+    void UnlockMouse()
+    {
+        Events::UnlockMouse e;
+        m_EventBroker->Publish(e);
+        m_MouseLocked = false;
+    }
+
+    virtual bool OnCommand(const Events::InputCommand& e) override
+    {
+        if (m_PlayerID != e.PlayerID) {
+            return false;
+        }
+
+        if (m_MouseLocked) {
+            if (e.Command == "Pitch") {
+                float val = glm::radians(e.Value);
+                m_Orientation = m_Orientation * glm::angleAxis<float>(-val, glm::vec3(1, 0, 0));
+                return true;
+            }
+
+            if (e.Command == "Yaw") {
+                float val = glm::radians(e.Value);
+                m_Orientation = glm::angleAxis<float>(-val, glm::vec3(0, 1, 0)) * m_Orientation;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+protected:
+    const unsigned int m_PlayerID;
+    glm::quat m_Orientation;
+    bool m_MouseLocked = false;
+    
+    EventRelay<EventContext, Events::LockMouse> m_ELockMouse;
+    bool OnLockMouse(const Events::LockMouse& e) { m_MouseLocked = true; return true; }
+    EventRelay<EventContext, Events::UnlockMouse> m_EUnlockMouse;
+    bool OnUnlockMouse(const Events::UnlockMouse& e) { m_MouseLocked = false; return true; }
+};
+
+#endif

include/Engine/Input/InputHandler.h

@@ -0,0 +1,25 @@
+#ifndef InputHandler_h__
+#define InputHandler_h__
+
+#include "../Common.h"
+#include "../Core/EventBroker.h"
+#include "InputProxy.h"
+
+class InputHandler
+{
+public:
+    InputHandler(EventBroker* eventBroker, InputProxy* inputProxy)
+        : m_EventBroker(eventBroker)
+        , m_InputProxy(inputProxy)
+    { }
+
+    virtual bool BindOrigin(std::string origin, std::string command, float value) = 0;
+    virtual void Update(double dt) { }
+    virtual float GetCommandValue(std::string command) = 0;
+
+protected:
+    EventBroker* m_EventBroker;
+    InputProxy* m_InputProxy;
+};
+
+#endif

include/Engine/Input/InputProxy.h

@@ -0,0 +1,46 @@
+#ifndef InputProxy_h__
+#define InputProxy_h__
+
+#include "../Common.h"
+#include "../Core/ResourceManager.h"
+#include "../Core/ConfigFile.h"
+#include "EInputCommand.h"
+#include "EBindOrigin.h"
+
+class InputHandler;
+
+class InputProxy
+{
+public:
+    InputProxy(EventBroker* eventBroker);
+    ~InputProxy();
+    
+    void LoadBindings(std::string file);
+	void Update(double dt);
+    void Process();
+    template <typename T>
+    void AddHandler();
+    void Publish(const Events::InputCommand& e);
+
+protected:
+    EventBroker* m_EventBroker;
+    std::vector<InputHandler*> m_Handlers;
+    std::map<std::string, std::set<InputHandler*>> m_CommandHandlers;
+    
+    // Represents every unique command (has of PlayerID & Command) and all values reported for that command this frame
+    std::map<std::pair<unsigned int, std::string>, std::vector<float>> m_CommandQueue;
+
+    std::map<std::string, float> m_CurrentCommandValues;
+    std::map<std::string, float> m_LastCommandValues;
+
+	EventRelay<InputProxy, Events::BindOrigin> m_EBindOrigin;
+	bool OnBindOrigin(const Events::BindOrigin& e);
+};
+
+template <typename T>
+void InputProxy::AddHandler()
+{
+    m_Handlers.push_back(new T(m_EventBroker, this));
+}
+
+#endif

include/Engine/Input/InputSystem.h

@@ -1,78 +0,0 @@
-#ifndef InputSystem_h__
-#define InputSystem_h__
-
-#include <array>
-#include <unordered_map>
-
-#include "Core/System.h"
-#include "Core/EKeyUp.h"
-#include "Core/EKeyDown.h"
-#include "Core/EMousePress.h"
-#include "Core/EMouseRelease.h"
-#include "Core/EGamepadAxis.h"
-#include "Core/EGamepadButton.h"
-#include "Core/Util/EnumClassHash.h"
-#include "EBindKey.h"
-#include "EBindMouseButton.h"
-#include "EBindGamepadAxis.h"
-#include "EBindGamepadButton.h"
-#include "EInputCommand.h"
-
-namespace Systems
-{
-
-class InputSystem : public System
-{
-public:
-	InputSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-		: System(world, eventBroker)
-	{ }
-
-	void RegisterComponents(ComponentFactory* cf) override;
-	void Initialize() override;
-
-	void Update(double dt) override;
-
-private:
-	std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandKeyboardValues; // command string -> keyboard key value for command
-	std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandMouseButtonValues; // command string -> mouse button value for command
-	std::unordered_map<std::string, std::unordered_map<Gamepad::Axis, float, EnumClassHash>> m_CommandGamepadAxisValues; // command string -> gamepad axis value for command
-	std::unordered_map<std::string, std::unordered_map<Gamepad::Button, float, EnumClassHash>> m_CommandGamepadButtonValues; // command string -> gamepad button value for command
-	// Input binding tables
-	std::unordered_multimap<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
-	std::unordered_multimap<int, std::tuple<std::string, float>> m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string
-	std::unordered_multimap<Gamepad::Axis, std::tuple<std::string, float>, EnumClassHash> m_GamepadAxisBindings; // Gamepad::Axis -> command string & value
-	std::unordered_multimap<Gamepad::Button, std::tuple<std::string, float>, EnumClassHash> m_GamepadButtonBindings; // Gamepad::Button -> command string
-
-	// Input events
-	EventRelay<InputSystem, Events::KeyDown> m_EKeyDown;
-	bool OnKeyDown(const Events::KeyDown &event);
-	EventRelay<InputSystem, Events::KeyUp> m_EKeyUp;
-	bool OnKeyUp(const Events::KeyUp &event);
-	EventRelay<InputSystem, Events::MousePress> m_EMousePress;
-	bool OnMousePress(const Events::MousePress &event);
-	EventRelay<InputSystem, Events::MouseRelease> m_EMouseRelease;
-	bool OnMouseRelease(const Events::MouseRelease &event);
-	EventRelay<InputSystem, Events::GamepadAxis> m_EGamepadAxis;
-	bool OnGamepadAxis(const Events::GamepadAxis &event);
-	EventRelay<InputSystem, Events::GamepadButtonDown> m_EGamepadButtonDown;
-	bool OnGamepadButtonDown(const Events::GamepadButtonDown &event);
-	EventRelay<InputSystem, Events::GamepadButtonUp> m_EGamepadButtonUp;
-	bool OnGamepadButtonUp(const Events::GamepadButtonUp &event);
-	// Input binding events
-	EventRelay<InputSystem, Events::BindKey> m_EBindKey;
-	bool OnBindKey(const Events::BindKey &event);
-	EventRelay<InputSystem, Events::BindMouseButton> m_EBindMouseButton;
-	bool OnBindMouseButton(const Events::BindMouseButton &event);
-	EventRelay<InputSystem, Events::BindGamepadAxis> m_EBindGamepadAxis;
-	bool OnBindGamepadAxis(const Events::BindGamepadAxis &event);
-	EventRelay<InputSystem, Events::BindGamepadButton> m_EBindGamepadButton;
-	bool OnBindGamepadButton(const Events::BindGamepadButton &event);
-
-	float GetCommandTotalValue(std::string command);
-	void PublishCommand(int playerID, std::string command, float value);
-};
-
-}
-
-#endif

include/Engine/Input/KeyboardInputHandler.h

@@ -0,0 +1,28 @@
+#ifndef KeyboardInputHandler_h__
+#define KeyboardInputHandler_h__
+
+#include <GLFW/glfw3.h>
+#include "InputHandler.h"
+#include "Core/EKeyDown.h"
+#include "Core/EKeyUp.h"
+
+class KeyboardInputHandler : public InputHandler
+{
+public:
+    KeyboardInputHandler(EventBroker* eventBroker, InputProxy* inputProxy);
+
+    bool BindOrigin(std::string origin, std::string command, float value) override;
+    virtual float GetCommandValue(std::string command) override;
+
+private:
+    std::unordered_map<std::string, int> m_OriginKeyCodes;
+	std::unordered_map<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
+    std::unordered_map<std::string, float> m_CommandValues;
+
+	EventRelay<InputHandler, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown& e);
+	EventRelay<InputHandler, Events::KeyUp> m_EKeyUp;
+	bool OnKeyUp(const Events::KeyUp& e);
+};
+
+#endif

include/Engine/Input/MouseInputHandler.h

@@ -0,0 +1,38 @@
+#ifndef MouseInputHandler_h__
+#define MouseInputHandler_h__
+
+#include <GLFW/glfw3.h>
+#include "InputHandler.h"
+#include "Core/EMousePress.h"
+#include "Core/EMouseRelease.h"
+#include "Core/EMouseMove.h"
+
+class MouseInputHandler : public InputHandler
+{
+public:
+    MouseInputHandler(EventBroker* eventBroker, InputProxy* inputProxy);
+
+    bool BindOrigin(std::string origin, std::string command, float value) override;
+    virtual float GetCommandValue(std::string command) override;
+
+private:
+    std::unordered_map<std::string, int> m_OriginCodes;
+    std::unordered_map<std::string, char> m_OriginAxes;
+	std::unordered_map<int, std::tuple<std::string, float>> m_Bindings; // GLFW_MOUSE_BUTTON... -> command string & value
+	std::unordered_map<char, std::tuple<std::string, float>> m_Axes; // Axis -> command string & value
+    std::unordered_map<std::string, float> m_CommandValues;
+    std::unordered_map<std::string, float> m_ContinuousCommandValues;
+
+	EventRelay<InputHandler, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e);
+	EventRelay<InputHandler, Events::MouseRelease> m_EMouseRelease;
+	bool OnMouseRelease(const Events::MouseRelease& e);
+	EventRelay<InputHandler, Events::MouseMove> m_EMouseMove;
+	bool OnMouseMove(const Events::MouseMove& e);
+
+    bool hasOrigin(std::string origin);
+
+
+};
+
+#endif

include/Engine/Rendering/DebugCameraInputController.h

@@ -0,0 +1,63 @@
+#include <imgui/imgui.h>
+#include "../Input/FirstPersonInputController.h"
+
+template <typename EventContext>
+class DebugCameraInputController : public FirstPersonInputController<EventContext>
+{
+public:
+    DebugCameraInputController(EventBroker* eventBroker, unsigned int playerID)
+        : FirstPersonInputController(eventBroker, playerID)
+    { }
+
+    const glm::vec3 Position() const { return m_Position; }
+    void SetBaseSpeed(float speed) { m_BaseSpeed = speed; }
+
+    virtual bool OnCommand(const Events::InputCommand& e) override
+    {
+        ImGuiIO& io = ImGui::GetIO();
+
+        if (e.Command == "PrimaryFire") {
+            if (e.Value > 0) {
+                if (!io.WantCaptureMouse) {
+                    LockMouse();
+                }
+            } else {
+                UnlockMouse();
+            }
+            return false;
+        }
+
+        if (!io.WantCaptureKeyboard) {
+            if (e.Command == "Right") {
+                float value = std::max(-1.f, std::min(e.Value, 1.f));
+                m_Velocity.x = value;
+            }
+            if (e.Command == "Forward") {
+                float value = std::max(-1.f, std::min(e.Value, 1.f));
+                m_Velocity.z = -value;
+            }
+            if (e.Command == "Sprint") {
+                if (e.Value > 0.f) {
+                    m_Speed = m_BaseSpeed * 2.f * (e.Value);
+                } else {
+                    m_Speed = m_BaseSpeed;
+                }
+            }
+        }
+
+        return FirstPersonInputController::OnCommand(e);
+    }
+
+    void Update(double dt)
+    {
+        if (glm::length2(m_Velocity) > 0) {
+            m_Position += m_Orientation * (glm::normalize(m_Velocity) * m_Speed * (float)dt);
+        }
+    }
+
+protected:
+    glm::vec3 m_Position = glm::vec3(0, 0, 0);
+    glm::vec3 m_Velocity = glm::vec3(0, 0, 0);
+    float m_BaseSpeed = 2.0f;
+    float m_Speed = m_BaseSpeed;
+};

include/Engine/Rendering/DrawScenePass.h

@@ -0,0 +1,36 @@
+#ifndef DrawScenePass_h__
+#define DrawScenePass_h__
+
+#include "IRenderer.h"
+#include "DrawScenePassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawScenePass
+{
+public:
+    DrawScenePass(IRenderer* renderer);
+    ~DrawScenePass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(RenderQueueCollection& rq);
+
+    //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;
+
+    ShaderProgram* m_BasicForwardProgram;
+
+};
+
+#endif 

include/Engine/Rendering/DrawScenePassState.h

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

include/Engine/Rendering/EPicking.h

@@ -0,0 +1,71 @@
+#ifndef Events_Picking_h__
+#define Events_Picking_h__
+
+#include "../OpenGL.h"
+#include "../GLM.h"
+
+#include "../Core/EventBroker.h"
+#include "Util/ScreenCoords.h"
+#include "FrameBuffer.h"
+#include "../Core/Entity.h"
+#include "Util/UnorderedMapVec2.h"
+
+namespace Events
+{
+
+/** Thrown Every frame, use functions to pick*/
+struct Picking : Event
+{
+public:
+    Picking(FrameBuffer* pickingBuffer, GLuint* depthBuffer, glm::mat4 projectionMatrix, glm::mat4 viewMatrix, Rectangle resolution, const std::unordered_map<glm::vec2, EntityID>* pickingColorsToEntity)
+        : PickingBuffer(pickingBuffer)
+        , DepthBuffer(depthBuffer)
+        , ProjectionMatrix(projectionMatrix)
+        , ViewMatrix(viewMatrix)
+        , Resolution(resolution)
+        , PickingColorsToEntity(pickingColorsToEntity)
+    { }
+        
+    
+
+    struct PickData
+    {
+        //Picked Entity
+        EntityID Entity;
+        //World position of the "pick"
+        glm::vec3 Position;
+    };
+
+    PickData Pick(glm::vec2 screenCoord) const
+    {
+        PickData pickData;
+
+        // Invert screen y coordinate
+        screenCoord.y = Resolution.Height - screenCoord.y;
+        ScreenCoords::PixelData data = ScreenCoords::ToPixelData(screenCoord, PickingBuffer, *DepthBuffer);
+
+        auto it = PickingColorsToEntity->find(glm::vec2(data.Color[0], data.Color[1]));
+        if (it != PickingColorsToEntity->end()) {
+            pickData.Entity = it->second;
+        } else {
+            pickData.Entity = 0;
+        }
+        pickData.Position = ScreenCoords::ToWorldPos(screenCoord.x, screenCoord.y, data.Depth, Resolution, ProjectionMatrix, ViewMatrix);
+
+        return pickData;
+    }
+
+
+private:
+    FrameBuffer* PickingBuffer;
+    GLuint* DepthBuffer;
+    const glm::mat4 ProjectionMatrix;
+    const glm::mat4 ViewMatrix;
+    const Rectangle Resolution;
+    const std::unordered_map<glm::vec2, EntityID>* PickingColorsToEntity;
+    
+};
+
+}
+
+#endif

include/Engine/Rendering/ImGuiRenderPass.h

@@ -0,0 +1,77 @@
+#include <imgui/imgui.h>
+#include "../OpenGL.h"
+#include "IRenderer.h"
+#include "RenderState.h"
+#include "../Core/EventBroker.h"
+#include "../Core/EMousePress.h"
+#include "../Core/EMouseRelease.h"
+#include "../Core/EMouseMove.h"
+#include "../Core/EMouseScroll.h"
+#include "../Core/EKeyDown.h"
+#include "../Core/EKeyUp.h"
+#include "../Core/EKeyboardChar.h"
+
+class ImGuiRenderState : public RenderState
+{
+public:
+    ImGuiRenderState()
+        : RenderState()
+    {
+        BindFramebuffer(0);
+        Enable(GL_BLEND);
+        BlendEquation(GL_FUNC_ADD);
+        BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        Disable(GL_CULL_FACE);
+        Disable(GL_DEPTH_TEST);
+        Enable(GL_SCISSOR_TEST);
+    }
+};
+
+class ImGuiRenderPass
+{
+public:
+    ImGuiRenderPass(IRenderer* renderer, EventBroker* eventBroker);
+
+    void Update(double dt);
+    void Draw();
+
+private:
+    IRenderer* m_Renderer;
+    EventBroker* m_EventBroker;
+
+    GLFWwindow* g_Window;
+    double g_DeltaTime = 0.0;
+    float g_MouseWheel = 0.f;
+    GLuint g_FontTexture;
+    int g_ShaderHandle;
+    int g_VertHandle;
+    int g_FragHandle;
+    int g_AttribLocationTex;
+    int g_AttribLocationProjMtx;
+    int g_AttribLocationPosition;
+    int g_AttribLocationUV;
+    int g_AttribLocationColor;
+    GLuint g_VboHandle;
+    GLuint g_VaoHandle;
+    GLuint g_ElementsHandle;
+
+    EventRelay<ImGuiRenderPass, Events::MousePress> m_EMousePress;
+    bool OnMousePress(const Events::MousePress& e);
+    EventRelay<ImGuiRenderPass, Events::MouseRelease> m_EMouseRelease;
+    bool OnMouseRelease(const Events::MouseRelease& e);
+    EventRelay<ImGuiRenderPass, Events::MouseMove> m_EMouseMove;
+    bool OnMouseMove(const Events::MouseMove& e);
+    EventRelay<ImGuiRenderPass, Events::MouseScroll> m_EMouseScroll;
+    bool OnMouseScroll(const Events::MouseScroll& e);
+    EventRelay<ImGuiRenderPass, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown& e);
+    EventRelay<ImGuiRenderPass, Events::KeyUp> m_EKeyUp;
+    bool OnKeyUp(const Events::KeyUp& e);
+    EventRelay<ImGuiRenderPass, Events::KeyboardChar> m_EKeyboardChar;
+    bool OnKeyboardChar(const Events::KeyboardChar& e);
+
+    bool createDeviceObjects();
+    bool createFontsTexture();
+
+    void newFrame();
+};

include/Engine/Rendering/PickingPass.h

@@ -0,0 +1,49 @@
+#ifndef PickingPass_h__
+#define PickingPass_h__
+
+#include "IRenderer.h"
+#include "PickingPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapVec2.h"
+#include "../Core/EventBroker.h"
+#include "EPicking.h"
+
+class PickingPass
+{
+public:
+    PickingPass(IRenderer* renderer, EventBroker* eb);
+    ~PickingPass();
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(RenderQueueCollection& rq);
+
+
+    //Getters
+    const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
+    const std::unordered_map<glm::vec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }
+    GLuint PickingTexture() const { return m_PickingTexture; }
+    GLuint DepthBuffer() const { return m_DepthBuffer; }
+    const FrameBuffer& PickingBuffer() const { return m_PickingBuffer; }
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    EventBroker* m_EventBroker;
+
+    const IRenderer* m_Renderer;
+
+    ShaderProgram* m_PickingProgram;
+
+    std::unordered_map<glm::vec2, EntityID> m_PickingColorsToEntity;
+
+    GLuint m_PickingTexture;
+    GLuint m_DepthBuffer;
+
+    FrameBuffer m_PickingBuffer;
+};
+
+#endif 

include/Engine/Rendering/PickingPassState.h

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

include/Engine/Rendering/RenderQueueFactory.h

@@ -13,8 +13,12 @@ public:
     RenderQueueFactory();
     void Update(World* world);
 
-    
     RenderQueueCollection RenderQueues() const { return m_RenderQueues; }
+
+    static glm::vec3 AbsolutePosition(World* world, EntityID entity);
+    static glm::quat AbsoluteOrientation(World* world, EntityID entity);
+    static glm::vec3 AbsoluteScale(World* world, EntityID entity);
+
 private:
     RenderQueueCollection m_RenderQueues;
 
@@ -22,10 +26,6 @@ private:
     void FillLights(World* world, RenderQueue* renderQueue);
 
     glm::mat4 ModelMatrix(World* world, EntityID entity);
-
-    glm::vec3 AbsolutePosition(World* world, EntityID entity);
-    glm::quat AbsoluteOrientation(World* world, EntityID entity);
-    glm::vec3 AbsoluteScale(World* world, EntityID entity);
 };
 
 #endif

include/Engine/Rendering/RenderState.h

@@ -0,0 +1,27 @@
+#ifndef RenderState_h__
+#define RenderState_h__
+
+#include <functional>
+#include "../Common.h"
+#include "../OpenGL.h"
+#include "../GLM.h"
+
+class RenderState 
+{
+public:
+    RenderState() = default;
+    ~RenderState();
+
+    bool Enable(GLenum cap);
+    bool Disable(GLenum cap);
+    bool CullFace(GLenum mode);
+    bool ClearColor(glm::vec4 color);
+    bool Clear(GLbitfield mask);
+    bool BindFramebuffer(GLint framebuffer);
+    bool BlendEquation(GLenum mode);
+    bool BlendFunc(GLenum sfactor, GLenum dfactor);
+
+private:
+    std::vector<std::function<void(void)>> m_ResetFunctions;
+};
+#endif

include/Engine/Rendering/Renderer.h

@@ -10,48 +10,115 @@
 #include "Util/UnorderedMapVec2.h"
 #include "FrameBuffer.h"
 #include "../Core/World.h"
+#include "PickingPass.h"
+#include "DrawScenePass.h"
+
+
+#define TILE_SIZE 16 
+#define NUM_LIGHTS 3
+
+
+enum lightType 
+{
+    Point,
+    Spot,
+    Directional,
+    Area
+};
+
+#include "../Core/EventBroker.h"
+#include "EPicking.h"
+#include "ImGuiRenderPass.h"
 
 class Renderer : public IRenderer
 {
 public:
-	virtual void Initialize() override;
-	virtual void Update(double dt) override;
-	virtual void Draw(RenderQueueCollection& rq) override;
+    Renderer(EventBroker* eventBroker) 
+        : m_EventBroker(eventBroker)
+    { }
+
+    virtual void Initialize() override;
+    virtual void Update(double dt) override;
+    virtual void Draw(RenderQueueCollection& rq) override;
 
 private:
-	//----------------------Variables----------------------//
-	Texture* m_ErrorTexture;
-	Texture* m_WhiteTexture;
-	float m_CameraMoveSpeed;
-    FrameBuffer m_PickingBuffer;
-    GLuint m_PickingTexture;
-    GLuint m_DepthBuffer;
+    //----------------------Variables----------------------//
+    EventBroker* m_EventBroker;
+
+    Texture* m_ErrorTexture;
+    Texture* m_WhiteTexture;
+    float m_CameraMoveSpeed;
 
     Model* m_ScreenQuad;
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
+    DrawScenePass* m_DrawScenePass;
+    PickingPass* m_PickingPass;
+    ImGuiRenderPass* m_ImGuiRenderPass;
 
-    
-    std::unordered_map<glm::vec2, EntityID> m_PickingColorsToEntity;
-
-	//----------------------Functions----------------------//
-	void InitializeWindow();
-	void InitializeShaders();
+    //----------------------Functions----------------------//
+    void InitializeWindow();
+    void InitializeShaders();
     void InitializeTextures();
-    void InitializeFrameBuffers();
+    void InitializeSSBOs();
+    void InitializeRenderPasses();
     //TODO: Renderer: Get InputUpdate out of renderer
-	void InputUpdate(double dt);
-    void PickingPass(RenderQueueCollection& rq);
+    void InputUpdate(double dt);
+    //void PickingPass(RenderQueueCollection& rq);
     void DrawScreenQuad(GLuint textureToDraw);
-    void DrawScene(RenderQueueCollection& rq);
 
+    //----------------------Forward+-----------------------//
+    void CalculateFrustum();
+    void CullLights();
+    //Frustum
+    struct Plane {
+        glm::vec3 Normal;
+        float d;
+    };
+    struct Frustum {
+        Plane Planes[4];
+    };
+    Frustum m_Frustums[80*45]; //TODO: Renderer: Make this change with resolution
+
+    //Lights
+    void TEMPCreateLights();
+    //TODO: Renderer: Add Directionllights, spotlights and area lights to this as type.
+    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;
+    };
+    PointLight m_PointLights[NUM_LIGHTS];
+
+    struct LightGrid {
+        int Amount;
+        int Start;
+        glm::vec2 Padding;
+    };
+    LightGrid m_LightGrid[80*45];
+
+    int m_LightOffset = 0;
+
+    int m_LightIndex[80*45*200];
+
+    //-------------------------SSBO------------------------//
+    GLuint m_FrustumSSBO = 0;
+    GLuint m_LightSSBO = 1;
+    GLuint m_LightGridSSBO = 2;
+    GLuint m_LightOffsetSSBO = 3;
+    GLuint m_LightIndexSSBO = 4;
 
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
-	ShaderProgram m_BasicForwardProgram;
-    ShaderProgram m_PickingProgram;
-    ShaderProgram m_DrawScreenQuadProgram;
+	ShaderProgram* m_BasicForwardProgram;
+    ShaderProgram* m_DrawScreenQuadProgram;
+    ShaderProgram* m_CalculateFrustumProgram;
+    ShaderProgram* m_LightCullProgram;
+
 };
 
 #endif

include/Engine/Rendering/ShaderProgram.h

@@ -1,6 +1,9 @@
+#ifndef ShaderProgram_h__
+#define ShaderProgram_h__
 
 #include "../Common.h"
 #include "../OpenGL.h"
+#include "../Core/ResourceManager.h"
 #include <fstream>
 
 class Shader
@@ -60,11 +63,13 @@ public:
 		: ShaderType(fileName) { }
 };
 
-class ShaderProgram
+class ShaderProgram : public Resource
 {
-public:
-	ShaderProgram()
+    friend class ResourceManager;
+private:
+	ShaderProgram(std::string)
 		: m_ShaderProgramHandle(0) { }
+public:
 	~ShaderProgram();
 
 	void AddShader(std::shared_ptr<Shader> shader);
@@ -79,3 +84,5 @@ private:
 	GLuint m_ShaderProgramHandle;
 	std::vector<std::shared_ptr<Shader>> m_Shaders;
 };
+
+#endif

include/Engine/Rendering/Util/GLError.h

@@ -9,7 +9,7 @@ inline bool _GLERROR(const char* info, const char* file, const char* func, unsig
 	GLenum error = glGetError();
 	if (error != GL_NO_ERROR)
 	{
-		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s %i %s", info, error, gluErrorString(error));
+		_LOG(LOG_LEVEL_ERROR, file, func, line, "GL Error: %s, %i, %s", info, error, gluErrorString(error));
 		return true;
 	}
 

include/Engine/Rendering/Util/ScreenCoords.h

@@ -11,6 +11,13 @@ class ScreenCoords
 {
 public: 
     ScreenCoords() = delete;
+
+    struct PixelData
+    {
+        int Color[2];
+        float Depth;
+    };
+
     //Return world position from given screenspace coordinates and depth value in viewspace.
     static glm::vec3 ToWorldPos(glm::vec2 screenCoord, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
     static glm::vec3 ToWorldPos(float x, float y, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
@@ -18,8 +25,8 @@ public:
     static glm::vec3 ToWorldPos(float x, float y, float depth, float screenWidth, float screenHeight, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
     //Return data from the given buffers at the coordinates given in screenspace. Buffer should probably have a texture that covers the screen.
     //Data is given as R = x, B = y, and 
-    static glm::vec3 ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
-    static glm::vec3 ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
+    static PixelData ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
+    static PixelData ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
     //Return EntityID of the clicked coordinate in given screenspace coordinates.
     //EntityID ScreenCoordsToEntityID(glm::vec2 screenCoord, float depth);