Merge branch 'master' of https://github.com/teamfisk/TacticalZ into SeeTeamMates

Conflicts:
	include/Engine/Rendering/SpriteJob.h
	resources/Schema/Components.xsd
	resources/Schema/Entities/Player.xml
	resources/Schema/Entities/PlayerRed.xml

src/Engine/CMakeLists.txt

@@ -3,7 +3,7 @@ project(TacticalZ-Engine)
 find_package(OpenGL REQUIRED)
 find_package(GLEW REQUIRED)
 find_package(GLFW REQUIRED)
-find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono program_options)
+find_package(Boost REQUIRED COMPONENTS system filesystem thread chrono timer program_options)
 find_package(assimp REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)

src/Engine/Collision/Collision.cpp

@@ -207,7 +207,7 @@ bool RayVsModel(const Ray& ray,
         glm::vec3 v0 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
         glm::vec3 v1 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
         glm::vec3 v2 = Transform::TransformPoint(modelVertices[modelIndices[i++]].Position, modelMatrix);
-        float dist = INFINITY;
+        float dist = outDistance;
         float u;
         float v;
         if (RayVsTriangle(ray, v0, v1, v2, dist, u, v)) {
@@ -366,7 +366,8 @@ bool AABBvsTriangle(const AABB& box,
     float verticalStepHeight,
     bool& isOnGround,
     glm::vec3& boxVelocity,
-    glm::vec3& outResolution)
+    glm::vec3& outResolution,
+    bool resolveCollision)
 {
     //Check so we don't have a zero area triangle when calculating the normal.
     //Also, don't check a triangle facing away from the player.
@@ -426,7 +427,7 @@ bool AABBvsTriangle(const AABB& box,
         //if projections don't overlap, return false.
         if (!rectangleVsTriangle(boxMin, boxMax, t2D, resolutionVector, resolutionDist, pushedFromTriangleLine)) {
             return false;
-        } else {
+        } else if (resolveCollision) {
             //Overwrite the smallest resolution if this is smaller.
             if (resolutionDist < resolveShortest.DistanceSq) {
                 resolveShortest.Vector = glm::vec3(0.f);
@@ -463,6 +464,11 @@ bool AABBvsTriangle(const AABB& box,
     if (glm::abs(t) > 1) {
         return false;
     }
+
+    if (!resolveCollision) {
+        return true;
+    }
+
     glm::vec3 cornerResolution = (1+t) * diagonal;
     //Overwrite the smallest resolution if cornerResolution is smaller.
     float lenSq = glm::length2(cornerResolution);
@@ -537,7 +543,8 @@ bool AABBvsTriangles(const AABB& box,
     glm::vec3& boxVelocity,
     float verticalStepHeight,
     bool& isOnGround,
-    glm::vec3& outResolutionVector)
+    glm::vec3& outResolutionVector,
+    bool resolveCollision)
 {
     bool hit = false;
 
@@ -553,7 +560,7 @@ bool AABBvsTriangles(const AABB& box,
         };
         glm::vec3 outVec;
         bool collideWithGround = isOnGround;
-        if (AABBvsTriangle(newBox, triVertices, originalBoxVelocity, verticalStepHeight, collideWithGround, boxVelocity, outVec)) {
+        if (AABBvsTriangle(newBox, triVertices, originalBoxVelocity, verticalStepHeight, collideWithGround, boxVelocity, outVec, resolveCollision)) {
             hit = true;
             outResolutionVector += outVec;
             newBox = AABB::FromOriginSize(newBox.Origin() + outVec, newBox.Size());
@@ -569,6 +576,44 @@ bool AABBvsTriangles(const AABB& box,
     return hit;
 }
 
+bool AABBvsTriangles(const AABB& box,
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix,
+    glm::vec3& boxVelocity,
+    float verticalStepHeight,
+    bool& isOnGround,
+    glm::vec3& outResolutionVector)
+{
+    return AABBvsTriangles(box,
+        modelVertices,
+        modelIndices,
+        modelMatrix,
+        boxVelocity,
+        verticalStepHeight,
+        isOnGround,
+        outResolutionVector,
+        true);
+}
+
+bool AABBvsTriangles(const AABB& box,
+    const RawModel::Vertex* modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    const glm::mat4& modelMatrix)
+{
+    glm::vec3 vel, outres;
+    bool g;
+    return AABBvsTriangles(box,
+        modelVertices,
+        modelIndices,
+        modelMatrix,
+        vel,
+        0.f,
+        g,
+        outres,
+        false);
+}
+
 boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity, bool takeModelBox)
 {
     AABB modelSpaceBox;
@@ -648,8 +693,9 @@ boost::optional<EntityAABB> EntityFirstHitByRay(const Ray& ray, std::vector<Enti
         if (!entityBox.Entity.HasComponent("Model")) {
             continue;
         }
-        std::string res = entityBox.Entity["Model"]["Resource"];
-        if (res.empty()) {
+        auto& cModel = entityBox.Entity["Model"];
+        std::string res = cModel["Resource"];
+        if (res.empty() || (bool)cModel["Transparent"] || !((bool)cModel["Visible"])) {
             continue;
         }
         Model* model;

src/Engine/Collision/CollisionSystem.cpp

@@ -3,24 +3,71 @@
 #include "Core/AABB.h"
 #include "Rendering/Model.h"
 
-void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
+void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPhysics, double dt)
 {
-    if (!entity.HasComponent("Physics")) {
+    if (!entity.HasComponent("Collidable")) {
         return;
     }
-    ComponentWrapper& cPhysics = entity["Physics"];
-
     boost::optional<EntityAABB> boundingBox = Collision::EntityAbsoluteAABB(entity);
     if (!boundingBox) {
         return;
     }
     ComponentWrapper& cTransform = entity["Transform"];
     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&) {
+                    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;
+            }
+        }
+    }
 
     // Collide against octree items
     m_OctreeResult.clear();
     m_Octree->ObjectsInSameRegion(*boundingBox, m_OctreeResult);
-    bool everHitTheGround = false;
     for (auto& boxB : m_OctreeResult) {
         glm::vec3 resolutionVector;
         if (boxA.Entity == boxB.Entity) {
@@ -64,4 +111,6 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     if (!everHitTheGround) {
         (bool)cPhysics["IsOnGround"] = false;
     }
+
+    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
 }

src/Engine/Core/ComponentPool.cpp

@@ -1,7 +1,5 @@
 #include "Core/ComponentPool.h"
 
-
-
 ComponentWrapper ComponentPoolForwardIterator::operator*() const
 {
     char* data = &(*m_MemoryPoolIterator);
@@ -32,6 +30,34 @@ ComponentPoolForwardIterator& ComponentPoolForwardIterator::operator++()
     return *this;
 }
 
+ComponentPool::ComponentPool(const ComponentPool& other)
+    : m_ComponentInfo(other.m_ComponentInfo)
+    , m_Pool(other.m_Pool)
+    , m_EntityToComponent()
+{
+    // Update EntityToComponent pointers
+    for (char& ptr : m_Pool) {
+        EntityID entity = *reinterpret_cast<EntityID*>(&ptr);
+        m_EntityToComponent[entity] = &ptr;
+    }
+
+    // Duplicate strings
+    for (auto& name : m_ComponentInfo.StringFields) {
+        for (auto& c : *this) {
+            std::string& val = c[name];
+            ComponentWrapper::SolidifyStrings(c);
+        }
+    }
+}
+
+ComponentPool::~ComponentPool()
+{
+    // Destroy component data
+    for (auto& c : *this) {
+        ComponentWrapper::Destroy(c.Info, c.Data);
+    }
+}
+
 //const ::ComponentInfo& ComponentPool::ComponentInfo() const
 //{
 //    return m_ComponentInfo;
@@ -39,10 +65,19 @@ ComponentPoolForwardIterator& ComponentPoolForwardIterator::operator++()
 
 ComponentWrapper ComponentPool::Allocate(EntityID entity)
 {
+    // Allocate pool data
     char* data = m_Pool.Allocate();
+    // Copy EntityID
     memcpy(data, &entity, sizeof(EntityID));
+
     m_EntityToComponent[entity] = data;
-    return ComponentWrapper(m_ComponentInfo, data);
+    ComponentWrapper component(m_ComponentInfo, data);
+
+    // Copy defaults
+    memcpy(component.Data, m_ComponentInfo.Defaults.get(), m_ComponentInfo.Stride);
+    ComponentWrapper::SolidifyStrings(component);
+
+    return component;
 }
 
 ComponentWrapper ComponentPool::GetByEntity(EntityID ent)
@@ -57,6 +92,7 @@ bool ComponentPool::KnowsEntity(EntityID ent)
 
 void ComponentPool::Delete(ComponentWrapper& wrapper)
 {
+    ComponentWrapper::Destroy(wrapper.Info, wrapper.Data);
     m_EntityToComponent.erase(wrapper.EntityID);
     m_Pool.Free(wrapper.Data - sizeof(EntityID));
 }

src/Engine/Core/EntityFilePreprocessor.cpp

@@ -185,6 +185,9 @@ void EntityFilePreprocessor::parseComponentInfo()
             field.Offset = fieldOffset;
             field.Stride = stride;
             compInfo.FieldsInOrder.push_back(name);
+            if (field.Type == "string") {
+                compInfo.StringFields.push_back(name);
+            }
             fieldOffset += stride;
         }
 
@@ -201,7 +204,7 @@ void EntityFilePreprocessor::parseDefaults()
 
     for (auto& ci : m_ComponentInfo) {
         // Allocate memory for default values
-        ci.second.Defaults = std::shared_ptr<char>(new char[ci.second.Stride]);
+        ci.second.Defaults = boost::shared_array<char>(new char[ci.second.Stride], std::bind(&ComponentWrapper::Destroy, ci.second, std::placeholders::_1));
         memset(ci.second.Defaults.get(), 0, ci.second.Stride);
 
         std::string componentName = ci.first;

src/Engine/Core/PerformanceTimer.cpp

@@ -0,0 +1,76 @@
+#include "Core/PerformanceTimer.h"
+#include <ctime>
+#include <fstream>
+
+cpu_timer PerformanceTimer::m_Timer;
+std::map<std::string, cpu_timer> PerformanceTimer::timers;
+std::string PerformanceTimer::currentTimerRunning = "";
+
+void PerformanceTimer::StartTimer(std::string nameOfTimer)
+{
+    timers[nameOfTimer].stop();
+    timers[nameOfTimer].start();
+    currentTimerRunning = nameOfTimer;
+}
+
+void PerformanceTimer::StartTimerAndStopPrevious(std::string nameOfTimer)
+{
+    //stop the current timer and start some other - useful to not have to stop timers all the time
+    if (currentTimerRunning != "") {
+        timers[currentTimerRunning].stop();
+    }
+    timers[nameOfTimer].stop();
+    timers[nameOfTimer].start();
+    currentTimerRunning = nameOfTimer;
+}
+
+void PerformanceTimer::StopTimer(std::string nameOfTimer)
+{
+    timers[nameOfTimer].stop();
+    currentTimerRunning = nameOfTimer;
+}
+
+void PerformanceTimer::SetFrameNumber(int frameNumber)
+{
+}
+
+void PerformanceTimer::ResetAllTimers()
+{
+    //stop all timers
+    for (auto aTimer : timers)
+    {
+        aTimer.second.stop();
+    }
+    currentTimerRunning = "";
+    timers.clear();
+}
+
+void PerformanceTimer::CreateExcelData()
+{
+    //get time
+    std::time_t t = std::time(NULL);
+    char tStr[16];
+    std::strftime(tStr, 32, " %a %H-%M-%S", std::localtime(&t));
+    std::string time(tStr);
+    std::string path("TacticalZ");
+    path += time + ".csv";
+    std::ofstream someFileStream;
+    someFileStream.open(path, std::ofstream::out);
+    someFileStream << "classname" << ',' << "walltime" << ',' << "userTime" << ',' << "systemTime" << '\n';
+
+    //write all timers to file
+    for (auto aTimer : timers)
+    {
+        //remove the "class" name in front of the string
+        auto className = aTimer.first;
+        if (className.find("class ") != std::string::npos) {
+            className.replace(0, 6, "");
+        }
+        auto wallTime = (double)aTimer.second.elapsed().wall*1e-3;
+        auto userTime = (double)aTimer.second.elapsed().user*1e-3;
+        auto systemTime = (double)aTimer.second.elapsed().system*1e-3;
+
+        someFileStream << className << "," << wallTime << ',' << userTime << ',' << systemTime << '\n';
+    }
+    someFileStream.close();
+}

src/Engine/Core/World.cpp

@@ -9,7 +9,20 @@ World::~World()
     }
 }
 
-EntityID World::CreateEntity(EntityID parent /*= 0*/)
+World::World(const World& other)
+    : m_EventBroker(other.m_EventBroker)
+    , m_CurrentEntityID(other.m_CurrentEntityID)
+    , m_EntityParents(other.m_EntityParents)
+    , m_EntityChildren(other.m_EntityChildren)
+    , m_EntityNames(other.m_EntityNames)
+{
+    // Deep copy component pools
+    for (auto& kv : other.m_ComponentPools) {
+        m_ComponentPools[kv.first] = new ComponentPool(*kv.second);
+    }
+}
+
+EntityID World::CreateEntity(EntityID parent /*= EntityID_Invalid*/)
 {
     EntityID newEntity = generateEntityID();
     if (newEntity == parent) {
@@ -44,10 +57,8 @@ ComponentWrapper World::AttachComponent(EntityID entity, const std::string& comp
     ComponentPool* pool = m_ComponentPools.at(componentType);
     const ComponentInfo& ci = pool->ComponentInfo();
 
-    // Allocate space for the component
+    // Allocate component with default values
     ComponentWrapper c = pool->Allocate(entity);
-    // Write default values
-    memcpy(c.Data, ci.Defaults.get(), ci.Stride);
 
     return c;
 }

src/Engine/Editor/EditorSystem.cpp

@@ -225,6 +225,12 @@ bool EditorSystem::OnInputCommand(const Events::InputCommand& e)
             Enable();
         }
     }
+    if (e.Command == "PerformanceTimingResetAllTimers" && e.Value > 0) {
+        PerformanceTimer::ResetAllTimers();
+    }
+    if (e.Command == "PerformanceTimingCreateExcelData" && e.Value > 0) {
+        PerformanceTimer::CreateExcelData();
+    }
     return true;
 }
 

src/Engine/GUI/ButtonSystem.cpp

@@ -0,0 +1,84 @@
+#include "GUI/ButtonSystem.h"
+
+ButtonSystem::ButtonSystem(SystemParams params, IRenderer* renderer)
+    : System(params)
+    , PureSystem("Button")
+    , m_Renderer(renderer)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &ButtonSystem::OnMousePress);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &ButtonSystem::OnMouseRelease);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseLock, &ButtonSystem::OnMouseLock);
+    EVENT_SUBSCRIBE_MEMBER(m_EMouseUnlock, &ButtonSystem::OnMouseUnlock);
+}
+
+
+bool ButtonSystem::OnMouseLock(const Events::LockMouse& e)
+{
+    m_MouseIsLocked = true;
+    return true;
+}
+
+
+bool ButtonSystem::OnMouseUnlock(const Events::UnlockMouse& e)
+{
+    m_MouseIsLocked = false;
+    return true;
+}
+
+
+bool ButtonSystem::OnMousePress(const Events::MousePress& e)
+{
+    if (e.Button == GLFW_MOUSE_BUTTON_1 && !m_MouseIsLocked) {
+        m_PickData = m_Renderer->Pick(glm::vec2(e.X, e.Y));
+        if (m_PickData.Entity != EntityID_Invalid && m_PickData.World == m_World) {
+            if(m_World->HasComponent(m_PickData.Entity, "Button")) {
+                //Entity is a button, save it and send pressed event.
+
+                m_PickEntity = EntityWrapper(m_World, m_PickData.Entity);
+
+                //You have clicked on a button entity, send pressed event.
+                Events::ButtonPressed ePressed;
+                ePressed.Entity = m_PickEntity;
+                ePressed.EntityName = m_PickEntity.Name();
+                m_EventBroker->Publish(ePressed);
+            }
+        }
+    }
+    return true;
+}
+
+bool ButtonSystem::OnMouseRelease(const Events::MouseRelease& e)
+{
+    if(!m_MouseIsLocked) {
+        //Mouse is not locked, send release event.
+        m_PickData = m_Renderer->Pick(glm::vec2(e.X, e.Y));
+        if(m_PickData.Entity != EntityID_Invalid && m_PickData.World == m_World) {
+            EntityWrapper ent = EntityWrapper(m_World, m_PickData.Entity);
+
+            Events::ButtonReleased eReleased;
+            eReleased.EntityName = m_PickEntity.Name();
+            eReleased.Entity = m_PickEntity;
+            m_EventBroker->Publish(eReleased);
+
+            if(m_World->HasComponent(m_PickData.Entity, "Button")) {
+                if (ent == m_PickEntity) {
+                    //The entity you released the mouse button on is the same as you pressed it on. "Clicked"
+                    Events::ButtonClicked eClicked;
+                    eClicked.Entity = m_PickEntity;
+                    eClicked.EntityName = m_PickEntity.Name();
+                    m_EventBroker->Publish(eClicked);
+                }
+            }
+        }
+    }
+    return true;
+}
+
+void ButtonSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cHealth, double dt)
+{
+
+}
+
+
+
+   

src/Engine/GUI/MainMenuSystem.cpp

@@ -0,0 +1,57 @@
+#include "GUI/MainMenuSystem.h"
+
+MainMenuSystem::MainMenuSystem(SystemParams params, IRenderer* renderer)
+    : System(params)
+    , ImpureSystem()
+    , m_Renderer(renderer)
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EPressed, &MainMenuSystem::OnButtonPress);
+    EVENT_SUBSCRIBE_MEMBER(m_EReleased, &MainMenuSystem::OnButtonRelease);
+    EVENT_SUBSCRIBE_MEMBER(m_EClicked, &MainMenuSystem::OnButtonClick);
+}
+
+void MainMenuSystem::Update(double dt)
+{
+
+}
+
+bool MainMenuSystem::OnButtonClick(const Events::ButtonClicked& e)
+{
+    if(e.EntityName == "Play") {
+        //Run play code
+    } else if(e.EntityName == "Connect") {
+        //Run connect code
+    } else if(e.EntityName == "Host") {
+        //Run host code
+    } else if(e.EntityName == "Quit") {
+        printf("No, you stay");
+    } else if (e.EntityName == "Res1080") {
+        glfwSetWindowSize(m_Renderer->Window(), 1920, 1080);
+        printf("\n1080");
+    } else if (e.EntityName == "Res720") {
+        glfwSetWindowSize(m_Renderer->Window(), 1280, 720);
+        glViewport(0, 0, 1280, 720);
+        printf("\n720");
+    } else if (e.EntityName == "Res480") {
+        glfwSetWindowSize(m_Renderer->Window(), 854, 480);
+        glViewport(0, 0, 854, 480);
+        printf("\n480");
+    } else if (e.EntityName == "FullScreen") {
+        printf("No fullscreen for now");
+    }
+
+    return true;
+}
+
+bool MainMenuSystem::OnButtonRelease(const Events::ButtonReleased& e)
+{
+
+    return true;
+}
+
+bool MainMenuSystem::OnButtonPress(const Events::ButtonPressed& e)
+{
+
+    return true;
+}
+

src/Engine/Network/Client.cpp

@@ -437,11 +437,12 @@ void Client::parsePlayerDamage(Packet& packet)
 {
     Events::PlayerDamage e;
     PlayerID victimID = packet.ReadPrimitive<EntityID>();
-    if(serverClientMapsHasEntity(victimID)){
+    PlayerID inflictorID = packet.ReadPrimitive<EntityID>();
+    if(!serverClientMapsHasEntity(victimID) || !serverClientMapsHasEntity(inflictorID)){
         return;
     }
     e.Inflictor = EntityWrapper(m_World, m_ServerIDToClientID.at(victimID));
-    e.Victim = EntityWrapper(m_World, m_ServerIDToClientID.at(packet.ReadPrimitive<EntityID>()));
+    e.Victim = EntityWrapper(m_World, m_ServerIDToClientID.at(inflictorID));
     e.Damage = packet.ReadPrimitive<double>();
     // Don't rebroadcast our own player damage events or we'll have an infinite loop!
     if (e.Inflictor != m_LocalPlayer) {

src/Engine/Network/Server.cpp

@@ -84,7 +84,6 @@ void Server::Update()
     if (isReadingData) {
         Network::Update();
     }
-
 }
 
 void Server::parseMessageType(Packet& packet)

src/Engine/Rendering/DrawBloomPass.cpp

@@ -19,16 +19,20 @@ void DrawBloomPass::InitializeTextures()
 void DrawBloomPass::InitializeShaderPrograms()
 {
     m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
-    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();
+	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");
-    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_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();
+	}
 }
 
 
@@ -71,15 +75,12 @@ void DrawBloomPass::Draw(GLuint texture)
     //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
     m_GaussianFrameBuffer_horiz.Bind();
     m_GaussianProgram_horiz->Bind();
-
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture);
-
     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
@@ -92,7 +93,6 @@ void DrawBloomPass::Draw(GLuint texture)
         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();
@@ -112,7 +112,6 @@ void DrawBloomPass::Draw(GLuint texture)
     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
@@ -121,6 +120,15 @@ void DrawBloomPass::Draw(GLuint texture)
     GLERROR("DrawBloomPass::Draw: END");
 }
 
+
+void DrawBloomPass::OnWindowResize()
+{
+    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);
+    m_GaussianFrameBuffer_horiz.Generate();
+}
+
 void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
     glGenTextures(1, texture);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -27,6 +27,7 @@ void DrawFinalPass::InitializeFrameBuffers()
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     GLERROR("RenderBuffer generation");
 
+
     GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
@@ -173,25 +174,25 @@ void DrawFinalPass::InitializeShaderPrograms()
     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());
     if (scene.ClearDepth) {
-        glClear(GL_DEPTH_BUFFER_BIT);
+        //glClear(GL_DEPTH_BUFFER_BIT);
+		state->Disable(GL_DEPTH_TEST);
+		state->DepthMask(GL_FALSE);
     }
     //TODO: Do we need check for this or will it be per scene always?
     glClearStencil(0x00);
     glClear(GL_STENCIL_BUFFER_BIT);
 
     //Fill depth buffer
-
-
+	
     state->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");
     DrawSprites(scene.Jobs.SpriteJob, scene);
     GLERROR("SpriteJobs");
@@ -206,11 +207,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");
@@ -241,14 +242,14 @@ void DrawFinalPass::Draw(RenderScene& scene)
     DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
     GLERROR("StencilPass");
 
-    glClear(GL_DEPTH_BUFFER_BIT);
+    //glClear(GL_DEPTH_BUFFER_BIT);
 
     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);
@@ -274,6 +275,27 @@ void DrawFinalPass::ClearBuffer()
     m_FinalPassFrameBuffer.Unbind();
 }
 
+
+void DrawFinalPass::OnWindowResize()
+{
+    //InitializeFrameBuffers();
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_FinalPassFrameBuffer.Generate();
+
+
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferLowRes);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
+
+    GenerateTexture(&m_SceneTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_FinalPassFrameBufferLowRes.Generate();
+    GLERROR("Error changing texture resolutions");
+}
+
 void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
     glGenTextures(1, texture);
@@ -300,7 +322,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");
@@ -323,6 +345,9 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, SSAOTexture);
+
     for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if (explosionEffectJob) {
@@ -669,14 +694,14 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
             glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(spriteJob->FillColor));
             glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), spriteJob->FillPercentage);
 
-            glActiveTexture(GL_TEXTURE0);
+            glActiveTexture(GL_TEXTURE1);
             if (spriteJob->DiffuseTexture != nullptr) {
                 glBindTexture(GL_TEXTURE_2D, spriteJob->DiffuseTexture->m_Texture);
             } else {
                 glBindTexture(GL_TEXTURE_2D, m_ErrorTexture->m_Texture);
             }
 
-            glActiveTexture(GL_TEXTURE1);
+            glActiveTexture(GL_TEXTURE2);
             if (spriteJob->IncandescenceTexture != nullptr) {
                 glBindTexture(GL_TEXTURE_2D, spriteJob->IncandescenceTexture->m_Texture);
             } else {
@@ -689,9 +714,6 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
             glDrawElements(GL_TRIANGLES, spriteJob->EndIndex - spriteJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(spriteJob->StartIndex*sizeof(unsigned int)));
         }
     }
-
-    
-
    // m_SpriteProgram->Unbind();
 }
 
@@ -705,7 +727,7 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
 	GLERROR("Bind 4 uniform");
 
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 	GLERROR("Bind 5 uniform");
 
     glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
@@ -738,6 +760,8 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
     glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), job->FillPercentage);
 	GLERROR("Bind 19 uniform");
     glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+    GLERROR("Bind 20 uniform");
+    glUniform1f(glGetUniformLocation(shaderHandle, "GlowIntensity"), job->GlowIntensity);
     GLERROR("END");
 }
 
@@ -755,7 +779,7 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 	GLERROR("Bind 4 uniform");
 
 	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
-	glUniform2f(Location_ScreenDimensions, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+	glUniform2f(Location_ScreenDimensions, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
 	GLERROR("Bind 5 uniform");
 
 	GLint Location_FillPercentage = glGetUniformLocation(shaderHandle, "FillPercentage");
@@ -773,6 +797,11 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 	GLint Location_AmbientColor = glGetUniformLocation(shaderHandle, "AmbientColor");
 	glUniform4fv(Location_AmbientColor, 1, glm::value_ptr(scene.AmbientColor));
 
+    GLERROR("Bind 10 uniform");
+    GLint Location_GlowIntensity = glGetUniformLocation(shaderHandle, "GlowIntensity");
+
+    glUniform1f(Location_GlowIntensity, job->GlowIntensity);
+
 	GLERROR("END");
 }
 
@@ -782,7 +811,7 @@ void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<E
 	case RawModel::MaterialType::SingleTextures:
 	case RawModel::MaterialType::Basic:
 	{
-		glActiveTexture(GL_TEXTURE0);
+		glActiveTexture(GL_TEXTURE1);
 		if (job->DiffuseTexture.size() > 0 && job->DiffuseTexture[0]->Texture != nullptr) {
 			glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[0]->Texture->m_Texture);
 			glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(job->DiffuseTexture[0]->UVRepeat));
@@ -792,7 +821,7 @@ void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<E
 			glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 		}
 
-		glActiveTexture(GL_TEXTURE1);
+		glActiveTexture(GL_TEXTURE2);
 		if (job->NormalTexture.size() > 0 && job->NormalTexture[0]->Texture != nullptr) {
 			glBindTexture(GL_TEXTURE_2D, job->NormalTexture[0]->Texture->m_Texture);
 			glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(job->NormalTexture[0]->UVRepeat));
@@ -802,7 +831,7 @@ void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<E
 			glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 		}
 
-		glActiveTexture(GL_TEXTURE2);
+		glActiveTexture(GL_TEXTURE3);
 		if (job->SpecularTexture.size() > 0 && job->SpecularTexture[0]->Texture != nullptr) {
 			glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[0]->Texture->m_Texture);
 			glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(job->SpecularTexture[0]->UVRepeat));
@@ -812,7 +841,7 @@ void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<E
 			glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 		}
 
-		glActiveTexture(GL_TEXTURE3);
+		glActiveTexture(GL_TEXTURE4);
 		if (job->IncandescenceTexture.size() > 0 && job->IncandescenceTexture[0]->Texture != nullptr) {
 			glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[0]->Texture->m_Texture);
 			glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(job->IncandescenceTexture[0]->UVRepeat));
@@ -825,7 +854,7 @@ void DrawFinalPass::BindExplosionTextures(GLuint shaderHandle, std::shared_ptr<E
 	}
 	case RawModel::MaterialType::SplatMapping:
 	{
-		glActiveTexture(GL_TEXTURE0);
+		glActiveTexture(GL_TEXTURE1);
 		glBindTexture(GL_TEXTURE_2D, job->SplatMap->Texture->m_Texture);
 
 		int texturePosition = GL_TEXTURE1;
@@ -900,7 +929,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 		case RawModel::MaterialType::SingleTextures:
 		case RawModel::MaterialType::Basic:
 		{
-			glActiveTexture(GL_TEXTURE0);
+			glActiveTexture(GL_TEXTURE1);
 			if (job->DiffuseTexture.size() > 0 && job->DiffuseTexture[0]->Texture != nullptr) {
 				glBindTexture(GL_TEXTURE_2D, job->DiffuseTexture[0]->Texture->m_Texture);
 				glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(job->DiffuseTexture[0]->UVRepeat));
@@ -910,7 +939,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 				glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 			}
 
-			glActiveTexture(GL_TEXTURE1);
+			glActiveTexture(GL_TEXTURE2);
 			if (job->NormalTexture.size() > 0 && job->NormalTexture[0]->Texture != nullptr) {
 				glBindTexture(GL_TEXTURE_2D, job->NormalTexture[0]->Texture->m_Texture);
 				glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(job->NormalTexture[0]->UVRepeat));
@@ -920,7 +949,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 				glUniform2fv(glGetUniformLocation(shaderHandle, "NormalUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 			}
 
-			glActiveTexture(GL_TEXTURE2);
+			glActiveTexture(GL_TEXTURE3);
 			if (job->SpecularTexture.size() > 0 && job->SpecularTexture[0]->Texture != nullptr) {
 				glBindTexture(GL_TEXTURE_2D, job->SpecularTexture[0]->Texture->m_Texture);
 				glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(job->SpecularTexture[0]->UVRepeat));
@@ -930,7 +959,7 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 				glUniform2fv(glGetUniformLocation(shaderHandle, "SpecularUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 			}
 
-			glActiveTexture(GL_TEXTURE3);
+			glActiveTexture(GL_TEXTURE4);
 			if (job->IncandescenceTexture.size() > 0 && job->IncandescenceTexture[0]->Texture != nullptr) {
 				glBindTexture(GL_TEXTURE_2D, job->IncandescenceTexture[0]->Texture->m_Texture);
 				glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(job->IncandescenceTexture[0]->UVRepeat));
@@ -943,10 +972,10 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 		}
 		case RawModel::MaterialType::SplatMapping:
 		{
-			glActiveTexture(GL_TEXTURE0);
+			glActiveTexture(GL_TEXTURE1);
 			glBindTexture(GL_TEXTURE_2D, job->SplatMap->Texture->m_Texture);
 
-			int texturePosition = GL_TEXTURE1;
+			int texturePosition = GL_TEXTURE2;
 		
 			//Bind 5 diffuse textures
 			std::string UniformName = "DiffuseUVRepeat";

src/Engine/Rendering/FrameBuffer.cpp

@@ -72,8 +72,8 @@ void FrameBuffer::Generate()
 
     GLenum* bufferTextures = &attachments[0];
     glDrawBuffers(attachments.size(), bufferTextures);
-    if(GLERROR("4")) {
-        printf("hello");
+    if (GLERROR("GLBufferAttachement error")) {
+        printf(": AttachmentSize %i", attachments.size());
     }
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {

src/Engine/Rendering/LightCullingPass.cpp

@@ -110,6 +110,34 @@ void LightCullingPass::FillLightList(RenderScene& scene)
     }
 }
 
+
+void LightCullingPass::OnWindowResize()
+{
+    SetSSBOSizes();
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_FrustumSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Frustum)*m_NumberOfTiles, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_FrustumSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(LightSource) * 200, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_LightSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightGridSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(LightGrid)*m_NumberOfTiles, nullptr, GL_DYNAMIC_COPY);
+    GLERROR("m_LightGridSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightOffsetSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(m_LightOffset), &m_LightOffset, GL_DYNAMIC_COPY);
+    GLERROR("m_LightOffsetSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_LightIndexSSBO);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float)*m_NumberOfTiles*MAX_LIGHTS_PER_TILE, m_LightIndex, GL_DYNAMIC_COPY);
+    GLERROR("m_LightIndexSSBO");
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+}
+
 void LightCullingPass::InitializeSSBOs()
 {
     glGenBuffers(1, &m_FrustumSSBO);

src/Engine/Rendering/PickingPass.cpp

@@ -15,6 +15,8 @@ PickingPass::~PickingPass()
 
 }
 
+
+
 void PickingPass::InitializeTextures()
 {
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
@@ -23,11 +25,20 @@ void PickingPass::InitializeTextures()
 
 void PickingPass::InitializeFrameBuffers()
 {
-    glGenRenderbuffers(1, &m_DepthBuffer);
+   /* glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);*/
 
-    m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
+	glGenTextures(1, &m_DepthBuffer);
+
+	glBindTexture(GL_TEXTURE_2D, m_DepthBuffer);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width), (int)(m_Renderer->GetViewportSize().Height), 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+
+    m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_PickingBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_PickingTexture, GL_COLOR_ATTACHMENT0)));
     m_PickingBuffer.Generate();
 }
@@ -61,7 +72,9 @@ void PickingPass::Draw(RenderScene& scene)
     m_PickingProgram->Bind();
 
     if (scene.ClearDepth) {
-        glClear(GL_DEPTH_BUFFER_BIT);
+        //glClear(GL_DEPTH_BUFFER_BIT);
+		state->Disable(GL_DEPTH_TEST);
+		state->DepthMask(GL_FALSE);
     }
     m_Camera = scene.Camera;
 
@@ -234,6 +247,52 @@ void PickingPass::Draw(RenderScene& scene)
         }
     }
 
+    for (auto& job : scene.Jobs.SpriteJob) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if (!spriteJob->Pickable) {
+            continue;
+        }
+        RenderState jobState;
+
+        if (spriteJob) {
+            if (spriteJob->Depth == 0) {
+                jobState.Disable(GL_DEPTH_TEST);
+            }
+            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+
+            PickingInfo pickInfo;
+            pickInfo.Entity = spriteJob->Entity;
+            pickInfo.World = spriteJob->World;
+            pickInfo.Camera = scene.Camera;
+
+            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+            if (color != m_EntityColors.end()) {
+                pickColor[0] = color->second[0];
+                pickColor[1] = color->second[1];
+            } else {
+                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+                if (m_ColorCounter[0] > 255) {
+                    m_ColorCounter[0] = 0;
+                    m_ColorCounter[1] += 1;
+                } else {
+                    m_ColorCounter[0] += 1;
+                }
+            }
+
+            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+
+            m_PickingProgram->Bind();
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(spriteJob->Matrix));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+            glBindVertexArray(spriteJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, spriteJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, spriteJob->EndIndex - spriteJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(spriteJob->StartIndex * sizeof(unsigned int)));
+        }
+    }
+
  /*   for (auto &job : scene.Jobs.TransparentShieldedObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
@@ -306,8 +365,6 @@ void PickingPass::Draw(RenderScene& scene)
     delete state;
 }
 
-
-
 void PickingPass::ClearPicking()
 {
     m_PickingColorsToEntity.clear();
@@ -321,6 +378,15 @@ void PickingPass::ClearPicking()
     m_PickingBuffer.Unbind();
 }
 
+
+void PickingPass::OnWindowResize()
+{
+    InitializeTextures();
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    m_PickingBuffer.Generate();
+}
+
 PickData PickingPass::Pick(glm::vec2 screenCoord)
 {
     int fbWidth;

src/Engine/Rendering/Renderer.cpp

@@ -1,5 +1,7 @@
 #include "Rendering/Renderer.h"
 
+std::unordered_map<GLFWwindow*, Renderer*> Renderer::m_WindowToRenderer;
+
 void Renderer::Initialize()
 {
 	InitializeWindow();
@@ -12,7 +14,6 @@ void Renderer::Initialize()
     m_TextPass = new TextPass();
     m_TextPass->Initialize();
 
-
    /* m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
     m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");*/
@@ -20,6 +21,17 @@ void Renderer::Initialize()
     m_ImGuiRenderPass = new ImGuiRenderPass(this, m_EventBroker);
 }
 
+void Renderer::glfwFrameBufferCallback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+    Renderer* currentRenderer = m_WindowToRenderer[window];
+    currentRenderer->m_ViewportSize = Rectangle(width, height);
+    currentRenderer->m_DrawFinalPass->OnWindowResize();
+    currentRenderer->m_LightCullingPass->OnWindowResize();
+    currentRenderer->m_PickingPass->OnWindowResize();
+    currentRenderer->m_DrawBloomPass->OnWindowResize();
+}
+
 void Renderer::InitializeWindow()
 {
 	// Initialize GLFW
@@ -39,6 +51,7 @@ void Renderer::InitializeWindow()
 		LOG_ERROR("GLFW: Failed to create window");
 		exit(EXIT_FAILURE);
 	}
+    glfwSetFramebufferSizeCallback(m_Window, &glfwFrameBufferCallback);
 	glfwMakeContextCurrent(m_Window);
 
 	// GL version info
@@ -59,8 +72,10 @@ void Renderer::InitializeWindow()
 		exit(EXIT_FAILURE);
 	}
 
+    m_WindowToRenderer[m_Window] = this;
+
     int windowSize[2];
-    glfwGetWindowSize(m_Window, &windowSize[0], &windowSize[1]);
+    glfwGetFramebufferSize(m_Window, &windowSize[0], &windowSize[1]);
     m_ViewportSize = Rectangle(windowSize[0], windowSize[1]);
 }
 
@@ -93,40 +108,71 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking\0Ambient Occlusion");
+
+	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);
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     //Clear other buffers
+    PerformanceTimer::StartTimer("Renderer-ClearBuffers");
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
-
+    PerformanceTimer::StopTimer("Renderer-ClearBuffers");
+	for (auto scene : frame.RenderScenes) {
+		PerformanceTimer::StartTimer("Renderer-Depth");
+		m_PickingPass->Draw(*scene);
+		GLERROR("Drawing pickingpass");
+		PerformanceTimer::StopTimer("Renderer-Depth");
+	}
+	PerformanceTimer::StartTimer("AO generation");
+	m_SSAOPass->Draw(m_PickingPass->DepthBuffer(), frame.RenderScenes.front()->Camera);
+	GLuint ao = m_SSAOPass->SSAOTexture();
+	PerformanceTimer::StopTimer("AO generation");
     for (auto scene : frame.RenderScenes){
         
+        PerformanceTimer::StartTimer("Renderer-Drawing PickingPass");
         SortRenderJobsByDepth(*scene);
         GLERROR("SortByDepth");
-        m_PickingPass->Draw(*scene);
-        GLERROR("Drawing pickingpass");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Generate Frustrums");
         m_LightCullingPass->GenerateNewFrustum(*scene);
         GLERROR("Generate frustums");
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Filling Light List");
         m_LightCullingPass->FillLightList(*scene);
         GLERROR("Filling light list");
+        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);
 
+        PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Text");
         m_TextPass->Draw(*scene, *m_DrawFinalPass->FinalPassFrameBuffer());
         GLERROR("Draw Text");
+        PerformanceTimer::StopTimer("Renderer-Draw Text");
+    }
 
-    }
+    PerformanceTimer::StartTimer("Renderer-Draw Bloom");
     m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
+    PerformanceTimer::StopTimer("Renderer-Draw Bloom");
+
     if (m_DebugTextureToDraw == 0) {
+        PerformanceTimer::StartTimer("Renderer-Color Correction Pass");
         m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), frame.Gamma, frame.Exposure);
+        PerformanceTimer::StopTimer("Renderer-Color Correction Pass");
     }
+
+    PerformanceTimer::StartTimer("Renderer-Misc Debug Draws");
     if (m_DebugTextureToDraw == 1) {
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
     }
@@ -145,10 +191,16 @@ void Renderer::Draw(RenderFrame& frame)
     if (m_DebugTextureToDraw == 6) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
+	if (m_DebugTextureToDraw == 7) {
+		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
+	}
+	PerformanceTimer::StopTimer("Renderer-Misc Debug Draws");
 
+    PerformanceTimer::StartTimer("Renderer-ImGuiRenderPass");
     m_ImGuiRenderPass->Draw();
     GLERROR("Imgui draw");
     glfwSwapBuffers(m_Window);
+    PerformanceTimer::StopTimer("Renderer-ImGuiRenderPass");
 }
 
 PickData Renderer::Pick(glm::vec2 screenCoord)
@@ -191,4 +243,5 @@ void Renderer::InitializeRenderPasses()
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this);
     m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
+	m_SSAOPass = new SSAOPass(this);
 }

src/Engine/Rendering/SSAOPass.cpp

@@ -0,0 +1,141 @@
+#include "Rendering/SSAOPass.h"
+
+SSAOPass::SSAOPass(IRenderer* renderer)
+{
+	m_Renderer = renderer;
+
+	m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+
+	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");
+	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");
+	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::InitializeBuffer()
+{
+	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);
+
+	m_SSAOFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOFramBuffer.Generate();
+
+	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);
+
+	m_SSAOViewSpaceZFramBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SSAOViewSpaceZTexture, GL_COLOR_ATTACHMENT0)));
+	m_SSAOViewSpaceZFramBuffer.Generate();
+}
+
+void SSAOPass::ClearBuffer()
+{
+	m_SSAOFramBuffer.Bind();
+	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	m_SSAOFramBuffer.Unbind();
+
+	m_SSAOViewSpaceZFramBuffer.Bind();
+	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	m_SSAOViewSpaceZFramBuffer.Unbind();
+}
+
+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;
+}
+
+void SSAOPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
+{
+	glGenTextures(1, texture);
+	glBindTexture(GL_TEXTURE_2D, *texture);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+	glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);
+	GLERROR("Texture initialization failed");
+}
+
+void SSAOPass::Draw(GLuint depthBuffer, Camera* camera)
+{
+	SSAOPassState state;
+	GLuint viewSpaceZPShaderHandle = m_SSAOViewSpaceZProgram->GetHandle();
+	GLuint SSAOShaderHandle = m_SSAOProgram->GetHandle();
+
+	m_SSAOViewSpaceZFramBuffer.Bind();
+	m_SSAOViewSpaceZProgram->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, depthBuffer);
+	glm::vec3 clipInfo = glm::vec3(
+		(camera->NearClip() * camera->FarClip()),
+		(camera->NearClip() - camera->FarClip()),
+		(camera->FarClip())
+		);
+	/*glm::vec3 clipInfo = glm::vec3(
+		(camera->NearClip()),
+		(-1.0f),
+		(+1.0f)
+		);*/
+	glUniform3fv(glGetUniformLocation(viewSpaceZPShaderHandle, "ClipInfo"), 1, glm::value_ptr(clipInfo));
+
+	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);
+	
+	glm::vec4 projInfo = glm::vec4(
+		((1.0 - camera->ProjectionMatrix()[0][2]) / 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 * camera->ProjectionMatrix()[1][1]))
+		);
+
+
+	m_SSAOFramBuffer.Bind();
+	m_SSAOProgram->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+	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 / (-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);;
+
+	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);
+
+	m_DrawBloomPass->ClearBuffer();
+	m_DrawBloomPass->Draw(m_SSAOTexture);
+}
+
+void ComputeAO(GLuint depthBuffer, Camera* camera) {
+
+}

src/Engine/Rendering/SSAOPassState.cpp

@@ -0,0 +1,16 @@
+#include "Rendering/SSAOPassState.h"
+
+
+SSAOPassState::SSAOPassState()
+{
+	//BindFramebuffer(0);
+	Disable(GL_BLEND);
+	Disable(GL_DEPTH_TEST);
+	Disable(GL_CULL_FACE);
+}
+
+SSAOPassState::~SSAOPassState()
+{
+
+}
+

src/Engine/Rendering/ShaderProgram.cpp

@@ -98,8 +98,7 @@ void ShaderProgram::AddShader(std::shared_ptr<Shader> shader)
 
 void ShaderProgram::Compile()
 {
-	if (m_ShaderProgramHandle == 0)
-	{
+	if (m_ShaderProgramHandle == 0)	{
 		m_ShaderProgramHandle = glCreateProgram();
 	}