Merge remote-tracking branch 'origin/master' into Forward+

# Conflicts:
#	include/Engine/Rendering/PickingPass.h
#	include/Engine/Rendering/Renderer.h
#	resources/Schema/Entities/Test.xml
#	src/Engine/Rendering/DrawScenePass.cpp
#	src/Engine/Rendering/PickingPass.cpp
#	src/Engine/Rendering/RenderQueueFactory.cpp
#	src/Engine/Rendering/Renderer.cpp

include/Engine/Core/ComponentInfo.h

@@ -14,6 +14,7 @@ struct ComponentInfo
 
     struct Field_t
     {
+        std::string Name;
         std::string Type;
         unsigned int Offset;
         unsigned int Stride;
@@ -21,7 +22,7 @@ struct ComponentInfo
 
 	std::string Name;
     std::unordered_map<std::string, Field_t> Fields;
-    std::vector<const Field_t*> FieldsInOrder;
+    std::vector<std::string> FieldsInOrder;
 	Meta_t Meta;
     std::shared_ptr<char> Defaults = nullptr;
 };

include/Engine/Core/Transform.h

@@ -0,0 +1,62 @@
+#ifndef Transform_h__
+#define Transform_h__
+
+#include "../GLM.h"
+#include "World.h"
+
+static class Transform
+{
+public:
+    static glm::vec3 AbsolutePosition(World* world, EntityID entity)
+    {
+        glm::vec3 position;
+
+        while (entity != EntityID_Invalid) {
+            ComponentWrapper transform = world->GetComponent(entity, "Transform");
+            EntityID parent = world->GetParent(entity);
+            position += AbsoluteOrientation(world, parent) * (glm::vec3)transform["Position"];
+            entity = parent;
+        }
+
+        return position;
+    };
+
+    static glm::quat AbsoluteOrientation(World* world, EntityID entity)
+    {
+        glm::quat orientation;
+
+        while (entity != EntityID_Invalid) {
+            ComponentWrapper transform = world->GetComponent(entity, "Transform");
+            orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
+            entity = world->GetParent(entity);
+        }
+
+        return orientation;
+    };
+
+    static glm::vec3 AbsoluteScale(World* world, EntityID entity)
+    {
+        glm::vec3 scale(1.f);
+
+        while (entity != EntityID_Invalid) {
+            ComponentWrapper transform = world->GetComponent(entity, "Transform");
+            scale *= (glm::vec3)transform["Scale"];
+            entity = world->GetParent(entity);
+        }
+
+        return scale;
+    };
+
+    static glm::mat4 ModelMatrix(EntityID entity, World* world)
+    {
+        glm::vec3 position = Transform::AbsolutePosition(world, entity);
+        glm::quat orientation = Transform::AbsoluteOrientation(world, entity);
+        glm::vec3 scale = Transform::AbsoluteScale(world, entity);
+
+        glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
+        return modelMatrix;
+    }
+
+};
+
+#endif

include/Engine/Editor/EditorSystem.h

@@ -9,9 +9,8 @@
 #include "../Core/ConfigFile.h"
 #include "../Input/EInputCommand.h"
 #include "../Rendering/IRenderer.h"
-#include "../Rendering/EPicking.h"
+#include "../Core/Transform.h"
 #include "../Core/EFileDropped.h"
-#include "../Rendering/RenderQueueFactory.h"
 #include "../Core/EntityFilePreprocessor.h"
 #include "../Core/EntityFileParser.h"
 #include "../Core/EntityFileWriter.h"
@@ -26,6 +25,7 @@ public:
 private:
     IRenderer* m_Renderer;
     World* m_World = nullptr;
+    Camera* m_Camera = nullptr;
 
     bool m_Enabled;
     bool m_Visible;
@@ -57,6 +57,7 @@ private:
     EntityID m_WidgetOrigin = EntityID_Invalid;
     glm::vec3 m_WidgetCurrentAxis;
     float m_WidgetPickingDepth = 0.f;
+    glm::vec3 m_WidgetPickingPosition = glm::vec3(0);
 
     EntityID m_Selection = EntityID_Invalid;
     EntityID m_LastSelection = EntityID_Invalid;
@@ -75,11 +76,10 @@ private:
     bool OnMousePress(const Events::MousePress& e);
     EventRelay<EditorSystem, Events::MouseMove> m_EMouseMove;
     bool OnMouseMove(const Events::MouseMove& e);
-    EventRelay<EditorSystem, Events::Picking> m_EPicking;
-    bool OnPicking(const Events::Picking& e);
     EventRelay<EditorSystem, Events::FileDropped> m_EFileDropped;
     bool OnFileDropped(const Events::FileDropped& e);
-
+    
+    void Picking();
     void createWidget();
     void updateWidget();
     void setWidgetMode(WidgetMode newMode);

include/Engine/GUI/Button.h

@@ -40,7 +40,7 @@ public:
 		m_TexturePressed = resourceName;
 	}
 
-	void Draw(RenderQueueCollection& rq) override
+	void Draw(RenderScene& rq) override
 	{
 		if (m_Texture == nullptr && !m_TextureReleased.empty()) {
 			SetTexture(m_TextureReleased);

include/Engine/GUI/Frame.h

@@ -212,7 +212,7 @@ public:
 
 	virtual void Update(double dt) { }
 
-	void DrawLayered(RenderQueueCollection& rq)
+	void DrawLayered(RenderScene& rq)
 	{
 		if (this->Hidden())
 			return;
@@ -232,7 +232,7 @@ public:
 		}
 	}
 
-	virtual void Draw(RenderQueueCollection& rq) { }
+	virtual void Draw(RenderScene& rq) { }
 
 protected:
 	::EventBroker* m_EventBroker;

include/Engine/GUI/TextureFrame.h

@@ -16,7 +16,7 @@ public:
 	void EnableScissor() { m_ScissorEnabled = true; }
 	void DisableScissor() { m_ScissorEnabled = false; }
 
-	void Draw(RenderQueueCollection& rq) override
+	void Draw(RenderScene& rq) override
 	{
 		if (m_Texture == nullptr)
 			return;

include/Engine/Network/Client.h

@@ -23,7 +23,6 @@ public:
     ~Client();
     void Start(World* world, EventBroker* eventBroker) override;
     void Update() override;
-    void Close();
 private:
     // Assio UDP logic
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
@@ -32,7 +31,7 @@ private:
 
     // Sending message to server logic
     int bytesRead = -1;
-    char readBuf[1024] = { 0 };
+    char readBuf[INPUTSIZE] = { 0 };
     int snapshotInterval = 33;
     std::clock_t previousSnapshotMessage = std::clock();
 
@@ -49,7 +48,6 @@ private:
     // Network logic
     PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
     SnapshotDefinitions m_NextSnapshot;
-    bool m_ThreadIsRunning = true;
     double m_DurationOfPingTime;
     std::clock_t m_StartPingTime;
     // Use to check if we should send disconnect message
@@ -59,7 +57,7 @@ private:
     // Private member functions
     void readFromServer();
     void sendSnapshotToServer();
-    int receive(char* data, size_t length);
+    int  receive(char* data, size_t length);
     void send(Packet& packet);
     void connect();
     void disconnect();
@@ -67,6 +65,7 @@ private:
     void moveMessageHead(char*& data, size_t& length, size_t stepSize);
     void parseMessageType(Packet& packet);
     void parseEventMessage(Packet& packet);
+    void updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID, const std::string& componentType);
     void parseConnect(Packet& packet);
     void parsePing();
     void parseServerPing();

include/Engine/Network/Network.h

@@ -6,7 +6,7 @@
 #include "Network/Packet.h"
 
 #define MAXCONNECTIONS 8
-#define INPUTSIZE 128
+#define INPUTSIZE 4097
 
 class Network
 {

include/Engine/Network/Packet.h

@@ -14,15 +14,17 @@ public:
     Packet(MessageType type, unsigned int& packetID);
     // Used to create packet from already existing data buffer.
     Packet(char* data, const int sizeOfPacket);
-    
     ~Packet();
+    void Init(MessageType type, unsigned int& packetID);
+
     // Add primitive types like int, float, char...
     template<typename T>
     void WritePrimitive(T val)
     {
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
-            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for!");
+            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for! New size is %i bytes\n", m_MaxPacketSize*2);
+            resizeData();
         }
         memcpy(m_Data + m_Offset, &val, sizeof(T));
         m_Offset += sizeof(T);
@@ -41,7 +43,7 @@ public:
         return returnValue;
     }
     // Add a string to the message
-    void WriteString(std::string str);
+    void WriteString(const std::string& str);
     // Add data to the message
     void WriteData(char* data, int sizeOfData);
     // Pops the first element as if it was a string.
@@ -50,12 +52,15 @@ public:
 
     int Size() { return m_Offset; };
     char* Data() { return m_Data; };
+    unsigned int DataReadSize() { return m_ReturnDataOffset; }
+    unsigned int MaxSize() { return m_MaxPacketSize; }
 
 private:
     char* m_Data;
     unsigned int m_ReturnDataOffset = 0;
     int m_Offset = 0;
-    unsigned int m_MaxPacketSize = 128;
+    unsigned int m_MaxPacketSize = 512;
+    void resizeData();
 };
 
 #endif

include/Engine/Network/Server.h

@@ -20,8 +20,6 @@ public:
     ~Server();
     void Start(World* m_world, EventBroker *eventBroker) override;
     void Update() override;
-    void Close();
-
 private:
     // UDP logic
     boost::asio::ip::udp::endpoint m_ReceiverEndpoint;
@@ -30,7 +28,7 @@ private:
     PlayerDefinition m_PlayerDefinitions[MAXCONNECTIONS];
 
     // Sending messages to client logic
-    char readBuffer[1024] = { 0 };
+    char readBuffer[INPUTSIZE] = { 0 };
     int bytesRead = 0;
     // time for previouse message
     std::clock_t previousePingMessage = std::clock();
@@ -55,9 +53,6 @@ private:
     unsigned int m_PacketID;
     unsigned int m_PreviousPacketID;
     unsigned int m_SendPacketID;
-    
-    // Close logic
-    bool m_ThreadIsRunning = true;
 
     // Private member functions
     int  receive(char* data, size_t length);

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

@@ -9,6 +9,9 @@ public:
         : 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; }
 

include/Engine/Rendering/DrawFinalPass.h

@@ -18,7 +18,7 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(RenderQueueCollection& rq);
+    void Draw(RenderScene& scene);
 
     //Getters
 

include/Engine/Rendering/DrawScenePass.h

@@ -17,7 +17,7 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(RenderQueueCollection& rq);
+    void Draw(RenderScene& scene);
 
     //Getters
 
@@ -25,12 +25,18 @@ public:
 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/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,74 +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;
-        // Depth
-        float Depth;
-    };
-
-    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);
-        pickData.Depth = data.Depth;
-
-        auto it = PickingColorsToEntity->find(glm::vec2(data.Color[0], data.Color[1]));
-        if (it != PickingColorsToEntity->end()) {
-            pickData.Entity = it->second;
-        } else {
-            pickData.Entity = EntityID_Invalid;
-        }
-        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/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,9 +10,17 @@
 #include "RenderQueue.h"
 #include "Model.h"
 #include "../Core/World.h" //So temp
-#include "RenderQueueFactory.h" //So temp
 
 
+struct PickData
+{
+    EntityID Entity;
+    glm::vec3 Position; //World position
+    float Depth;
+    ::Camera* Camera;
+    const ::World* World;
+};
+
 class IRenderer
 {
 public:
@@ -23,19 +31,19 @@ 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;
 
     World* m_World; //Temp world, untill viktor merge.
 
@@ -45,9 +53,9 @@ protected:
 	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/LightCullingPass.h

@@ -7,6 +7,7 @@
 #include "IRenderer.h"
 #include "LightCullingPassState.h"
 #include "ShaderProgram.h"
+#include "RenderQueue.h"
 
 
 class LightCullingPass
@@ -15,9 +16,9 @@ public:
     LightCullingPass(IRenderer* renderer);
     ~LightCullingPass();
 
-    void GenerateNewFrustum();
-    void CullLights();
-    void FillLightList(RenderQueueCollection& rq);
+    void GenerateNewFrustum(RenderScene& scene);
+    void CullLights(RenderScene& scene);
+    void FillLightList(RenderScene& scene);
 
     GLuint FrustumSSBO() const { return m_FrustumSSBO; }
     GLuint LightSSBO() const { return m_LightSSBO; }

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;
+    World* World;
+
+    void CalculateHash() override
+    {
+        Hash = TextureID;
+    }
+};
+
+#endif

include/Engine/Rendering/PickingPass.h

@@ -7,9 +7,9 @@
 #include "PickingPassState.h"
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
-#include "Util/UnorderedMapVec2.h"
+#include "Util/UnorderedMapiVec2.h"
 #include "../Core/EventBroker.h"
-#include "EPicking.h"
+#include "../Core/World.h"
 
 
 
@@ -22,15 +22,19 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(RenderQueueCollection& rq);
+    void Draw(RenderScene& scene);
+    void ClearPicking();
 
     //Getters
     const ShaderProgram& PickingProgram() const { return *m_PickingProgram; }
-    const std::unordered_map<glm::vec2, EntityID>& PickingColorsToEntity() const { return m_PickingColorsToEntity; }
+    //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;
 
@@ -39,13 +43,24 @@ private:
     const IRenderer* m_Renderer;
 
     ShaderProgram* m_PickingProgram;
+    Camera* m_Camera;
 
-    std::unordered_map<glm::vec2, EntityID> m_PickingColorsToEntity;
+    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/PointLightJob.h

@@ -0,0 +1,36 @@
+#ifndef PointLightJob_h__
+#define PointLightJob_h__
+
+#include <cstdint>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include "../Core/ComponentWrapper.h"
+#include "RenderJob.h"
+
+struct PointLightJob : RenderJob
+{
+    PointLightJob(ComponentWrapper transformComponent, ComponentWrapper pointLightComponent)
+        : RenderJob()
+    {
+        Position = glm::vec4((glm::vec3)transformComponent["Position"], 1.0f);
+        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

@@ -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,61 +8,13 @@
 #include "../GLM.h"
 #include "../Core/Util/Rectangle.h"
 #include "../Core/Entity.h"
+#include "Camera.h"
+#include "RenderJob.h"
+#include "ModelJob.h"
+#include "PointLightJob.h"
 
-class Model;
-class Skeleton;
-class Texture;
-class RenderQueue;
-
-//TODO: Render: Remove obsolete RenderJobs and fix standard values on variables.
-
-struct RenderJob
-{
-	friend class RenderQueue;
-
-	float Depth;
-
-protected:
-	uint64_t Hash;
-
-	virtual void CalculateHash() = 0;
-
-	bool operator<(const RenderJob& rhs)
-	{
-		return this->Hash < rhs.Hash;
-	}
-};
-
-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;
@@ -94,62 +46,53 @@ struct PointLightJob : RenderJob
 		Hash = 0;
 	}
 };
+*/
 
-class RenderQueue
+struct RenderScene
 {
-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();
-	}
+    ::Camera* Camera;
+    std::list<std::shared_ptr<RenderJob>> ForwardJobs;
+    std::list<std::shared_ptr<RenderJob>> PointLightJobs;
+    Rectangle Viewport;
 
 	void Clear()
 	{
-		Jobs.clear();
-		m_Size = 0;
+        ForwardJobs.clear();
+        PointLightJobs.clear();
 	}
-
-	int Size() const { return m_Size; }
-	std::list<std::shared_ptr<RenderJob>>::const_iterator begin()
-	{
-		return Jobs.begin();
-	}
-
-	std::list<std::shared_ptr<RenderJob>>::const_iterator end()
-	{
-		return Jobs.end();
-	}
-
-	std::list<std::shared_ptr<RenderJob>> Jobs;
-
-private:
-	int m_Size = 0;
 };
 
-struct RenderQueueCollection
+struct RenderFrame
 {
-	RenderQueue Forward;
-	RenderQueue Lights;
+public:
 
-	void Clear()
-	{
-		Forward.Clear();
-		Lights.Clear();
-	}
+    void Add(RenderScene &scene)
+    {
+        RenderScenes.push_back(std::shared_ptr<RenderScene>(new RenderScene(scene)));
+        m_Size++;
+    }
 
-	void Sort()
-	{
-		Forward.Sort();
-		Lights.Sort();
-	}
+    void Clear()
+    {
+        RenderScenes.clear();
+        m_Size = 0;
+    }
+
+    int Size() const { return m_Size; }
+    std::list<std::shared_ptr<RenderScene>>::const_iterator begin()
+    {
+        return RenderScenes.begin();
+    }
+
+    std::list<std::shared_ptr<RenderScene>>::const_iterator end()
+    {
+        return RenderScenes.end();
+    }
+
+    std::list<std::shared_ptr<RenderScene>> RenderScenes;
+    
+private:
+    int m_Size = 0;
 };
 
 #endif

include/Engine/Rendering/RenderQueueFactory.h

@@ -1,31 +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; }
-
-    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;
-
-    void FillModels(World* world, RenderQueue* renderQueue);
-    void FillLights(World* world, RenderQueue* renderQueue);
-
-    glm::mat4 ModelMatrix(World* world, EntityID entity);
-};
-
-#endif

include/Engine/Rendering/RenderSystem.h

@@ -0,0 +1,55 @@
+#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 "PointLightJob.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 fillLight(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

@@ -12,34 +12,34 @@
 #include "../Core/World.h"
 #include "PickingPass.h"
 #include "DrawScenePass.h"
-#include "DebugCameraInputController.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
-
 #include "../Core/EventBroker.h"
-#include "EPicking.h"
 #include "ImGuiRenderPass.h"
+#include "Camera.h"
+#include "../Core/Transform.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 Draw(RenderFrame& frame) override;
+
+    virtual PickData Pick(glm::vec2 screenCoord) override;
 
 private:
     //----------------------Variables----------------------//
     EventBroker* m_EventBroker;
-
-    std::shared_ptr<DebugCameraInputController<Renderer>> m_DebugCameraInputController;
+    World* m_World;
 
     Texture* m_ErrorTexture;
     Texture* m_WhiteTexture;
-    float m_CameraMoveSpeed;
 
     Model* m_ScreenQuad;
     Model* m_UnitQuad;
@@ -62,8 +62,7 @@ private:
     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(RenderQueueCollection& rq);
-
+    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;

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