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

# Conflicts:
#	include/Engine/Rendering/DrawFinalPass.h
#	resources/Schema/Components.xsd
#	resources/Schema/Entities/CollisionTestLevel.xml
#	resources/Schema/Types/Entity.xsd
#	src/Engine/Collision/Collision.cpp
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Engine/Rendering/RenderSystem.cpp

include/Engine/Collision/Collision.h

@@ -28,6 +28,21 @@ bool RayVsAABB(const Ray& ray, const AABB& box);
 //Return true if the ray hits the box, also outputs distance from ray origin to intersection point in [outDistance].
 bool RayVsAABB(const Ray& ray, const AABB& box, float& outDistance);
 
+//Return true if the ray hits the triangle.
+bool RayVsTriangle(const Ray& ray,
+    const glm::vec3& v0,
+    const glm::vec3& v1,
+    const glm::vec3& v2,
+    bool trueOnNegativeDistance = false);
+//Return true if the ray hits the triangle, and the distance is less than outDistance.
+bool RayVsTriangle(const Ray& ray,
+    const glm::vec3& v0,
+    const glm::vec3& v1,
+    const glm::vec3& v2,
+    float& outDistance,
+    float& outUCoord,
+    float& outVCoord,
+    bool trueOnNegativeDistance = false);
 //Return true if the ray hits any of the triangles in the model. Stops checking when a hit is detected.
 bool RayVsModel(const Ray& ray, 
     const std::vector<RawModel::Vertex>& modelVertices,
@@ -52,6 +67,9 @@ bool AABBvsTriangles(const AABB& box,
     const std::vector<RawModel::Vertex>& modelVertices,
     const std::vector<unsigned int>& modelIndices,
     const glm::mat4& modelMatrix,
+    glm::vec3& boxVelocity,
+    float verticalStepHeight,
+    bool& isOnGround,
     glm::vec3& outResolutionVector);
 
 //Return true if the boxes are intersecting.
@@ -60,6 +78,8 @@ bool AABBVsAABB(const AABB& a, const AABB& b);
 //Also outputs the minimum translation that box [a] would need in order to resolve collision.
 bool AABBVsAABB(const AABB& a, const AABB& b, glm::vec3& minimumTranslation);
 
+//Attaches an AABB which contains all vertices in the entitys Model.
+bool AttachAABBComponentFromModel(EntityWrapper entity);
 // Calculates an absolute AABB from an entity AABB component
 boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity);
 

include/Engine/Collision/FillOctreeSystem.h

@@ -6,12 +6,12 @@
 #include "Collision.h"
 #include "EntityAABB.h"
 
-class CollidableOctreeSystem : public ImpureSystem, public PureSystem
+class FillOctreeSystem : public ImpureSystem, public PureSystem
 {
 public:
-    CollidableOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree, const std::string& componentType)
+    FillOctreeSystem(World* world, EventBroker* eventBroker, Octree<EntityAABB>* octree, const std::string& fillComponentType)
         : System(world, eventBroker)
-        , PureSystem(componentType)
+        , PureSystem(fillComponentType)
         , m_Octree(octree)
     { }
 

include/Engine/Core/ComponentWrapper.h

@@ -43,6 +43,11 @@ struct ComponentWrapper
     // Specialization for string literals
     template <std::size_t N>
     void SetField(std::string name, const char(&value)[N]) { Field<std::string>(name) = std::string(value); }
+
+    void Copy(ComponentWrapper& destination)
+    {
+        memcpy(destination.Data, this->Data, Info.Stride);
+    }
     
     struct SubscriptProxy
     {

include/Engine/Core/EPickupSpawned.h

@@ -0,0 +1,17 @@
+#ifndef EPickupSpawned_h__
+#define EPickupSpawned_h__
+
+#include "Core/Event.h"
+#include "Core/EntityWrapper.h"
+
+namespace Events
+{
+
+struct PickupSpawned : Event
+{
+    EntityWrapper Pickup;
+};
+
+}
+
+#endif

include/Engine/Core/EPlayerDamage.h

@@ -9,6 +9,7 @@ namespace Events
 
 struct PlayerDamage : Event
 {
+    //NOTE: this struct is missing information on what the damageSource is
     EntityWrapper Player;
     double Damage;
 };

include/Engine/Core/EPlayerDeath.h

@@ -2,7 +2,7 @@
 #define EPlayerDeath_h__
 
 #include "EventBroker.h"
-#include "../Core/Entity.h"
+#include "../Core/EntityWrapper.h"
 
 namespace Events
 {
@@ -10,8 +10,7 @@ namespace Events
 struct PlayerDeath : Event
 {
     //KilledBy,KilledByWhat is optional for now. It might be used later in the playerlog-system
-    EntityID KilledBy;
-    EntityID PlayerID;
+    EntityWrapper Player;
     std::string KilledByWhat;
 };
 

include/Engine/Core/EPlayerHealthPickup.h

@@ -2,16 +2,16 @@
 #define EPlayerHealthPickup_h__
 
 #include "EventBroker.h"
-#include "../Core/Entity.h"
+#include "../Core/EntityWrapper.h"
 
 namespace Events
 {
 
-struct PlayerHealthPickup : Event
-{
-    double HealthAmount;
-    EntityID PlayerHealedID;
-};
+    struct PlayerHealthPickup : Event
+    {
+        EntityWrapper Player;
+        double HealthAmount;
+    };
 
 }
 

include/Engine/Core/EntityWrapper.h

@@ -25,6 +25,7 @@ struct EntityWrapper
 
     const std::string Name();
     bool HasComponent(const std::string& componentType);
+    void AttachComponent(const char* componentName);
     EntityWrapper Parent();
     EntityWrapper FirstChildByName(const std::string& name);
     EntityWrapper FirstParentWithComponent(const std::string& componentType);

include/Engine/Core/MemoryPool.h

@@ -102,7 +102,7 @@ public:
 			m_ExtraMemory.push_back((char*)malloc(m_Stride));
 			//We should preferably not enter here to avoid performance issues. Set more numMaxElements in constructor instead.
             if (!DisableMemoryPool::Value) {
-			    LOG_WARNING("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
+			    LOG_DEBUG("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
             }
 			return m_ExtraMemory.back();
 		}

include/Engine/Core/Octree.h

@@ -111,7 +111,7 @@ struct Child
     std::vector<ContainedObject>& m_StaticObjectsRef;
     std::vector<ContainedObject>& m_DynamicObjectsRef;
 
-    bool hasChildren() const;
+    inline bool hasChildren() const { return m_Children[0] != nullptr; }
     int childIndexContainingPoint(const glm::vec3& point) const;
     std::vector<int> childIndicesContainingBox(const AABB& box) const;
 };

include/Engine/Core/Ray.h

@@ -7,6 +7,10 @@
 class Ray
 {
 public:
+    Ray()
+        : m_Origin(glm::vec3(0.f))
+        , m_Direction(glm::vec3(0, 0, 1))
+    {}
     Ray(const glm::vec3& origin, const glm::vec3& dir)
         : m_Origin(origin)
         , m_Direction(glm::normalize(dir))

include/Engine/Core/Transform.h

@@ -18,6 +18,7 @@ glm::vec3 AbsoluteScale(EntityWrapper entity);
 glm::vec3 AbsoluteScale(World* world, EntityID entity);
 glm::mat4 ModelMatrix(EntityWrapper entity);
 glm::mat4 ModelMatrix(EntityID entity, World* world);
+glm::vec3 TransformPoint(const glm::vec3& point, const glm::mat4& matrix);
 
 }
 

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -17,7 +17,7 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure);
+    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLfloat gamma, GLfloat exposure);
 private:
     const IRenderer* m_Renderer;
 

include/Engine/Rendering/DrawFinalPass.h

@@ -22,15 +22,23 @@ public:
 
     //Return the texture that is used in later stages to apply the bloom effect
     GLuint BloomTexture() const { return m_BloomTexture; }
+    GLuint BloomTextureLowRes() const { return m_BloomTextureLowRes; }
     //Return the texture with diffuse and lighting of the scene.
     GLuint SceneTexture() const { return m_SceneTexture; }
+    GLuint SceneTextureLowRes() const { return m_SceneTextureLowRes; }
+    //Return the framebuffer used in the scene rendering stage.
     FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
+    FrameBuffer* FinalPassFrameBufferLowRes() { return &m_FinalPassFrameBufferLowRes; }
 
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
     void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
-    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& job, RenderScene& scene);
+
+    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
 
     void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
     void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
@@ -44,9 +52,16 @@ private:
     Texture* m_GreyTexture;
 
     FrameBuffer m_FinalPassFrameBuffer;
+    FrameBuffer m_FinalPassFrameBufferLowRes;
     GLuint m_BloomTexture;
     GLuint m_SceneTexture;
+    GLuint m_BloomTextureLowRes;
+    GLuint m_SceneTextureLowRes;
     GLuint m_DepthBuffer;
+    GLuint m_DepthBufferLowRes;
+
+    //maqke this component based i guess?
+    GLuint m_ShieldPixelRate = 16;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
@@ -55,6 +70,8 @@ private:
     ShaderProgram* m_ExplosionEffectProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
 	ShaderProgram* m_ForwardPlusSplatMapProgram;
+    ShaderProgram* m_ShieldToStencilProgram;
+    ShaderProgram* m_FillDepthBufferProgram;
 
 
 	ShaderProgram* m_ForwardPlusSkinnedProgram;

include/Engine/Rendering/DrawFinalPassState.h

@@ -12,4 +12,11 @@ private:
 
 };
 
+class DrawStencilState : public RenderState
+{
+public:
+    DrawStencilState(GLuint frameBuffer);
+    ~DrawStencilState();
+};
+
 #endif

include/Engine/Rendering/RenderQueue.h

@@ -19,22 +19,30 @@
 struct RenderScene
 {
     ::Camera* Camera = nullptr;
-    std::list<std::shared_ptr<RenderJob>> OpaqueObjects;
-    std::list<std::shared_ptr<RenderJob>> TransparentObjects;
-    std::list<std::shared_ptr<RenderJob>> PointLightJobs;
-    std::list<std::shared_ptr<RenderJob>> TextJobs;
-    std::list<std::shared_ptr<RenderJob>> DirectionalLightJobs;
+    struct Queues {
+        std::list<std::shared_ptr<RenderJob>> OpaqueObjects;
+        std::list<std::shared_ptr<RenderJob>> TransparentObjects;
+        std::list<std::shared_ptr<RenderJob>> OpaqueShieldedObjects;
+        std::list<std::shared_ptr<RenderJob>> TransparentShieldedObjects;
+        std::list<std::shared_ptr<RenderJob>> ShieldObjects;
+        std::list<std::shared_ptr<RenderJob>> PointLight;
+        std::list<std::shared_ptr<RenderJob>> Text;
+        std::list<std::shared_ptr<RenderJob>> DirectionalLight;
+    } Jobs;
+
     Rectangle Viewport;
     bool ClearDepth = false;
     glm::vec4 AmbientColor;
 
 	void Clear()
 	{
-        OpaqueObjects.clear();
-        TransparentObjects.clear();
-        PointLightJobs.clear();
-        TextJobs.clear();
-        DirectionalLightJobs.clear();
+        Jobs.OpaqueObjects.clear();
+        Jobs.TransparentObjects.clear();
+        Jobs.OpaqueShieldedObjects.clear();
+        Jobs.TransparentShieldedObjects.clear();
+        Jobs.ShieldObjects.clear();
+        Jobs.Text.clear();
+        Jobs.DirectionalLight.clear();
 	}
 };
 

include/Engine/Rendering/RenderState.h

@@ -2,6 +2,7 @@
 #define RenderState_h__
 
 #include <functional>
+#include <boost/range/adaptor/reversed.hpp>
 #include "../Common.h"
 #include "../OpenGL.h"
 #include "../GLM.h"
@@ -19,6 +20,9 @@ public:
     bool BindFramebuffer(GLint framebuffer);
     bool BlendEquation(GLenum mode);
     bool BlendFunc(GLenum sfactor, GLenum dfactor);
+    bool StencilOp(GLenum sfail, GLenum dpfail, GLenum dppass);
+    bool StencilFunc(GLenum func, GLint ref, GLuint mask);
+    bool StencilMask(GLuint mask);
     bool DepthMask(GLboolean flag);
 
 private:

include/Engine/Rendering/RenderSystem.h

@@ -40,7 +40,7 @@ private:
     EventRelay<RenderSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
 
-    void fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs, std::list<std::shared_ptr<RenderJob>>& transparentJobs);
+    void fillModels(RenderScene::Queues &jobs);
     void fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);
     void fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world);