Broken undo

Death explosion should always get triggered now.

include/Engine/Collision/CollisionSystem.h

@@ -24,6 +24,7 @@ public:
 private:
     Octree<EntityAABB>* m_Octree;
     std::vector<EntityAABB> m_OctreeResult;
+    std::unordered_map<EntityWrapper, glm::vec3> m_PrevPositions;
 };
 
 #endif

include/Engine/Core/ComponentPool.h

@@ -65,6 +65,8 @@ public:
 	iterator end() const;
     size_t size() const;
 
+    std::size_t MemoryUsage() const;
+
 	//Dumps information about what the pool memory looks like right now 
 	//into an output stream (e.g. file/std::cout, anything that has an operator<<)
 	//Interpret the data in the memory as InterpretType.

include/Engine/Core/EntityWrapper.h

@@ -27,8 +27,10 @@ struct EntityWrapper
     bool HasComponent(const std::string& componentType);
     void AttachComponent(const char* componentName);
     EntityWrapper Parent();
+    EntityWrapper BaseParent();
     EntityWrapper FirstChildByName(const std::string& name);
     EntityWrapper FirstParentWithComponent(const std::string& componentType);
+    EntityWrapper Clone(EntityWrapper parent = EntityWrapper::Invalid);
     bool IsChildOf(EntityWrapper potentialParent);
     bool Valid() const;
 
@@ -39,6 +41,7 @@ struct EntityWrapper
 
 private:
     EntityWrapper firstChildByNameRecursive(const std::string& name, EntityID parent);
+    EntityWrapper cloneRecursive(EntityWrapper entity, EntityWrapper parent);
 };
 
 namespace std

include/Engine/Core/MemoryPool.h

@@ -194,6 +194,11 @@ public:
 		return m_ExtraMemory.size();
 	}
 
+    std::size_t MemoryUsage() const
+    {
+        return size() * m_Stride;
+    }
+
 	//Dumps information about what the pool memory looks like right now 
 	//into an output stream (e.g. file/std::cout, anything that has an operator<<)
 	//Interpret the data in the memory as InterpretType.

include/Engine/Core/World.h

@@ -18,7 +18,7 @@ public:
     World(const World& other);
 
     // Create empty entity
-    EntityID CreateEntity(EntityID parent = 0);
+    EntityID CreateEntity(EntityID parent = EntityID_Invalid);
     // Delete entity and all components within
     void DeleteEntity(EntityID entity);
     // Check if an entity exists
@@ -40,7 +40,7 @@ public:
     // Change the parent of an entity
     void SetParent(EntityID entity, EntityID parent);
     // Get children of an entity
-    const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> GetChildren(EntityID entity);
+    const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> GetDirectChildren(EntityID entity);
     // Get all component pools
     const std::unordered_map<std::string, ComponentPool*>& GetComponentPools() const { return m_ComponentPools; }
     // Get the entity children map
@@ -50,6 +50,9 @@ public:
     // Get the textual name of an entity
     std::string GetName(EntityID entity) const;
 
+    // Get an approximate number for component pool memory usage
+    std::size_t MemoryUsage() const;
+
 private:
     EventBroker* m_EventBroker = nullptr;
     EntityID m_CurrentEntityID = 0;

include/Engine/Editor/EditorGUI.h

@@ -73,6 +73,12 @@ public:
     // Called when the user means to rename an entity.
     typedef std::function<void(EntityWrapper, const std::string&)> OnEntityChangeName_t;
     void SetEntityChangeNameCallback(OnEntityChangeName_t f) { m_OnEntityChangeName = f; }
+    // Called when the user pastes an entity previously "copied"
+    // @param EntityWrapper The entity to copy
+    // @param EntityWrapper The entity to parent the new copy to
+    // @return The new copy of the entity
+    typedef std::function<EntityWrapper(EntityWrapper, EntityWrapper)> OnEntityPaste_t;
+    void SetEntityPasteCallback(OnEntityPaste_t f) { m_OnEntityPaste = f; }
     // Called when the user means to attach a new component to an entity.
     typedef std::function<void(EntityWrapper, const std::string&)> OnComponentAttach_t;
     void SetComponentAttachCallback(OnComponentAttach_t f) { m_OnComponentAttach = f; }
@@ -85,7 +91,13 @@ public:
     // Called when the user selects a widget space.
     typedef std::function<void(WidgetSpace)> OnWidgetSpace_t;
     void SetWidgetSpaceCallback(OnWidgetSpace_t f) { m_OnWidgetSpace = f; }
-
+    // Called when anything is modified making the world dirty
+    // @param EntityWrapper The entity that was changed and marked as dirty
+    typedef std::function<void(EntityWrapper)> OnDirty_t;
+    void SetDirtyCallback(OnDirty_t f) { m_OnDirty = f; }
+    // Called when the user wishes to undo
+    typedef std::function<void()> OnUndo_t;
+    void SetUndoCallback(OnUndo_t f) { m_OnUndo = f; }
 private:
     World* m_World;
     EventBroker* m_EventBroker;
@@ -111,6 +123,7 @@ private:
     std::string m_DroppedFile = "";
     bool m_Paused = false;
     bool m_MouseLocked = false;
+    EntityWrapper m_CopyTarget = EntityWrapper::Invalid;
 
     // Callbacks
     OnEntitySelectedCallback_t m_OnEntitySelected = nullptr;
@@ -124,6 +137,9 @@ private:
     OnComponentDelete_t m_OnComponentDelete = nullptr;
     OnWidgetMode_t m_OnWidgetMode = nullptr;
     OnWidgetSpace_t m_OnWidgetSpace = nullptr;
+    OnEntityPaste_t m_OnEntityPaste = nullptr;
+    OnDirty_t m_OnDirty = nullptr;
+    OnUndo_t m_OnUndo = nullptr;
 
     // Events
     EventRelay<EditorGUI, Events::KeyDown> m_EKeyDown;

include/Engine/Editor/EditorSystem.h

@@ -36,6 +36,7 @@ private:
     EditorCameraInputController<EditorSystem>* m_EditorCameraInputController;
     EditorGUI* m_EditorGUI;
     EditorStats* m_EditorStats;
+    std::vector<World> m_UndoLevels;
 
     // State
     double m_LastTime = 0.f;
@@ -44,6 +45,7 @@ private:
     EditorGUI::WidgetSpace m_WidgetSpace = EditorGUI::WidgetSpace::Global;
     EntityWrapper m_Widget = EntityWrapper::Invalid;
     EntityWrapper m_CurrentSelection = EntityWrapper::Invalid;
+    bool m_SaveUndoLevel = false; // Only save undo state once per update
 
     // Utility functions
     EntityWrapper importEntity(EntityWrapper parent, boost::filesystem::path filePath);
@@ -56,9 +58,12 @@ private:
     void OnEntityDelete(EntityWrapper entity);
     void OnEntityChangeParent(EntityWrapper entity, EntityWrapper parent);
     void OnEntityChangeName(EntityWrapper entity, const std::string& name);
+    EntityWrapper OnEntityPaste(EntityWrapper entityToCopy, EntityWrapper parent);
     void OnComponentAttach(EntityWrapper entity, const std::string& componentType);
     void OnComponentDelete(EntityWrapper entity, const std::string& componentType);
     void OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace);
+    void OnDirty(EntityWrapper entity);
+    void OnUndo();
 
     // Events
     EventRelay<EditorSystem, Events::MousePress> m_EMousePress;

include/Engine/Network/Client.h

@@ -19,6 +19,7 @@
 #include "Core/World.h"
 #include "Core/EventBroker.h"
 #include "Core/ConfigFile.h"
+#include "Core/EPlayerDeath.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
 #include "../Game/Events/EDoubleJump.h"

include/Engine/Rendering/DrawBloomPass.h

@@ -12,7 +12,7 @@
 class DrawBloomPass
 {
 public:
-    DrawBloomPass(IRenderer* renderer, ConfigFile* config);
+    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
     ~DrawBloomPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -23,34 +23,23 @@ public:
     void FillGaussianBuffer(FrameBuffer* fb);
 
     void Draw(GLuint texture);
-	void ChangeQuality(int quality);
 
     void OnWindowResize();
 
     //Getters
     //Return the blurred result of the texture that was sent into draw
-	GLuint GaussianTexture() const {
-		if (m_Quality == 0) {
-			return m_BlackTexture->m_Texture;
-		}
-		else {
-			return m_GaussianTexture_vert;
-		}
-	}
-
+    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
 
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
 
-    Texture* m_BlackTexture;
+    Texture* m_WhiteTexture;
     Model* m_ScreenQuad;
 
     const IRenderer* m_Renderer;
-	ConfigFile* m_Config;
     //const LightCullingPass* m_LightCullingPass 
-	int m_Iterations = 7;
-	int m_Quality = 3;
+    GLuint m_iterations = 9;
 
     GLuint m_GaussianTexture_horiz;
     GLuint m_GaussianTexture_vert;

include/Engine/Rendering/DrawFinalPass.h

@@ -5,7 +5,6 @@
 #include "DrawFinalPassState.h"
 #include "LightCullingPass.h"
 #include "CubeMapPass.h"
-#include "SSAOPass.h"
 #include "FrameBuffer.h"
 #include "ShaderProgram.h"
 #include "Util/UnorderedMapVec2.h"
@@ -15,12 +14,12 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-    void Draw(RenderScene& scene);
+    void Draw(RenderScene& scene, GLuint SSAOTexture);
     void ClearBuffer();
     void OnWindowResize();
 
@@ -39,7 +38,7 @@ private:
     void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
 
     void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
-    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene, GLuint SSAOTexture);
     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);
@@ -72,7 +71,6 @@ private:
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
     const CubeMapPass* m_CubeMapPass;
-	const SSAOPass* m_SSAOPass;
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;

include/Engine/Rendering/IRenderer.h

@@ -5,7 +5,6 @@
 #include "../OpenGL.h"
 #include "../GLM.h"
 #include "../Core/Util/Rectangle.h"
-#include "../Core/ConfigFile.h"
 #include "Util/ScreenCoords.h"
 #include "Camera.h"
 #include "RenderQueue.h"

include/Engine/Rendering/Renderer.h

@@ -32,9 +32,8 @@ class Renderer : public IRenderer
     static void glfwFrameBufferCallback(GLFWwindow* window, int width, int height);
 
 public:
-	Renderer(EventBroker* eventBroker, ConfigFile* config)
-		: m_EventBroker(eventBroker)
-		, m_Config(config)
+    Renderer(EventBroker* eventBroker) 
+        : m_EventBroker(eventBroker)
     { }
 
     virtual void Initialize() override;
@@ -48,7 +47,6 @@ private:
     //----------------------Variables----------------------//
 
     static std::unordered_map <GLFWwindow*, Renderer*> m_WindowToRenderer;
-	ConfigFile* m_Config;
 
     EventBroker* m_EventBroker;
     TextPass* m_TextPass;
@@ -63,8 +61,12 @@ private:
     int m_DebugTextureToDraw = 0;
     int m_CubeMapTexture = 0;
     bool m_ResizeWindow = false;
-	int m_SSAO_Quality = 0;
-	int m_GLOW_Quality = 2;
+	float m_SSAO_Radius = 1.0f;
+	float m_SSAO_Bias = 0.05f;
+	float m_SSAO_Contrast = 1.5f;
+	float m_SSAO_IntensityScale = 1.0f;
+	int m_SSAO_NumOfSamples = 24;
+	int m_SSAO_NumOfTurns = 7;
 
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;

include/Engine/Rendering/SSAOPass.h

@@ -13,32 +13,18 @@
 class SSAOPass
 {
 public:
-	SSAOPass(IRenderer* renderer, ConfigFile* config);
-	~SSAOPass() { };
-
-	void ChangeQuality(int quality);
+	SSAOPass(IRenderer* rendere);
+	~SSAOPass() { 
+		delete m_DrawBloomPass;
+	};
 
 	void Draw(GLuint depthBuffer, Camera* camera);
-	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int numOfTurns, int iterations, int quality);
+	void Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns);
 	void ClearBuffer();
 	void OnWindowResize();
 
 	//Return the SSAO of the texture sent to Draw
-	GLuint SSAOTexture() const { 
-		if (m_Quality == 0) {
-			return m_WhiteTexture->m_Texture;
-		} else {
-			return m_GaussianTexture_vert;
-		}
-	}
-
-	int TextureQuality() const {
-		if (m_Quality == 0) {
-			return 13;
-		} else {
-			return m_TextureQuality;
-		}
-	}
+	GLuint SSAOTexture() const { return m_DrawBloomPass->GaussianTexture(); }
 
 private:
 	void InitializeTexture();
@@ -54,7 +40,6 @@ private:
 	Model* m_ScreenQuad;
 
 	const IRenderer* m_Renderer;
-	ConfigFile* m_Config;
 
 	float m_Radius;
 	float m_Bias;
@@ -62,11 +47,6 @@ private:
 	float m_IntensityScale;
 	int m_NumOfSamples;
 	int m_NumOfTurns;
-	int m_Iterations;
-	int m_TextureQuality;
-	int m_Quality = 0;
-
-	Texture* m_WhiteTexture;
 
 	GLuint m_SSAOTexture;
 	FrameBuffer m_SSAOFramBuffer;
@@ -74,16 +54,10 @@ private:
 	GLuint m_SSAOViewSpaceZTexture;
 	FrameBuffer m_SSAOViewSpaceZFramBuffer;
 
-	GLuint m_GaussianTexture_horiz;
-	GLuint m_GaussianTexture_vert;
-
-	FrameBuffer m_GaussianFrameBuffer_horiz;
-	FrameBuffer m_GaussianFrameBuffer_vert;
-
 	ShaderProgram* m_SSAOProgram;
 	ShaderProgram* m_SSAOViewSpaceZProgram;
-	ShaderProgram* m_GaussianProgram_horiz;
-	ShaderProgram* m_GaussianProgram_vert;
+
+	DrawBloomPass* m_DrawBloomPass;
 };
 
 #endif

resources/DefaultConfig.ini

@@ -36,37 +36,4 @@ ResourceLoading=true
 [Sound]
 BGMVolume=1.0
 SFXVolume=1.0
-Announcer=female
-
-[SSAO]
-Quality=0
-
-[SSAO1]
-Radius=1.0
-Bias=0.02
-Contrast=1.5
-Intensity=1.0
-NumSamples=8
-NumTurns=3
-NumIterations=5
-TextureQuality=2
-
-[SSAO2]
-Radius=1.0
-Bias=0.02
-Contrast=1.5
-Intensity=1.0
-NumSamples=16
-NumTurns=13
-NumIterations=9
-TextureQuality=1
-
-[SSAO3]
-Radius=1.0
-Bias=0.02
-Contrast=1.5
-Intensity=1.0
-NumSamples=24
-NumTurns=17
-NumIterations=13
-TextureQuality=0
+Announcer=female

resources/Schema/Components/Physics.xml

@@ -2,7 +2,6 @@
 <Physics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Physics.xsd">
 	<Velocity X="0" Y="0" Z="0"/>
 	<Gravity>true</Gravity>
-	<PrevOrigin X="-9876.5" Y="-9876.5" Z="-9876.5"/>
 	<IsOnGround>false</IsOnGround>
 	<VerticalStepHeight>0.33</VerticalStepHeight>
 </Physics>

resources/Schema/Components/Physics.xsd

@@ -13,7 +13,6 @@
 					<xs:annotation><xs:documentation>m/s^2</xs:documentation></xs:annotation>
 				</xs:element>
 				<xs:element name="Gravity" type="t:bool" minOccurs="0"/>
-				<xs:element name="PrevOrigin" type="t:Vector" minOccurs="0"/>
 				<xs:element name="IsOnGround" type="t:bool" minOccurs="0"/>
 				<xs:element name="VerticalStepHeight" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>The largest height of a "stair-step" that can be walked over</xs:documentation></xs:annotation>

resources/Schema/Entities/Empty.xml

@@ -5,6 +5,20 @@
     <c:Transform/>
   </Components>
 
-  <Children/>
+  <Children>
+    <Entity>
+      <Components>
+        <c:Transform/>
+      </Components>
+      <Children>
+        <Entity>
+          <Components>
+            <c:Transform/>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
 
 </Entity>

resources/Schema/Entities/Player.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Schema/Entities/PlayerRed.xml

@@ -13,7 +13,6 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
-      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Shaders/ForwardPlus.frag.glsl

@@ -13,7 +13,6 @@ uniform vec4 AmbientColor;
 uniform float FillPercentage;
 uniform float GlowIntensity = 10;
 uniform vec3 CameraPosition;
-uniform int SSAOQuality;
 
 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
@@ -126,7 +125,7 @@ vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textu
 
 void main()
 {
-	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy), 0).r;
 	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
 	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
 	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);

resources/Shaders/ForwardPlusSplatMapRGB.frag.glsl

@@ -11,7 +11,6 @@ uniform vec4 DiffuseColor;
 uniform vec4 FillColor;
 uniform vec4 Color;
 uniform vec4 AmbientColor;
-uniform int SSAOQuality;
 
 //Get bineded at the same time as the textures
 uniform vec2 DiffuseUVRepeat1;
@@ -178,7 +177,7 @@ vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
 
 void main()
 {
-	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy), 0).r;
 	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
 
 	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);

resources/Shaders/SSAO.frag.glsl

@@ -2,11 +2,11 @@
 
 //Number of samples per pixel
 uniform int           uNumOfSamples;
-//#define uNumOfSamples (11)
+//#define NUM_SAMPLES (11)
 
 //Number of turns around the cirle
 uniform int           uNumOfTurns;
-//#define uNumOfTurns (7)
+//#define NUM_TURNS (7)
 
 layout (binding = 0) uniform sampler2D ViewSpaceZ;
 
@@ -16,16 +16,15 @@ uniform float           uProjScale;
 //#define ProjScale 500
 
 uniform float           uRadius;
-//#define uRadius 1.0f
+//#define Radius 1.0f
 
 uniform float           uBias;
-//#define uBias 0.05f
+//#define Bias 0.012f
 
 uniform float           uContrast;
-//#define uContrast 1.5f
+//#define IntensityDivR6 1
 
 uniform float           uIntensityScale;
-//#define uIntensityScale 1.0f
 
 out float				AO;
 
@@ -89,7 +88,13 @@ void main() {
 
 	vec3 origin = getVSPosition(originScreenCoord);
 
-	float radius = min(origin.z, uRadius);
+	float radius;
+	if(origin.z < uRadius){
+		radius = origin.z;
+	} else {
+		radius = uRadius;
+	}
+
 
 	vec3 originNormal = getVSFaceNormal(origin);
 

resources/Shaders/SSAO.vert.glsl

@@ -2,12 +2,7 @@
 
 layout (location = 0) in vec3 Position;
 
-out VertexData{
-	vec2 TextureCoordinate;
-}Output;
-
 void main()
 {
 	gl_Position = vec4(Position, 1.0);
-	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
 }

resources/Shaders/SSAOViewSpaceZ.frag.glsl

@@ -3,15 +3,11 @@
 layout (binding = 0) uniform sampler2D DepthBuffer;
 uniform vec3 ClipInfo;
 
-in VertexData{
-	vec2 TextureCoordinate;
-}Input;
-
 out float depthLinear;
 //Just for Debug, should be depthLinear
 //out vec4 fragmentColor;
 void main() {
-	float depthSample = texture2D(DepthBuffer, Input.TextureCoordinate).r;
+	float depthSample = texelFetch(DepthBuffer, ivec2(gl_FragCoord.xy), 0).r;
 	depthLinear = ClipInfo[0] / (ClipInfo[1] * depthSample + ClipInfo[2]);
 	//float depthLinear = (NearClip) / ( -depthSample + 1.0f);
 	//fragmentColor = vec4(depthLinear, depthLinear, depthLinear, 1.0f);

src/Engine/Collision/CollisionSystem.cpp

@@ -16,51 +16,51 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    glm::vec3 size = boxA.Size();
-    float diameter = std::min(size.x, size.z);
-    glm::vec3 prevOrigin = (glm::vec3)cPhysics["PrevOrigin"];
-    glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
-    float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
-    //If the entity has moved farther than the size of its box, we need to handle it specially.
-    bool traceCollision = rayLength > diameter;
-    //hack solution: If prevOrigin is less than -9000 in all dimensions, 
-    //then it means it is not set, i.e. this is the first collision check for the entity.
-    if (traceCollision && glm::any(glm::greaterThan((glm::vec3)cPhysics["PrevOrigin"], glm::vec3(-9000.f)))) {
-        Ray ray(prevOrigin, toCurrentPos);
-        m_OctreeResult.clear();
-        m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
-        for (auto& boxB : m_OctreeResult) {
-            if (boxA.Entity == boxB.Entity) {
-                continue;
-            }
-            bool hit;
-            float dist;
-            if (boxB.Entity.HasComponent("Model")) {
-                RawModel* model;
-                std::string res = (std::string)boxB.Entity["Model"]["Resource"];
-                try {
-                    model = ResourceManager::Load<RawModel, true>(res);
-                } catch (const std::exception&) {
+    auto prevPosIt = m_PrevPositions.find(entity);
+    if (prevPosIt != m_PrevPositions.end()) {
+        glm::vec3 size = boxA.Size();
+        float diameter = std::min(size.x, size.z);
+        glm::vec3 prevOrigin = prevPosIt->second;
+        glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
+        float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
+        //If the entity has moved farther than the size of its box, we need to handle it specially.
+        if (rayLength > diameter) {
+            Ray ray(prevOrigin, toCurrentPos);
+            m_OctreeResult.clear();
+            m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
+            for (auto& boxB : m_OctreeResult) {
+                if (boxA.Entity == boxB.Entity) {
                     continue;
                 }
-                float u, v;
-                hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
-            } else {
-                hit = Collision::RayVsAABB(ray, boxB, dist);
-            }
-            if (hit && dist < rayLength) {
-                //Set the entity to where it was colliding, minus the maximum box size. 
-                //TODO: Perhaps this should be done slightly more properly.
-                glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
-                glm::vec3 resolve = newOriginPos - boxA.Origin();
-                (glm::vec3&)cTransform["Position"] += resolve;
-                boxA = *Collision::EntityAbsoluteAABB(entity);
-                if (resolve.y > 0) {
-                    everHitTheGround = true;
-                    (bool)cPhysics["IsOnGround"] = true;
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                bool hit;
+                float dist;
+                if (boxB.Entity.HasComponent("Model")) {
+                    RawModel* model;
+                    std::string res = (std::string)boxB.Entity["Model"]["Resource"];
+                    try {
+                        model = ResourceManager::Load<RawModel, true>(res);
+                    } catch (const std::exception&) {
+                        continue;
+                    }
+                    float u, v;
+                    hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                } else {
+                    hit = Collision::RayVsAABB(ray, boxB, dist);
+                }
+                if (hit && dist < rayLength) {
+                    //Set the entity to where it was colliding, minus the maximum box size. 
+                    //TODO: Perhaps this should be done slightly more properly.
+                    glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
+                    glm::vec3 resolve = newOriginPos - boxA.Origin();
+                    (glm::vec3&)cTransform["Position"] += resolve;
+                    boxA = *Collision::EntityAbsoluteAABB(entity);
+                    if (resolve.y > 0) {
+                        everHitTheGround = true;
+                        (bool)cPhysics["IsOnGround"] = true;
+                        ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                    }
+                    break;
                 }
-                break;
             }
         }
     }
@@ -90,6 +90,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
             if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
+                boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {
                     everHitTheGround = true;
@@ -99,6 +100,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
+            boxA = *Collision::EntityAbsoluteAABB(entity);
             if (resolutionVector.y > 0) {
                 everHitTheGround = true;
                 (bool)cPhysics["IsOnGround"] = true;
@@ -112,5 +114,5 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         (bool)cPhysics["IsOnGround"] = false;
     }
 
-    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
+    m_PrevPositions[entity] = boxA.Origin();
 }

src/Engine/Core/ComponentPool.cpp

@@ -112,6 +112,11 @@ size_t ComponentPool::size() const
     return m_Pool.size();
 }
 
+std::size_t ComponentPool::MemoryUsage() const
+{
+    return m_Pool.MemoryUsage();
+}
+
 template <typename InterpretType /*= char*/>
 void ComponentPool::Dump() const
 {

src/Engine/Core/EntityWrapper.cpp

@@ -34,6 +34,15 @@ EntityWrapper EntityWrapper::Parent()
     }
 }
 
+EntityWrapper EntityWrapper::BaseParent()
+{
+    EntityWrapper baseParent = Parent();
+    while (baseParent.Parent().Valid()) {
+        baseParent = baseParent.Parent();
+    }
+    return baseParent;
+}
+
 EntityWrapper EntityWrapper::FirstChildByName(const std::string& name)
 {
     return firstChildByNameRecursive(name, this->ID);
@@ -51,6 +60,17 @@ EntityWrapper EntityWrapper::FirstParentWithComponent(const std::string& compone
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::Clone(EntityWrapper parent /*= Invalid*/)
+{
+    if (!Valid()) {
+        return EntityWrapper::Invalid;
+    }
+
+    EntityWrapper clone = cloneRecursive(*this, EntityWrapper::Invalid);
+    this->World->SetParent(clone.ID, parent.ID);
+    return clone;
+}
+
 bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
 {
     EntityWrapper entity = *this;
@@ -111,7 +131,7 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
         return EntityWrapper::Invalid;
     }
 
-    auto itPair = this->World->GetChildren(parent);
+    auto itPair = this->World->GetDirectChildren(parent);
     if (itPair.first == itPair.second) {
         return EntityWrapper::Invalid;
     }
@@ -131,3 +151,27 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::cloneRecursive(EntityWrapper entity, EntityWrapper parent)
+{
+    EntityWrapper clone = EntityWrapper(entity.World, entity.World->CreateEntity(parent.ID));
+    entity.World->SetName(clone.ID, entity.Name());
+
+    // Clone components
+    for (auto& kv : entity.World->GetComponentPools()) {
+        if (kv.second->KnowsEntity(entity.ID)) {
+            ComponentWrapper c1 = kv.second->GetByEntity(entity.ID);
+            ComponentWrapper c2 = entity.World->AttachComponent(clone.ID, kv.first);
+            c1.Copy(c2);
+        }
+    }
+
+    // Clone children
+    auto children = entity.World->GetDirectChildren(entity.ID);
+    for (auto it = children.first; it != children.second; ++it) {
+        EntityWrapper child(entity.World, it->second);
+        cloneRecursive(child, clone);
+    }
+      
+    return clone;
+}
+

src/Engine/Core/World.cpp

@@ -127,7 +127,7 @@ void World::SetParent(EntityID entity, EntityID parent)
     m_EntityChildren.insert(std::make_pair(parent, entity));
 }
 
-const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetChildren(EntityID entity)
+const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetDirectChildren(EntityID entity)
 {
     return m_EntityChildren.equal_range(entity);
 }
@@ -151,6 +151,17 @@ std::string World::GetName(EntityID entity) const
     }
 }
 
+std::size_t World::MemoryUsage() const
+{
+    std::size_t mem = 0;
+
+    for (auto& kv : m_ComponentPools) {
+        mem += kv.second->MemoryUsage();
+    }
+
+    return mem;
+}
+
 EntityID World::generateEntityID()
 {
     // TODO: Make EntityID generation smarter

src/Engine/Editor/EditorGUI.cpp

@@ -598,6 +598,28 @@ bool EditorGUI::OnKeyDown(const Events::KeyDown& e)
         entityImport(m_World);
     }
 
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_C) {
+        m_CopyTarget = m_CurrentSelection;
+    }
+
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_Z) {
+        if (m_OnUndo != nullptr) {
+            m_OnUndo();
+            if (!m_CurrentSelection.Valid()) {
+                SelectEntity(EntityWrapper::Invalid);
+            }
+        }
+    }
+
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_V) {
+        if (m_OnEntityPaste != nullptr) {
+            EntityWrapper copy = m_OnEntityPaste(m_CopyTarget, m_CurrentSelection);
+            if (copy != EntityWrapper::Invalid) {
+                SelectEntity(copy);
+            }
+        }
+    }
+
     if (e.KeyCode == GLFW_KEY_DELETE) {
         if (m_CurrentSelection.Valid()) {
             entityDelete(m_CurrentSelection);
@@ -761,13 +783,13 @@ bool EditorGUI::compareCharArray(const char* c1, const char* c2)
 
 void EditorGUI::SetDirty(EntityWrapper entity)
 {
-    EntityWrapper baseParent = entity;
-    while (baseParent.Parent().Valid()) {
-        baseParent = baseParent.Parent();
-    }
+    EntityWrapper baseParent = entity.BaseParent();
     if (m_EntityFiles.find(baseParent) != m_EntityFiles.end()) {
         m_EntityFiles.at(baseParent).Dirty = true;
     }
+    if (m_OnDirty != nullptr) {
+        m_OnDirty(entity);
+    }
 }
 
 void EditorGUI::entityImport(World* world)
@@ -817,6 +839,7 @@ void EditorGUI::entityCreate(World* world, EntityWrapper parent)
             parent.World = world;
         }
         EntityWrapper newEntity = m_OnEntityCreate(parent);
+        SetDirty(newEntity);
         SelectEntity(newEntity);
     }
 }
@@ -832,9 +855,9 @@ void EditorGUI::entityDelete(EntityWrapper entity)
         if (boost::any_cast<EntityWrapper>(m_ModalData[modalName]) == entity) {
             EntityWrapper parent = entity.Parent();
             if (m_OnEntityDelete != nullptr) {
-                SetDirty(entity);
                 m_OnEntityDelete(entity);
                 m_EntityFiles.erase(entity);
+                SetDirty(parent);
             }
             if (!m_CurrentSelection.Valid()) {
                 SelectEntity(parent);
@@ -851,8 +874,8 @@ void EditorGUI::entityChangeParent(EntityWrapper entity, EntityWrapper parent)
     }
 
     if (m_OnEntityChangeParent != nullptr) {
-        SetDirty(entity);
         m_OnEntityChangeParent(entity, parent);
+        SetDirty(entity);
         LOG_DEBUG("Changed parent of %i to %i", entity.ID, parent.ID);
     }
 }

src/Engine/Editor/EditorSystem.cpp

@@ -28,10 +28,13 @@ EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame
     m_EditorGUI->SetEntityDeleteCallback(std::bind(&EditorSystem::OnEntityDelete, this, std::placeholders::_1));
     m_EditorGUI->SetEntityChangeParentCallback(std::bind(&EditorSystem::OnEntityChangeParent, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetEntityChangeNameCallback(std::bind(&EditorSystem::OnEntityChangeName, this, std::placeholders::_1, std::placeholders::_2));
+    m_EditorGUI->SetEntityPasteCallback(std::bind(&EditorSystem::OnEntityPaste, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentAttachCallback(std::bind(&EditorSystem::OnComponentAttach, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentDeleteCallback(std::bind(&EditorSystem::OnComponentDelete, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetWidgetModeCallback(std::bind(&EditorSystem::setWidgetMode, this, std::placeholders::_1));
     m_EditorGUI->SetWidgetSpaceCallback(std::bind(&EditorSystem::OnWidgetSpace, this, std::placeholders::_1));
+    m_EditorGUI->SetDirtyCallback(std::bind(&EditorSystem::OnDirty, this, std::placeholders::_1));
+    m_EditorGUI->SetUndoCallback(std::bind(&EditorSystem::OnUndo, this));
 
     EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &EditorSystem::OnMousePress);
     EVENT_SUBSCRIBE_MEMBER(m_EWidgetDelta, &EditorSystem::OnWidgetDelta);
@@ -86,6 +89,11 @@ void EditorSystem::Update(double dt)
         glm::vec3& pos = cameraTransform["Position"];
         pos += m_EditorCameraInputController->Movement() * glm::inverse(glm::quat(ori)) * (float)actualDelta;
     }
+
+    if (m_SaveUndoLevel) {
+        m_UndoLevels.push_back(*m_World);
+        m_SaveUndoLevel = false;
+    }
 }
 
 void EditorSystem::Enable()
@@ -160,6 +168,11 @@ void EditorSystem::OnEntityChangeName(EntityWrapper entity, const std::string& n
     }
 }
 
+EntityWrapper EditorSystem::OnEntityPaste(EntityWrapper entityToCopy, EntityWrapper parent)
+{
+    return entityToCopy.Clone(parent);
+}
+
 void EditorSystem::OnComponentAttach(EntityWrapper entity, const std::string& componentType)
 {
     if (entity.Valid()) {
@@ -179,6 +192,19 @@ void EditorSystem::OnWidgetSpace(EditorGUI::WidgetSpace widgetSpace)
     m_WidgetSpace = widgetSpace;
 }
 
+void EditorSystem::OnDirty(EntityWrapper entity)
+{
+    m_SaveUndoLevel = true;
+}
+
+void EditorSystem::OnUndo()
+{
+    // The last "undo level" is always the most recent change
+    if (m_UndoLevels.size() >= 2) {
+        *m_World = m_UndoLevels.at(m_UndoLevels.size() - 2);
+    }
+}
+
 bool EditorSystem::OnMousePress(const Events::MousePress& e)
 {
     ImGuiIO& io = ImGui::GetIO();

src/Engine/Network/Client.cpp

@@ -261,8 +261,14 @@ void Client::parseEntityDeletion(Packet & packet)
     if (m_ServerIDToClientID.find(entityToDelete) != m_ServerIDToClientID.end()) {
         EntityID localEntity = m_ServerIDToClientID.at(entityToDelete);
         if (m_World->ValidEntity(localEntity)) {
-            m_World->DeleteEntity(localEntity);
-            deleteFromServerClientMaps(entityToDelete, localEntity);
+            if (m_World->HasComponent(localEntity,"Player")) {
+                Events::PlayerDeath e;
+                e.Player = EntityWrapper(m_World, localEntity);
+                m_EventBroker->Publish(e);
+            } else {
+                m_World->DeleteEntity(localEntity);
+                deleteFromServerClientMaps(entityToDelete, localEntity);
+            }
         }
     }
 }

src/Engine/Network/Server.cpp

@@ -186,7 +186,7 @@ void Server::addInputCommandsToPacket(Packet& packet)
 
 void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -234,7 +234,7 @@ void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 
 void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -601,7 +601,7 @@ void Server::parsePlayerTransform(Packet& packet)
 
 bool Server::shouldSendToClient(EntityWrapper childEntity)
 {
-    auto children = m_World->GetChildren(childEntity.ID);
+    auto children = m_World->GetDirectChildren(childEntity.ID);
     for (auto it = children.first; it != children.second; it++) {
         EntityWrapper child(m_World, it->second);
         if(child.HasComponent("CapturePoint")) {

src/Engine/Rendering/CubeMapPass.cpp

@@ -17,7 +17,7 @@ void CubeMapPass::LoadTextures(std::string input)
             m_CubeMapTextures.push_back(img);
         }
         GenerateCubeMapTexture();
-		m_PreviusCubeMapTexture = input;
+        m_PreviusCubeMapTexture = input;
     }
 }
 

src/Engine/Rendering/DrawBloomPass.cpp

@@ -1,42 +1,19 @@
 #include "Rendering/DrawBloomPass.h"
 
-DrawBloomPass::DrawBloomPass(IRenderer* renderer, ConfigFile* config)
-	: m_Renderer(renderer)
-	, m_Config(config)
+DrawBloomPass::DrawBloomPass(IRenderer* renderer)
 {
-	InitializeTextures();
+    m_Renderer = renderer;
 
-	ChangeQuality(m_Config->Get<int>("GLOW.Quality", 2));
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+
+    InitializeTextures();
+    InitializeBuffers();
+    InitializeShaderPrograms();
 }
 
 void DrawBloomPass::InitializeTextures()
 {
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
-}
-
-void DrawBloomPass::ChangeQuality(int quality)
-{
-	if (m_Quality == quality) {
-		return;
-	}
-	m_Quality = quality;
-
-	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
-
-	if (m_Quality == 0) {
-		glDeleteTextures(1, &m_GaussianTexture_horiz);
-		glDeleteTextures(1, &m_GaussianTexture_vert);
-		return;
-	}
-
-	InitializeTextures();
-	InitializeBuffers();
-	InitializeShaderPrograms();
-	std::string qStr = std::to_string(m_Quality);
-	m_Iterations = m_Config->Get<float>("GLOW" + qStr + ".NumIterations", 0);
-
-	InitializeBuffers();
-	InitializeShaderPrograms();
+    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
 }
 
 void DrawBloomPass::InitializeShaderPrograms()
@@ -63,25 +40,18 @@ void DrawBloomPass::InitializeBuffers()
 {
     GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
-	if (m_GaussianFrameBuffer_horiz.GetHandle() == 0) {
-		m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
-	}
-	m_GaussianFrameBuffer_horiz.Generate();
+    m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_horiz.Generate();
 
     GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
 
-	if (m_GaussianFrameBuffer_vert.GetHandle() == 0) {
-		m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
-	}
-	m_GaussianFrameBuffer_vert.Generate();
+    m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_vert.Generate();
 }
 
 
 void DrawBloomPass::ClearBuffer()
 {
-	if (m_Quality == 0) {
-		return;
-	}
     GLERROR("PRE");
     m_GaussianFrameBuffer_horiz.Bind();
     glClearColor(0.f, 0.f, 0.f, 0.f);
@@ -96,9 +66,6 @@ void DrawBloomPass::ClearBuffer()
 
 void DrawBloomPass::Draw(GLuint texture)
 {
-	if (m_Quality == 0) {
-		return;
-	}
     GLERROR("DrawBloomPass::Draw: Pre");
 
     DrawBloomPassState state;
@@ -117,7 +84,7 @@ void DrawBloomPass::Draw(GLuint texture)
     glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex +1
         , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
     //Iterate some times to make it more gaussian.
-    for (int i = 1; i < m_Iterations; i++) {
+    for (int i = 1; i < m_iterations; i++) {
         //Vertical pass
         m_GaussianFrameBuffer_vert.Bind();
         m_GaussianProgram_vert->Bind();
@@ -158,9 +125,6 @@ void DrawBloomPass::Draw(GLuint texture)
 
 void DrawBloomPass::OnWindowResize()
 {
-	if (m_Quality == 0) {
-		return;
-	}
     GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     m_GaussianFrameBuffer_vert.Generate();
     GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
@@ -169,7 +133,6 @@ void DrawBloomPass::OnWindowResize()
 
 void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
-	glDeleteTextures(1, texture);
     glGenTextures(1, texture);
     glBindTexture(GL_TEXTURE_2D, *texture);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -1,9 +1,9 @@
 #include "Rendering/DrawFinalPass.h"
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass)
-	: m_Renderer(renderer)
-	, m_LightCullingPass(lightCullingPass)
-	, m_CubeMapPass(cubeMapPass)
-	, m_SSAOPass(ssaoPass)
+
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass)
+    : m_Renderer(renderer)
+    , m_LightCullingPass(lightCullingPass)
+    , m_CubeMapPass(cubeMapPass)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
     m_ShieldPixelRate = 8;
@@ -162,20 +162,20 @@ void DrawFinalPass::InitializeShaderPrograms()
 
     m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
-   // m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferProgram->Compile();
     m_FillDepthBufferProgram->Link();
     GLERROR("Creating DepthFill program");
 
     m_FillDepthBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
     m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
-   // m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferSkinnedProgram->Compile();
     m_FillDepthBufferSkinnedProgram->Link();
     GLERROR("Creating DepthFill program");
 }
 
-void DrawFinalPass::Draw(RenderScene& scene)
+void DrawFinalPass::Draw(RenderScene& scene, GLuint SSAOTexture)
 {
     GLERROR("Pre");
     DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
@@ -191,10 +191,10 @@ void DrawFinalPass::Draw(RenderScene& scene)
     //Fill depth buffer
 	
     state->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
     GLERROR("OpaqueObjects");
     state->BlendFunc(GL_ONE, GL_ONE);
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
     GLERROR("TransparentObjects");
     state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     DrawSprites(scene.Jobs.SpriteJob, scene);
@@ -210,11 +210,11 @@ void DrawFinalPass::Draw(RenderScene& scene)
     //Draw Opaque shielded objects
     state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
     state->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
+    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene, SSAOTexture); //might need changing
     GLERROR("Shielded Opaque object");
 
     //Draw Transparen Shielded objects
-    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
+    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene, SSAOTexture); //might need changing
     GLERROR("Shielded Transparent objects");
 
     GLERROR("END");
@@ -250,9 +250,9 @@ void DrawFinalPass::Draw(RenderScene& scene)
     stateLowRes->Enable(GL_DEPTH_TEST);
     stateLowRes->StencilFunc(GL_LEQUAL, 1, 0xFF);
     stateLowRes->StencilMask(0x00);
-    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene, SSAOTexture);
     GLERROR("OpaqueObjects");
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene, SSAOTexture);
     GLERROR("TransparentObjects");
     glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
@@ -340,7 +340,7 @@ void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm:
     GLERROR("MipMap Texture initialization failed");
 }
 
-void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
+void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene, GLuint SSAOTexture)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
     GLERROR("forwardHandle");
@@ -364,7 +364,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
 	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, m_SSAOPass->SSAOTexture());
+	glBindTexture(GL_TEXTURE_2D, SSAOTexture);
 
     for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
@@ -383,7 +383,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
                     glActiveTexture(GL_TEXTURE5);
                     glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                    glUniform3fv(glGetUniformLocation(explosionSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                     std::vector<glm::mat4> frameBones;
                     if (explosionEffectJob->AnimationOffset.animation != nullptr) {
@@ -401,7 +401,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                     BindExplosionTextures(explosionHandle, explosionEffectJob);
                     glActiveTexture(GL_TEXTURE5);
                     glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                    glUniform3fv(glGetUniformLocation(explosionHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                    glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                 }
                 break;
@@ -463,7 +463,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                             BindModelTextures(forwardSkinnedHandle, modelJob);
                             glActiveTexture(GL_TEXTURE5);
                             glBindTexture(GL_TEXTURE_CUBE_MAP, m_CubeMapPass->m_CubeMapTexture);
-                            glUniform3fv(glGetUniformLocation(forwardSkinnedHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
+                            glUniform3fv(glGetUniformLocation(forwardHandle, "CameraPosition"), 1, glm::value_ptr(scene.Camera->Position()));
 
                             std::vector<glm::mat4> frameBones;
                             if (modelJob->AnimationOffset.animation != nullptr) {
@@ -753,7 +753,6 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
 
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
-	glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 	GLERROR("Bind 1 uniform");
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));
 	GLERROR("Bind 2 uniform");
@@ -802,7 +801,6 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 
 void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene)
 {
-	glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
 	GLERROR("Bind 1 uniform");
 	GLint Location_M = glGetUniformLocation(shaderHandle, "M");
 	glUniformMatrix4fv(Location_M, 1, GL_FALSE, glm::value_ptr(job->Matrix));

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -9,7 +9,6 @@ DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-	glDepthFunc(GL_LEQUAL);
     Enable(GL_STENCIL_TEST);
     StencilFunc(GL_NOTEQUAL, 1, 0xFF);
     StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

src/Engine/Rendering/FrameBuffer.cpp

@@ -42,33 +42,33 @@ void FrameBuffer::Generate()
     GLERROR("PRE");
 
     std::vector<GLenum> attachments;
-	if (m_BufferHandle == 0) {
-		glGenFramebuffers(1, &m_BufferHandle);
-	}
+
+    glGenFramebuffers(1, &m_BufferHandle);
     glBindFramebuffer(GL_FRAMEBUFFER, m_BufferHandle);
     GLERROR("1");
 
-	for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
-		switch ((*it)->m_ResourceType) {
-		case GL_TEXTURE_2D:
-			glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
-			GLERROR("FrameBuffer generate: glFramebufferTexture2D");
+    for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
+        switch ((*it)->m_ResourceType) {
+        case GL_TEXTURE_2D:
+            glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
+            GLERROR("FrameBuffer generate: glFramebufferTexture2D");
 
-			break;
-		case GL_RENDERBUFFER:
-			glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
-			GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
-			break;
-		}
-		GLERROR("2");
+            break;
+        case GL_RENDERBUFFER:
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
+            GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
+            break;
+        }
+        GLERROR("2");
 
-		if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
-			attachments.push_back((*it)->m_Attachment);
-		}
-		GLERROR("Attachment");
+        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
+            attachments.push_back((*it)->m_Attachment);
+        }
+        GLERROR("Attachment");
+
+    }
+    GLERROR("3");
 
-	}
-	GLERROR("3");
 
     GLenum* bufferTextures = &attachments[0];
     glDrawBuffers(attachments.size(), bufferTextures);

src/Engine/Rendering/Renderer.cpp

@@ -4,8 +4,6 @@ std::unordered_map<GLFWwindow*, Renderer*> Renderer::m_WindowToRenderer;
 
 void Renderer::Initialize()
 {
-	m_SSAO_Quality = m_Config->Get<int>("SSAO.Quality", 0);
-	m_GLOW_Quality = m_Config->Get<int>("GLOW.Quality", 0);
 	InitializeWindow();
     
     InitializeRenderPasses();
@@ -109,7 +107,6 @@ void Renderer::Update(double dt)
 void Renderer::Draw(RenderFrame& frame)
 {
     GLERROR("PRE");
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
     ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
     ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
     if(m_CubeMapTexture == 0) {
@@ -118,16 +115,19 @@ void Renderer::Draw(RenderFrame& frame)
         m_CubeMapPass->LoadTextures("Sky");
     }
 
-	ImGui::SliderInt("SSAO Quality", &m_SSAO_Quality, 0, 3);
-	ImGui::SliderInt("Glow Quality", &m_GLOW_Quality, 0, 3);
-	m_SSAOPass->ChangeQuality(m_SSAO_Quality);
-	m_DrawBloomPass->ChangeQuality(m_GLOW_Quality);
+	ImGui::SliderFloat("SSAO sample radius", &m_SSAO_Radius, 0.01f, 5.0f);
+	ImGui::SliderFloat("SSAO bias", &m_SSAO_Bias, 0.0f, 0.1f);
+	ImGui::SliderFloat("SSAO contrast", &m_SSAO_Contrast, 0.0f, 10.0f);
+	ImGui::SliderFloat("SSAO IntensityScale", &m_SSAO_IntensityScale, 0.0f, 10.0f);
+	ImGui::SliderInt("SSAO Number of Samples", &m_SSAO_NumOfSamples, 2, 100);
+	ImGui::SliderInt("SSAO Number of Turns", &m_SSAO_NumOfTurns, 0, 50);
+	m_SSAOPass->Setting(m_SSAO_Radius, m_SSAO_Bias, m_SSAO_Contrast, m_SSAO_IntensityScale, m_SSAO_NumOfSamples, m_SSAO_NumOfTurns);
     GLERROR("SSAO Settings");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    //Clear other buffers 
+    //Clear other buffers
     PerformanceTimer::StartTimer("Renderer-ClearBuffers");
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
@@ -141,10 +141,10 @@ void Renderer::Draw(RenderFrame& frame)
 		GLERROR("Drawing pickingpass");
 		PerformanceTimer::StopTimer("Renderer-Depth");
 	}
-	PerformanceTimer::StartTimer("Renderer-AO generation");
+	PerformanceTimer::StartTimer("AO generation");
 	m_SSAOPass->Draw(m_PickingPass->DepthBuffer(), frame.RenderScenes.front()->Camera);
 	GLuint ao = m_SSAOPass->SSAOTexture();
-	PerformanceTimer::StopTimer("Renderer-AO generation");
+	PerformanceTimer::StopTimer("AO generation");
     for (auto scene : frame.RenderScenes){
         
         PerformanceTimer::StartTimer("Renderer-Drawing PickingPass");
@@ -159,7 +159,7 @@ void Renderer::Draw(RenderFrame& frame)
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Light Culling");
         m_LightCullingPass->CullLights(*scene);
         GLERROR("LightCulling");
-		m_DrawFinalPass->Draw(*scene);
+		m_DrawFinalPass->Draw(*scene, ao);
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
         GLERROR("Draw Geometry+Light");
         //m_DrawScenePass->Draw(*scene);
@@ -248,10 +248,9 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_CubeMapPass = new CubeMapPass(this);
-	m_SSAOPass = new SSAOPass(this, m_Config);
-    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass);
+    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
-    m_DrawBloomPass = new DrawBloomPass(this, m_Config);
+    m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
-  
+    m_SSAOPass = new SSAOPass(this);
 }

src/Engine/Rendering/SSAOPass.cpp

@@ -1,130 +1,50 @@
 #include "Rendering/SSAOPass.h"
 
-SSAOPass::SSAOPass(IRenderer* renderer, ConfigFile* config)
-	: m_Renderer(renderer)
-	, m_Config(config)
+SSAOPass::SSAOPass(IRenderer* renderer)
 {
-	m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
-
-	ChangeQuality(m_Config->Get<int>("SSAO.Quality", 0));
-}
-
-void SSAOPass::ChangeQuality(int quality)
-{
-	if (m_Quality == quality) {
-		return;
-	}
-
-	m_Quality = quality;
-
-	if (m_Quality == 0) {	
-		glDeleteTextures(1, &m_SSAOTexture);
-		glDeleteTextures(1, &m_SSAOViewSpaceZTexture);
-		glDeleteTextures(1, &m_GaussianTexture_horiz);
-		glDeleteTextures(1, &m_GaussianTexture_vert);
-		return;
-	}
-
-	std::string qStr = std::to_string(m_Quality);
-	Setting(
-		m_Config->Get<float>("SSAO" + qStr + ".Radius", 0.01),
-		m_Config->Get<float>("SSAO" + qStr + ".Bias", 0.012),
-		m_Config->Get<float>("SSAO" + qStr + ".Contrast", 1.0),
-		m_Config->Get<float>("SSAO" + qStr + ".Intensity", 1.0),
-		m_Config->Get<int>("SSAO" + qStr + ".NumSamples", 0),
-		m_Config->Get<int>("SSAO" + qStr + ".NumTurns", 0),
-		m_Config->Get<int>("SSAO" + qStr + ".NumIterations", 0),
-		m_Config->Get<int>("SSAO" + qStr + ".TextureQuality", 4)
-		);
-
-
+	m_Renderer = renderer;
 
 	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
 	InitializeTexture();
 	InitializeBuffer();
 	InitializeShaderProgram();
+	Setting(0.1f, 0.012f, 1.0f, 1.0f, 13, 7);
 
-
+	m_DrawBloomPass = new DrawBloomPass(renderer);
 }
 
 void SSAOPass::InitializeShaderProgram()
 {
 	m_SSAOProgram = ResourceManager::Load<ShaderProgram>("##SSAOProgram");
-	if (m_SSAOProgram->GetHandle() == 0) {
-		m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
-		m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAO.frag.glsl")));
-		m_SSAOProgram->Compile();
-		m_SSAOProgram->Link();
-	}
+	m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
+	m_SSAOProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAO.frag.glsl")));
+	m_SSAOProgram->Compile();
+	m_SSAOProgram->Link();
 
 	m_SSAOViewSpaceZProgram = ResourceManager::Load<ShaderProgram>("##SSAOViewSpaceZProgram");
-	if (m_SSAOViewSpaceZProgram->GetHandle() == 0) {
-		m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
-		m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAOViewSpaceZ.frag.glsl")));
-		m_SSAOViewSpaceZProgram->Compile();
-		m_SSAOViewSpaceZProgram->Link();
-	}
-
-	m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
-	if (m_GaussianProgram_horiz->GetHandle() == 0) {
-		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
-		m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
-		m_GaussianProgram_horiz->Compile();
-		m_GaussianProgram_horiz->Link();
-	}
-
-	m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
-	if (m_GaussianProgram_vert->GetHandle() == 0) {
-		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
-		m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
-		m_GaussianProgram_vert->Compile();
-		m_GaussianProgram_vert->Link();
-	}
+	m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/SSAO.vert.glsl")));
+	m_SSAOViewSpaceZProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/SSAOViewSpaceZ.frag.glsl")));
+	m_SSAOViewSpaceZProgram->Compile();
+	m_SSAOViewSpaceZProgram->Link();
 }
 
 void SSAOPass::InitializeTexture() {
-	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RED, GL_FLOAT);
-	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R32F, GL_RED, GL_FLOAT);
-
-	GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RGB, GL_FLOAT);
-	GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width >> m_TextureQuality, m_Renderer->GetViewportSize().Height >> m_TextureQuality), GL_R8, GL_RGB, GL_FLOAT);
+	GenerateTexture(&m_SSAOTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R8, GL_RED, GL_FLOAT);
+	GenerateTexture(&m_SSAOViewSpaceZTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_R32F, GL_RED, GL_FLOAT);
 }
 
 void SSAOPass::InitializeBuffer()
 {
-	if (m_SSAOFramBuffer.GetHandle() == 0) {
-		m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
-	}
-		m_SSAOFramBuffer.Generate();
-
-
-	if (m_SSAOViewSpaceZFramBuffer.GetHandle() == 0) {
-		m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
-	}
-		m_SSAOViewSpaceZFramBuffer.Generate();
-
-
-
-	if (m_GaussianFrameBuffer_horiz.GetHandle() == 0) {
-		m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
-	}
-		m_GaussianFrameBuffer_horiz.Generate();
-
-
-	if (m_GaussianFrameBuffer_vert.GetHandle() == 0) {
-		m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
-	}
-		m_GaussianFrameBuffer_vert.Generate();
+	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOFramBuffer.Generate();
 
+	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOViewSpaceZFramBuffer.Generate();
 }
 
 void SSAOPass::ClearBuffer()
 {
-	if (m_Quality == 0) {
-		return;
-	}
-
 	m_SSAOFramBuffer.Bind();
 	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -134,32 +54,19 @@ void SSAOPass::ClearBuffer()
 	glClearColor(1.f, 1.f, 1.f, 1.f);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 	m_SSAOViewSpaceZFramBuffer.Unbind();
-
-	m_GaussianFrameBuffer_horiz.Bind();
-	glClearColor(1.f, 1.f, 1.f, 1.f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	m_GaussianFrameBuffer_horiz.Unbind();
-
-	m_GaussianFrameBuffer_vert.Bind();
-	glClearColor(1.f, 1.f, 1.f, 1.f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	m_GaussianFrameBuffer_vert.Unbind();
 }
 
-void SSAOPass::Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int numOfTurns, int iterations, int quality) {
+void SSAOPass::Setting(float radius, float bias, float contrast, float intensityScale, int numOfSamples, int NumOfTurns) {
 	m_Radius = radius;
 	m_Bias = bias;
 	m_Contrast = contrast;
 	m_IntensityScale = intensityScale;
 	m_NumOfSamples = numOfSamples;
-	m_NumOfTurns = numOfTurns;
-	m_Iterations = iterations;
-	m_TextureQuality = quality;
+	m_NumOfTurns = NumOfTurns;
 }
 
 void SSAOPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
-	glDeleteTextures(1, texture);
 	glGenTextures(1, texture);
 	glBindTexture(GL_TEXTURE_2D, *texture);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
@@ -172,10 +79,6 @@ void SSAOPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filterin
 
 void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 {
-	if (m_Quality == 0) {
-		return;
-	}
-
 	SSAOPassState state;
 	GLuint viewSpaceZPShaderHandle = m_SSAOViewSpaceZProgram->GetHandle();
 	GLuint SSAOShaderHandle = m_SSAOProgram->GetHandle();
@@ -195,7 +98,6 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 		(-1.0f),
 		(+1.0f)
 		);*/
-	glViewport(0, 0, (m_Renderer->GetViewportSize().Width >> m_TextureQuality), (m_Renderer->GetViewportSize().Height >> m_TextureQuality)); //JOHAN TODO: Get this into state
 	glUniform3fv(glGetUniformLocation(viewSpaceZPShaderHandle, "ClipInfo"), 1, glm::value_ptr(clipInfo));
 
 	glBindVertexArray(m_ScreenQuad->VAO);
@@ -205,9 +107,9 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	
 	glm::vec4 projInfo = glm::vec4(
 		((1.0 - camera->ProjectionMatrix()[0][2]) / camera->ProjectionMatrix()[0][0]),
-		(-2.0 / ((m_Renderer->GetViewportSize().Width >> m_TextureQuality) * camera->ProjectionMatrix()[0][0])),
+		(-2.0 / (m_Renderer->GetViewportSize().Width * camera->ProjectionMatrix()[0][0])),
 		((1.0 + camera->ProjectionMatrix()[1][2]) / camera->ProjectionMatrix()[1][1]),
-		(-2.0 / ((m_Renderer->GetViewportSize().Height >> m_TextureQuality) * camera->ProjectionMatrix()[1][1]))
+		(-2.0 / (m_Renderer->GetViewportSize().Height * camera->ProjectionMatrix()[1][1]))
 		);
 
 
@@ -218,76 +120,26 @@ void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
 	glBindTexture(GL_TEXTURE_2D, m_SSAOViewSpaceZTexture);
 
 	// How many pixel there are in a 1m long object 1m away from the camera
-	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uProjScale"), (m_Renderer->GetViewportSize().Height >> m_TextureQuality) / (-2.0f * glm::tan(camera->FOV() * 0.5f)));
+	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uProjScale"), m_Renderer->GetViewportSize().Height / (-2.0f * glm::tan(camera->FOV() * 0.5f)));
 
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uRadius"), m_Radius);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uBias"), m_Bias);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uContrast"), m_Contrast);
 	glUniform1f(glGetUniformLocation(SSAOShaderHandle, "uIntensityScale"), m_IntensityScale);
 	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfSamples"), m_NumOfSamples);
-	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfTurns"), m_NumOfTurns);
+	glUniform1i(glGetUniformLocation(SSAOShaderHandle, "uNumOfTurns"), m_NumOfTurns);;
 
 	glUniform4fv(glGetUniformLocation(SSAOShaderHandle, "uProjInfo"), 1, glm::value_ptr(projInfo));
 	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
 		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
 
-	DrawBloomPassState BloomState;
-	GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
-	GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
-
-	m_GaussianFrameBuffer_horiz.Bind();
-	m_GaussianProgram_horiz->Bind();
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, m_SSAOTexture);
-
-	glBindVertexArray(m_ScreenQuad->VAO);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
-		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
-	//Iterate some times to make it more gaussian.
-	for (int i = 1; i < m_Iterations; i++) {
-		//Vertical pass
-		m_GaussianFrameBuffer_vert.Bind();
-		m_GaussianProgram_vert->Bind();
-
-		glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
-
-		glBindVertexArray(m_ScreenQuad->VAO);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-		glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
-			, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
-		//horizontal pass
-
-		m_GaussianFrameBuffer_horiz.Bind();
-		m_GaussianProgram_horiz->Bind();
-
-		glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_vert);
-
-		glBindVertexArray(m_ScreenQuad->VAO);
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-		glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
-			, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
-	}
-
-	//final vertical gaussian after the iterations are done
-
-	m_GaussianFrameBuffer_vert.Bind();
-	m_GaussianProgram_vert->Bind();
-
-	glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
-	glBindVertexArray(m_ScreenQuad->VAO);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-	glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].material->EndIndex - m_ScreenQuad->MaterialGroups()[0].material->StartIndex + 1
-		, GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].material->StartIndex);
-
-	glViewport(0, 0, (m_Renderer->GetViewportSize().Width), (m_Renderer->GetViewportSize().Height));
+	m_DrawBloomPass->ClearBuffer();
+	m_DrawBloomPass->Draw(m_SSAOTexture);
 }
 
 void SSAOPass::OnWindowResize() {
-	if (m_Quality == 0) {
-		return;
-	}
-
+	m_DrawBloomPass->OnWindowResize();
 	InitializeTexture();
+	m_SSAOFramBuffer.Generate();
+	m_SSAOViewSpaceZFramBuffer.Generate();
 }

src/Game/Game.cpp

@@ -54,7 +54,7 @@ Game::Game(int argc, char* argv[])
     m_EventBroker = new EventBroker();
 
     // Create the renderer
-    m_Renderer = new Renderer(m_EventBroker, m_Config);
+    m_Renderer = new Renderer(m_EventBroker);
     m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
     m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
     m_Renderer->SetResolution(Rectangle::Rectangle(

src/Game/Systems/SpawnerSystem.cpp

@@ -36,7 +36,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     }
 
     // Find any SpawnPoints existing as children of spawner
-    auto children = spawner.World->GetChildren(spawner.ID);
+    auto children = spawner.World->GetDirectChildren(spawner.ID);
     std::vector<EntityWrapper> spawnPoints;
     for (auto kv = children.first; kv != children.second; ++kv) {
         const EntityID& child = kv->second;