Merge branch 'Rendering' into TextRendering

# Conflicts:
#	include/Engine/Rendering/RenderQueue.h
#	include/Engine/Rendering/RenderQueueFactory.h
#	include/Engine/Rendering/Renderer.h
#	include/Engine/Rendering/ShaderProgram.h
#	include/Game/Game.h
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/Test.xml
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Rendering/RenderQueueFactory.cpp
#	src/Engine/Rendering/Renderer.cpp
#	src/Game/Game.cpp

include/Engine/Rendering/Camera.h

@@ -26,13 +26,12 @@ public:
 	glm::quat Orientation() const { return m_Orientation; }
 	void SetOrientation(glm::quat val);
 
-	/*float Pitch() const { return m_Pitch; }
-	void Pitch(float val);
-	float Yaw() const { return m_Yaw; }
-	void Yaw(float val);*/
-
 	glm::mat4 ProjectionMatrix() const { return m_ProjectionMatrix; }
+    void SetProjectionMatrix(glm::mat4 val);
+
 	glm::mat4 ViewMatrix() const { return m_ViewMatrix; }
+    void SetViewMatrix(glm::mat4 val);
+
 
 	float AspectRatio() const { return m_AspectRatio; }
 	void SetAspectRatio(float val);
@@ -46,11 +45,10 @@ public:
 	float FarClip() const { return m_FarClip; }
 	void SetFarClip(float val);
 
-	
+    void UpdateViewMatrix();
+    void UpdateProjectionMatrix();
 
 private:
-	void UpdateViewMatrix();
-	void UpdateProjectionMatrix();
 
 	glm::vec3 m_Position;
 	glm::quat m_Orientation;

include/Engine/Rendering/DebugCameraInputController.h

@@ -0,0 +1,66 @@
+#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)
+    { }
+
+    void SetPosition(const glm::vec3 position) { m_Position = position; }
+    void SetOrientation(const glm::quat orientation) { m_Orientation = orientation; }
+
+    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,42 @@
+#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(RenderScene& scene);
+
+    //Getters
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j)
+    {
+        return (i->Depth < j->Depth);
+    };
+
+    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/DummyRenderer.h

@@ -9,7 +9,7 @@ class DummyRenderer : public IRenderer
 {
 public:
 	virtual void Initialize() override;
-	virtual void Draw(RenderQueueCollection& rq) override;
+	virtual void Draw(RenderFrame& rq) override;
 };
 
 #endif

include/Engine/Rendering/EPicking.h

@@ -1,69 +0,0 @@
-#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;
-
-        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 = -1;
-        }
-        pickData.Position = ScreenCoords::ToWorldPos(screenCoord.x, Resolution.Width - 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/ESetCamera.h

@@ -0,0 +1,23 @@
+#ifndef Events_SetCamera_h__
+#define Events_SetCamera_h__
+
+#include "../Core/EventBroker.h"
+#include "../Core/Entity.h"
+#include <string.h>
+
+namespace Events
+{
+
+struct SetCamera : Event
+{
+public:
+    SetCamera() { };
+    std::string Name;
+
+private:
+
+};
+
+}
+
+#endif

include/Engine/Rendering/IRenderer.h

@@ -10,6 +10,15 @@
 #include "RenderQueue.h"
 #include "Model.h"
 
+struct PickData
+{
+    EntityID Entity;
+    glm::vec3 Position; //World position
+    float Depth;
+    ::Camera* Camera;
+    const ::World* World;
+};
+
 class IRenderer
 {
 public:
@@ -20,29 +29,29 @@ public:
 	void SetFullscreen(bool fullscreen) { m_Fullscreen = fullscreen; }
 	bool VSYNC() const { return m_VSYNC; }
 	void SetVSYNC(bool vsync) { m_VSYNC = vsync; }
-	::Camera* Camera() const { return m_Camera; }
-	void SetCamera(::Camera* camera)
-	{
-		if (camera == nullptr) {
-			m_Camera = m_DefaultCamera;
-		} else {
-			m_Camera = camera;
-		}
-	}
-
+    ::Camera* Camera() const { return m_Camera; }
+    void SetCamera(::Camera* camera)
+    {
+        if (camera == nullptr) {
+            m_Camera = m_DefaultCamera;
+        } else {
+            m_Camera = camera;
+        }
+    }
 	virtual void Initialize() = 0;
 	virtual void Update(double dt) = 0;
-	virtual void Draw(RenderQueueCollection& rq) = 0;
+	virtual void Draw(RenderFrame& rq) = 0;
+    virtual PickData Pick(glm::vec2 screenCord) = 0;
 
 protected:
-	Rectangle m_Resolution = Rectangle(1280, 720);
+	Rectangle m_Resolution = Rectangle::Rectangle(1280, 720);
 	bool m_Fullscreen = false;
 	bool m_VSYNC = false;
 	int m_GLVersion[2];
 	std::string m_GLVendor;
-	::Camera* m_DefaultCamera;
-	::Camera* m_Camera = nullptr;
 	GLFWwindow* m_Window = nullptr;
+    ::Camera* m_DefaultCamera;
+    ::Camera* m_Camera = nullptr;
 };
 
 #endif // Renderer_h__

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/ModelJob.h

@@ -0,0 +1,55 @@
+#ifndef ModelJob_h__
+#define ModelJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "Texture.h"
+#include "Model.h"
+#include "RenderJob.h"
+#include "../Core/ResourceManager.h"
+#include "Camera.h"
+#include "../Core/World.h"
+
+struct ModelJob : RenderJob
+{
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::Model::MaterialGroup texGroup, 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;
+        Matrix = matrix;
+        Color = modelComponent["Color"];
+        Entity = modelComponent.EntityID;
+        World = world;
+    };
+
+    unsigned int TextureID;
+    unsigned int ShaderID;
+
+    EntityID Entity;
+    glm::mat4 Matrix;
+    const Texture* DiffuseTexture;
+    const Texture* NormalTexture;
+    const Texture* SpecularTexture;
+    float Shininess = 0.f;
+    glm::vec4 Color;
+    const ::Model* Model = nullptr;
+    unsigned int StartIndex = 0;
+    unsigned int EndIndex = 0;
+    const World* World;
+
+    void CalculateHash() override
+    {
+        Hash = TextureID;
+    }
+};
+
+#endif

include/Engine/Rendering/PickingPass.h

@@ -0,0 +1,63 @@
+#ifndef PickingPass_h__
+#define PickingPass_h__
+
+#include "IRenderer.h"
+#include "PickingPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapiVec2.h"
+#include "../Core/EventBroker.h"
+#include "../Core/World.h"
+
+class PickingPass
+{
+public:
+    PickingPass(IRenderer* renderer, EventBroker* eb);
+    ~PickingPass();
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    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; }
+    GLuint PickingTexture() const { return m_PickingTexture; }
+    GLuint DepthBuffer() const { return m_DepthBuffer; }
+    const FrameBuffer& PickingBuffer() const { return m_PickingBuffer; }
+
+    
+    PickData Pick(glm::vec2 screenCoord);
+
+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;
+    Camera* m_Camera;
+
+    struct PickingInfo
+    {
+        EntityID Entity;
+        const ::World* World;
+        ::Camera* Camera;
+    };
+
+    std::unordered_map<glm::ivec2, PickingInfo> m_PickingColorsToEntity;
+
+    GLuint m_PickingTexture;
+    GLuint m_DepthBuffer;
+
+    FrameBuffer m_PickingBuffer;
+
+    int m_ColorCounter[2];
+    std::map<std::tuple<EntityID, const World*, Camera*>, glm::ivec2> m_EntityColors;
+};
+
+#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/RawModel.h

@@ -46,6 +46,7 @@ public:
 	struct MaterialGroup
 	{
 		float Shininess;
+        float Transparency;
 		std::shared_ptr<::Texture> Texture;
 		std::shared_ptr<::Texture> NormalMap;
 		std::shared_ptr<::Texture> SpecularMap;

include/Engine/Rendering/RenderJob.h

@@ -0,0 +1,32 @@
+#ifndef RenderJob_h__
+#define RenderJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "RenderQueue.h"
+
+
+struct RenderJob
+{
+    friend class RenderQueue;
+
+public:
+
+    float Depth;
+
+protected:
+    uint64_t Hash;
+
+    virtual void CalculateHash() = 0;
+
+    bool operator<(const RenderJob& rhs)
+    {
+        return this->Hash < rhs.Hash;
+    }
+
+};
+
+#endif

include/Engine/Rendering/RenderQueue.h

@@ -8,164 +8,57 @@
 #include "../GLM.h"
 #include "../Core/Util/Rectangle.h"
 #include "../Core/Entity.h"
-#include "Font.h"
+#include "Camera.h"
+#include "RenderJob.h"
+#include "ModelJob.h"
+#include "TextJob.h"
 
-class Model;
-class Skeleton;
-class Texture;
-class RenderQueue;
-
-//TODO: Render: Remove obsolete RenderJobs and fix standard values on variables.
-
-struct RenderJob
+struct RenderScene
 {
-	friend class RenderQueue;
+    ::Camera* Camera;
+    std::list<std::shared_ptr<RenderJob>> ForwardJobs;
+    std::list<std::shared_ptr<RenderJob>> LightJobs;
+    std::list<std::shared_ptr<RenderJob>> TextJobs;
+    Rectangle Viewport;
 
-	float Depth;
-
-protected:
-	uint64_t Hash;
-
-	virtual void CalculateHash() = 0;
-
-	bool operator<(const RenderJob& rhs)
+	void Clear()
 	{
-		return this->Hash < rhs.Hash;
+        ForwardJobs.clear();
+        LightJobs.clear();
+        TextJobs.clear();
 	}
 };
 
-struct ModelJob : RenderJob
-{
-	unsigned int ShaderID = 0;
-	unsigned int TextureID = 0;
-
-    //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
-    EntityID Entity;
-
-	glm::mat4 ModelMatrix;
-	const Texture* DiffuseTexture;
-	const Texture* NormalTexture;
-	const Texture* SpecularTexture;
-	float Shininess = 0.f;
-	glm::vec4 Color;
-	const Model* Model = nullptr;
-	unsigned int StartIndex = 0;
-	unsigned int EndIndex = 0;
-
-	// Animation
-	Skeleton* Skeleton = nullptr;
-	bool NoRootMotion = true;
-	std::string AnimationName;
-	double AnimationTime = 0;
-
-	void CalculateHash() override
-	{
-		Hash = TextureID;
-	}
-};
-
-struct SpriteJob : RenderJob
-{
-	unsigned int ShaderID = 0;
-	unsigned int TextureID = 0;
-
-	glm::mat4 ModelMatrix;
-	const Texture* DiffuseTexture = nullptr;
-	const Texture* NormalTexture = nullptr;
-	const Texture* SpecularTexture = nullptr;
-	glm::vec4 Color;
-
-	void CalculateHash() override
-	{
-		Hash = TextureID;
-	}
-};
-
-struct TextJob : RenderJob
-{
-    glm::mat4 ModelMatrix;
-    glm::vec4 Color;
-    std::string Content;
-    Font* Resource;
-
-    void CalculateHash() override
-    {
-        Hash = 0;
-    }
-};
-
-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;
-
-	void CalculateHash() override
-	{
-		Hash = 0;
-	}
-};
-
-class RenderQueue
+struct RenderFrame
 {
 public:
-	template <typename T>
-	void Add(T &job)
-	{
-		job.CalculateHash();
-		Jobs.push_back(std::shared_ptr<T>(new T(job)));
-		m_Size++;
-	}
 
-	void Sort()
-	{
-		Jobs.sort();
-	}
+    void Add(RenderScene &scene)
+    {
+        RenderScenes.push_back(std::shared_ptr<RenderScene>(new RenderScene(scene)));
+        m_Size++;
+    }
 
-	void Clear()
-	{
-		Jobs.clear();
-		m_Size = 0;
-	}
+    void Clear()
+    {
+        RenderScenes.clear();
+        m_Size = 0;
+    }
 
-	int Size() const { return m_Size; }
-	std::list<std::shared_ptr<RenderJob>>::const_iterator begin()
-	{
-		return Jobs.begin();
-	}
+    int Size() const { return m_Size; }
+    std::list<std::shared_ptr<RenderScene>>::const_iterator begin()
+    {
+        return RenderScenes.begin();
+    }
 
-	std::list<std::shared_ptr<RenderJob>>::const_iterator end()
-	{
-		return Jobs.end();
-	}
-
-	std::list<std::shared_ptr<RenderJob>> Jobs;
+    std::list<std::shared_ptr<RenderScene>>::const_iterator end()
+    {
+        return RenderScenes.end();
+    }
 
+    std::list<std::shared_ptr<RenderScene>> RenderScenes;
+    
 private:
-	int m_Size = 0;
+    int m_Size = 0;
 };
-
-struct RenderQueueCollection
-{
-	RenderQueue Forward;
-	RenderQueue Lights;
-    RenderQueue Text;
-
-	void Clear()
-	{
-		Forward.Clear();
-		Lights.Clear();
-        Text.Clear();
-	}
-
-	void Sort()
-	{
-		Forward.Sort();
-		Lights.Sort();
-        Text.Sort();
-	}
-};
-
 #endif

include/Engine/Rendering/RenderQueueFactory.h

@@ -1,32 +0,0 @@
-#ifndef RenderQueueFactory_h__
-#define RenderQueueFactory_h__
-
-#include "../Core/World.h"
-#include "RenderQueue.h"
-#include "../Core/ResourceManager.h"
-#include "Model.h"
-#include "../GLM.h"
-
-class RenderQueueFactory
-{
-public:
-    RenderQueueFactory();
-    void Update(World* world);
-
-    
-    RenderQueueCollection RenderQueues() const { return m_RenderQueues; }
-private:
-    RenderQueueCollection m_RenderQueues;
-
-    void FillModels(World* world, RenderQueue* renderQueue);
-    void FillLights(World* world, RenderQueue* renderQueue);
-    void FillText(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/RenderSystem.h

@@ -0,0 +1,54 @@
+#ifndef RenderSystem_h__
+#define RenderSystem_h__
+
+#include "../Core/System.h"
+#include "RenderQueue.h"
+#include "../GLM.h"
+#include "../OpenGL.h"
+#include "../Core/ResourceManager.h"
+#include "ESetCamera.h"
+#include "Model.h"
+#include "../Core/EKeyDown.h"
+#include "../Input/EInputCommand.h"
+#include "Camera.h"
+#include "ModelJob.h"
+#include "Renderer.h"
+#include "../Core/Transform.h"
+
+class RenderSystem : public ImpureSystem
+{
+public:
+    RenderSystem(EventBroker* eventBrokerer, const IRenderer* renderer, RenderFrame* renderFrame);
+
+    virtual void Update(World* world, double dt) override;
+
+private:
+    World* m_World = nullptr;
+    const IRenderer* m_Renderer = nullptr;
+
+    RenderFrame* m_RenderFrame;
+    bool m_SwitchCamera = false;
+    Camera* m_Camera = nullptr;
+    Camera* m_DefaultCamera = nullptr;
+    
+    std::list<ComponentWrapper> m_CameraComponents;
+
+    EventRelay<RenderSystem, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera &event);
+    EntityID m_CurrentCamera = EntityID_Invalid;
+
+    void switchCamera(EntityID entity);
+
+    void updateCamera(World* world, double dt);
+    void updateProjectionMatrix(ComponentWrapper& cameraComponent);
+    glm::mat4 m_ViewMatrix;
+    glm::mat4 m_ProjectionMatrix;
+    
+    void fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+    void fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
+
+    EventRelay<RenderSystem, Events::InputCommand> m_EInputCommand;
+    bool OnInputCommand(const Events::InputCommand& e);
+};
+
+#endif

include/Engine/Rendering/Renderer.h

@@ -10,58 +10,61 @@
 #include "Util/UnorderedMapVec2.h"
 #include "FrameBuffer.h"
 #include "../Core/World.h"
-
+#include "PickingPass.h"
+#include "DrawScenePass.h"
 #include "../Core/EventBroker.h"
-#include "EPicking.h"
+#include "ImGuiRenderPass.h"
+#include "Camera.h"
 
 #include "TextRenderer.h"
 
 class Renderer : public IRenderer
 {
 public:
-    Renderer(EventBroker* eventBroker) 
+    Renderer(EventBroker* eventBroker, World* world) 
         : m_EventBroker(eventBroker)
+        , m_World(world)
     { }
 
-	virtual void Initialize() override;
-	virtual void Update(double dt) override;
-	virtual void Draw(RenderQueueCollection& rq) override;
+    virtual void Initialize() override;
+    virtual void Update(double dt) override;
+    virtual void Draw(RenderFrame& frame) override;
+
+    virtual PickData Pick(glm::vec2 screenCoord) override;
 
 private:
-	//----------------------Variables----------------------//
+    //----------------------Variables----------------------//
     EventBroker* m_EventBroker;
+    World* m_World;
     TextRenderer* m_TextRenderer;
 
-	Texture* m_ErrorTexture;
-	Texture* m_WhiteTexture;
-	float m_CameraMoveSpeed;
-    FrameBuffer m_PickingBuffer;
-    GLuint m_PickingTexture;
-    GLuint m_DepthBuffer;
+    Texture* m_ErrorTexture;
+    Texture* m_WhiteTexture;
 
     Model* m_ScreenQuad;
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-    std::unordered_map<glm::vec2, EntityID> m_PickingColorsToEntity;
+    DrawScenePass* m_DrawScenePass;
+    PickingPass* m_PickingPass;
+    ImGuiRenderPass* m_ImGuiRenderPass;
 
-	//----------------------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);
-
 
     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;
+
 };
 
 #endif

include/Engine/Rendering/ShaderProgram.h

@@ -1,9 +1,9 @@
-
 #ifndef ShaderProgram_h__
 #define ShaderProgram_h__
 
 #include "../Common.h"
 #include "../OpenGL.h"
+#include "../Core/ResourceManager.h"
 #include <fstream>
 
 class Shader
@@ -63,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);
@@ -83,4 +85,4 @@ private:
 	std::vector<std::shared_ptr<Shader>> m_Shaders;
 };
 
-#endif
+#endif

include/Engine/Rendering/TextJob.h

@@ -0,0 +1,37 @@
+#ifndef TextJob_h__
+#define TextJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "Texture.h"
+#include "RenderJob.h"
+#include "../Core/ResourceManager.h"
+#include "Font.h"
+
+struct TextJob : RenderJob
+{
+    TextJob(glm::mat4 matrix, Font* font, ComponentWrapper textComponent)
+        : RenderJob()
+    {
+        Matrix = matrix;
+        Color = (glm::vec4)textComponent["Color"];
+        Content = (std::string)textComponent["Content"];
+        Resource = font;
+    };
+
+    glm::mat4 Matrix;
+    glm::vec4 Color;
+    std::string Content;
+    Font* Resource;
+
+
+    void CalculateHash() override
+    {
+        Hash = 0;
+    }
+};
+
+#endif

include/Engine/Rendering/TextRenderer.h

@@ -17,7 +17,7 @@ public:
     TextRenderer();
     void Initialize();
     void Update();
-    void Draw(RenderQueue &rq, glm::mat4 projection, glm::mat4 view);
+    void Draw(RenderScene& scene);
 
 private:
     Font* font;
@@ -26,7 +26,7 @@ private:
 
     void RenderText(std::string text, Font* font, GLfloat scale, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix);
 
-    ShaderProgram m_TextProgram;
+    ShaderProgram* m_TextProgram;
 
     std::string text = "";
 

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/UnorderedMapiVec2.h

@@ -0,0 +1,24 @@
+#pragma once
+#ifndef UnorderedMapiVec2_h__
+#define UnorderedMapiVec2_h__
+
+#include <functional>
+#include <boost/functional/hash.hpp>
+#include <glm/vec2.hpp>
+
+template<>
+struct std::hash<glm::ivec2>
+{
+    inline std::size_t operator()(const glm::ivec2 &v) const
+    {
+        return boost::hash<float>()(v.x) ^ boost::hash<float>()(v.y);
+    }
+
+    inline bool operator()(const glm::ivec2& a, const glm::ivec2& b)const
+    {
+        return a.x == b.x && a.y == b.y;
+    }
+
+};
+
+#endif