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

# Conflicts: # include/Engine/Rendering/DrawFinalPass.h # include/Engine/Rendering/Renderer.h # resources/Shaders/ForwardPlus.vert.glsl # resources/Shaders/ForwardPlusSkinned.vert.glsl # src/Engine/Rendering/Renderer.cpp
2016-03-09 19:38:55 +01:00
parent e494f6a495 fce6e90f3c
commit e25c9ee690
158 changed files with 29178 additions and 8731 deletions
@@ -4,6 +4,8 @@ AnimationSystem::AnimationSystem(SystemParams params)
    : System(params)
 {
    EVENT_SUBSCRIBE_MEMBER(m_EAutoAnimationBlend, &AnimationSystem::OnAutoAnimationBlend);
+    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &AnimationSystem::OnEntityDeleted);
+    EVENT_SUBSCRIBE_MEMBER(m_ESetBlendWeight, &AnimationSystem::OnSetBlendWeight);
 }

 void AnimationSystem::Update(double dt)
@@ -122,16 +124,16 @@ void AnimationSystem::UpdateAnimations(double dt)
    }
 }

-
 void AnimationSystem::UpdateWeights(double dt)
 {
-    for (auto& autoBlendQueue : m_AutoBlendQueues) {
-
-        if(autoBlendQueue.second.HasActiveBlendJob()) {
-            AutoBlendQueue::AutoBlendJob& blendJob = autoBlendQueue.second.GetActiveBlendJob();
-
-            std::shared_ptr<BlendTree> blendTree = autoBlendQueue.second.GetBlendTree();
-
+    for (auto it = m_AutoBlendQueues.begin(); it != m_AutoBlendQueues.end(); ) {
+        LOG_INFO("%s", it->first.Name().c_str());
+        it->second.PrintQueue();
+        
+        if(it->second.HasActiveBlendJob()) {
+            AutoBlendQueue::AutoBlendJob& blendJob = it->second.GetActiveBlendJob();
+            LOG_INFO("%s", blendJob.RootNode.Name().c_str());
+            std::shared_ptr<BlendTree> blendTree = it->second.GetBlendTree();
            if (blendTree != nullptr) {
                if (blendJob.Duration != 0.0) {
                    blendJob.BlendInfo.progress = glm::clamp(blendJob.CurrentTime / blendJob.Duration, 0.0, 1.0);
@@ -140,10 +142,17 @@ void AnimationSystem::UpdateWeights(double dt)
                }

                blendJob.BlendInfo = blendTree->AutoBlendStep(blendJob.BlendInfo);
+            } else {
+                it = m_AutoBlendQueues.erase(it);
+            }
+            it++;
+        } else {
+            if (it->second.Empty()) {
+                it = m_AutoBlendQueues.erase(it);
+            } else {
+                it++;
            }
-
        }
-
    }
 }

@@ -177,46 +186,163 @@ bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
        return false;
    }

+    EntityWrapper subTreeRoot;


-    EntityWrapper subTreeRoot = blendTree->GetSubTreeRoot(e.NodeName);
+    if (e.SingleLevelBlend) {
+        subTreeRoot = blendTree->GetSubTreeRoot(e.NodeName);

-    if (!subTreeRoot.Valid()) {
-        return false;
-    }
+        if (!subTreeRoot.Valid()) {
+            return false;
+        }

-    AutoBlendQueue::AutoBlendJob abj;
-    abj.AnimationEntity = e.AnimationEntity;
-    abj.CurrentTime = 0.0;
-    abj.Delay = e.Delay;
-    abj.Duration = e.Duration;
-    abj.RootNode = e.RootNode;
+        AutoBlendQueue::AutoBlendJob abj;
+        abj.AnimationEntity = e.AnimationEntity;
+        abj.CurrentTime = 0.0;
+        abj.Delay = e.Delay;
+        abj.Duration = e.Duration;
+        abj.RootNode = e.RootNode;

-    abj.BlendInfo.NodeName = e.NodeName;
-    abj.BlendInfo.progress = 0.0;
-    abj.BlendInfo.Start = e.Start;
-    abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
-    abj.BlendInfo.Weight = e.Weight;
+        abj.BlendInfo.NodeName = e.NodeName;
+        abj.BlendInfo.progress = 0.0;
+        abj.BlendInfo.Start = e.Start;
+        abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
+        abj.BlendInfo.Weight = e.Weight;

-    EntityWrapper nodeEntity = subTreeRoot.FirstChildByName(e.NodeName); // more than one
-    if (nodeEntity.Valid()) {
-        if (nodeEntity.HasComponent("Animation")) {
-            const Skeleton::Animation* animation = skeleton->GetAnimation(nodeEntity["Animation"]["AnimationName"]);
-            (bool&)nodeEntity["Animation"]["Reverse"] = e.Reverse;
+        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
+        for(auto entity : animationEntities)
+        if (entity.Valid()) {
+            if (entity.HasComponent("Animation")) {
+                const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
+                (bool&)entity["Animation"]["Reverse"] = e.Reverse;

-            if (e.Restart) {
-                if (animation != nullptr) {
-                    if (e.Restart) {
-                        if (e.Reverse) {
-                            (double&)nodeEntity["Animation"]["Time"] = animation->Duration;
-                        } else {
-                            (double&)nodeEntity["Animation"]["Time"] = 0.0;
+                if (e.Restart) {
+                    if (animation != nullptr) {
+                        if (e.Restart) {
+                            if (e.Reverse) {
+                                (double&)entity["Animation"]["Time"] = animation->Duration;
+                            } else {
+                                (double&)entity["Animation"]["Time"] = 0.0;
+                            }
                        }
                    }
                }
            }
        }
+        m_AutoBlendQueues[subTreeRoot].Insert(abj);
+    } else {
+        std::vector<EntityWrapper> subtreeroots = blendTree->GetSingleLevelRoots(e.NodeName);
+
+        for(auto entity : subtreeroots) {
+            subTreeRoot = entity;
+
+            if (!subTreeRoot.Valid()) {
+                return false;
+            }
+
+            AutoBlendQueue::AutoBlendJob abj;
+            abj.AnimationEntity = e.AnimationEntity;
+            abj.CurrentTime = 0.0;
+            abj.Delay = e.Delay;
+            abj.Duration = e.Duration;
+            abj.RootNode = e.RootNode;
+
+            abj.BlendInfo.NodeName = e.NodeName;
+            abj.BlendInfo.progress = 0.0;
+            abj.BlendInfo.Start = e.Start;
+            abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
+            abj.BlendInfo.Weight = e.Weight;
+            m_AutoBlendQueues[subTreeRoot].Insert(abj);
+        }
+
+        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
+        for (auto entity : animationEntities)
+            if (entity.Valid()) {
+                if (entity.HasComponent("Animation")) {
+                    const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
+                    (bool&)entity["Animation"]["Reverse"] = e.Reverse;
+
+                    if (e.Restart) {
+                        if (animation != nullptr) {
+                            if (e.Restart) {
+                                if (e.Reverse) {
+                                    (double&)entity["Animation"]["Time"] = animation->Duration;
+                                } else {
+                                    (double&)entity["Animation"]["Time"] = 0.0;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
    }
-    m_AutoBlendQueues[subTreeRoot].Insert(abj);
+
+   
    return true;
 }
+
+bool AnimationSystem::OnEntityDeleted(Events::EntityDeleted& e)
+{
+    EntityWrapper entity = EntityWrapper(m_World, e.DeletedEntity);
+
+    if (entity.HasComponent("Model")) {
+        Model* model;
+        try {
+            model = ResourceManager::Load<::Model, true>(entity["Model"]["Resource"]);
+        } catch (const std::exception&) {
+            return false;
+        }
+
+        Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+        if (skeleton == nullptr) {
+            return false;
+        }
+
+        if (skeleton->BlendTrees.find(entity) != skeleton->BlendTrees.end()) {
+            skeleton->BlendTrees.erase(entity);
+        }
+
+
+    }
+
+}
+
+bool AnimationSystem::OnSetBlendWeight(Events::SetBlendWeight& e)
+{
+    if (!e.RootNode.Valid()) {
+        return false;
+    }
+
+    if (!e.RootNode.HasComponent("Model")) {
+        return false;
+    }
+
+    Model* model;
+    try {
+        model = ResourceManager::Load<::Model, true>((std::string)e.RootNode["Model"]["Resource"]);
+    } catch (const std::exception&) {
+        return false;
+    }
+
+    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
+    if (skeleton == nullptr) {
+        return false;
+    }
+
+    std::shared_ptr<BlendTree> blendTree;
+    if (skeleton->BlendTrees.find(e.RootNode) != skeleton->BlendTrees.end()) {
+        blendTree = skeleton->BlendTrees.at(e.RootNode);
+    } else {
+        return false;
+    }
+
+    if(e.Weight >= 0 && e.Weight <= 1) {
+
+        blendTree->SetWeightByName(e.NodeName, e.Weight);
+
+        return true;
+    } else {
+        return false;
+    }
+
+}
@@ -38,11 +38,14 @@ void AutoBlendQueue::Insert(AutoBlendJob autoBlendJob)
            double animationSpeed = (double)autoBlendJob.AnimationEntity["Animation"]["Speed"];
            double animationTime = (double)autoBlendJob.AnimationEntity["Animation"]["Time"];

-
-            if ((bool)autoBlendJob.AnimationEntity["Animation"]["Reverse"]) {
-                AnimationDuration = (animation->Duration * animationSpeed) - (animation->Duration - animationTime);
+            if (animationSpeed != 0) {
+                if ((bool)autoBlendJob.AnimationEntity["Animation"]["Reverse"]) {
+                    AnimationDuration = (animation->Duration / animationSpeed) - (animation->Duration - animationTime);
+                } else {
+                    AnimationDuration = (animation->Duration / animationSpeed) - animationTime;
+                }
            } else {
-                AnimationDuration = (animation->Duration * animationSpeed) - animationTime;
+                return;
            }

            blendNode.StartTime += AnimationDuration;
@@ -75,7 +78,6 @@ void AutoBlendQueue::Insert(AutoBlendJob autoBlendJob)
        }
    }

-
    m_BlendQueue.clear();
    m_BlendQueue.push_back(blendNode);
 }
@@ -124,7 +126,7 @@ bool AutoBlendQueue::HasActiveBlendJob()
            try {
                model = ResourceManager::Load<::Model, true>(blendJob.RootNode["Model"]["Resource"]);
            } catch (const std::exception&) {
-                m_BlendQueue.pop_front();
+                //m_BlendQueue.pop_front();
                return HasActiveBlendJob();
            }

@@ -2,11 +2,8 @@

 BlendTree::BlendTree(EntityWrapper ModelEntity, Skeleton* skeleton)
 {
-
    m_Skeleton = skeleton;

-
-
    if (ModelEntity.HasComponent("Animation")) {
        const Skeleton::Animation* animation = skeleton->GetAnimation(ModelEntity["Animation"]["AnimationName"]);
        if (animation == nullptr) {
@@ -217,7 +214,6 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
                }
            }
        }
-
        return blendInfo;
    }

@@ -270,7 +266,7 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)
            currentNode = currentNode->Parent;

            if (blendInfo.SingleBlend) {
-                break;
+                return blendInfo;;
            }
        }
    } else if(goalNodes.size() >= 2) {
@@ -331,9 +327,11 @@ BlendTree::AutoBlendInfo BlendTree::AutoBlendStep(AutoBlendInfo blendInfo)

                lastNode = currentNode;
                currentNode = currentNode->Parent;
+                if (blendInfo.SingleBlend) {
+                    return blendInfo;
+                }
            }
        }
-
    }

    return blendInfo;
@@ -427,6 +425,55 @@ EntityWrapper BlendTree::GetSubTreeRoot(std::string nodeName)
    return subTreeRoots.front()->Entity;
 }

+
+std::vector<EntityWrapper> BlendTree::GetSingleLevelRoots(std::string name)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+    std::vector<EntityWrapper> entities;
+
+    for (auto it = nodes.begin(); it != nodes.end(); it++) {
+        Node* currentNode = (*it)->Parent;
+        
+        if(currentNode->Entity.Valid()) {
+            entities.push_back(currentNode->Entity);
+        }
+    }
+
+    return entities;
+}
+
+
+std::vector<EntityWrapper> BlendTree::GetEntitesByName(std::string name)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+    std::vector<EntityWrapper> entities;
+
+    for (auto it = nodes.begin(); it != nodes.end(); it++) {
+        Node* currentNode = (*it);
+
+        if (currentNode->Entity.Valid()) {
+            entities.push_back(currentNode->Entity);
+        }
+    }
+
+    return entities;
+}
+
+
+void BlendTree::SetWeightByName(std::string name, double weight)
+{
+    std::vector<Node*> nodes = FindNodesByName(name);
+
+    for (auto node : nodes) {
+        EntityWrapper entity = node->Entity;
+
+        if(entity.HasComponent("Blend")) {
+            entity["Blend"]["Weight"] = weight;
+            node->Weight = weight;
+        }
+    }
+}
+
 void BlendTree::Blend(std::map<int, Skeleton::PoseData>& pose)
 {
    Node* currentNode;
@@ -0,0 +1,282 @@
+#include "Rendering/BlurHUD.h"
+
+BlurHUD::BlurHUD(IRenderer* renderer)
+    : m_Renderer(renderer)
+{
+    InitializeShaderPrograms();
+    InitializeBuffers();
+	InitializeTextures();
+}
+
+void BlurHUD::InitializeTextures()
+{
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
+}
+
+void BlurHUD::InitializeShaderPrograms()
+{
+    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->BindFragDataLocation(0, "fragmentColor");
+		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->BindFragDataLocation(0, "fragmentColor");
+		m_GaussianProgram_vert->Link();
+	}
+    m_FillDepthStencilProgram = ResourceManager::Load<ShaderProgram>("#FillDepthStencilProgram");
+    if (m_FillDepthStencilProgram->GetHandle() == 0) {
+        m_FillDepthStencilProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
+        m_FillDepthStencilProgram->Compile();
+        m_FillDepthStencilProgram->Link();
+    }
+    m_CombineTexturesProgram = ResourceManager::Load<ShaderProgram>("#CombineTexturesProgram");
+    if (m_CombineTexturesProgram->GetHandle() == 0) {
+        m_CombineTexturesProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/CombineTexture.vert.glsl")));
+        m_CombineTexturesProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/CombineTexture.frag.glsl")));
+        m_CombineTexturesProgram->Compile();
+        m_CombineTexturesProgram->BindFragDataLocation(0, "sceneColor");
+        m_CombineTexturesProgram->BindFragDataLocation(1, "bloomColor");
+        m_CombineTexturesProgram->Link();
+    }
+    GLERROR("Creating DepthFill program");
+}
+
+void BlurHUD::InitializeBuffers()
+{
+    glm::vec2 res = glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glm::vec2 res2 = glm::vec2(m_Renderer->GetViewportSize().Width/m_BlurQuality, m_Renderer->GetViewportSize().Height/m_BlurQuality);
+
+
+    CommonFunctions::GenerateTexture(&m_DepthStencil_horiz, GL_CLAMP_TO_BORDER, GL_NEAREST,
+        res2, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+    CommonFunctions::GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_NEAREST, 
+        res2, GL_RGBA16F, GL_RGBA, GL_FLOAT);
+
+	if (m_GaussianFrameBuffer_horiz.GetHandle() == 0) {
+        m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthStencil_horiz, GL_DEPTH_STENCIL_ATTACHMENT)));
+		m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
+	}
+	m_GaussianFrameBuffer_horiz.Generate();
+
+    CommonFunctions::GenerateTexture(&m_DepthStencil_vert, GL_CLAMP_TO_BORDER, GL_NEAREST,
+        res2, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+    CommonFunctions::GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_NEAREST,
+        res2, GL_RGBA16F, GL_RGBA, GL_FLOAT);
+
+	if (m_GaussianFrameBuffer_vert.GetHandle() == 0) {
+        m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_DepthStencil_vert, GL_DEPTH_STENCIL_ATTACHMENT)));
+		m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
+	}
+	m_GaussianFrameBuffer_vert.Generate();
+
+    CommonFunctions::GenerateTexture(&m_CombinedTexture, GL_CLAMP_TO_BORDER, GL_NEAREST,
+        res, GL_RGB16F, GL_RGB, GL_FLOAT);
+
+    if (m_CombinedTextureBuffer.GetHandle() == 0) {
+        m_CombinedTextureBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_CombinedTexture, GL_COLOR_ATTACHMENT0)));
+    }
+    m_CombinedTextureBuffer.Generate();
+}
+
+
+void BlurHUD::ClearBuffer()
+{
+    GLERROR("PRE");
+    m_GaussianFrameBuffer_horiz.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClearStencil(0x00);
+    glStencilMask(~0);
+    glDisable(GL_SCISSOR_TEST);
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    m_GaussianFrameBuffer_horiz.Unbind();
+    m_GaussianFrameBuffer_vert.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClearStencil(0x00);
+    glStencilMask(~0);
+    glDisable(GL_SCISSOR_TEST);
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    m_GaussianFrameBuffer_vert.Unbind();
+
+    m_CombinedTextureBuffer.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    m_CombinedTextureBuffer.Unbind();
+    GLERROR("END");
+}
+
+//Returns the finished blurred texture
+GLuint BlurHUD::Draw(GLuint texture, RenderScene& scene)
+{
+    GLERROR("DrawBloomPass::Draw: Pre");
+
+    FillStencil(scene);
+
+    RenderState state;
+    state.Disable(GL_BLEND);
+    state.Disable(GL_DEPTH_TEST);
+    state.Disable(GL_CULL_FACE);
+
+    state.Enable(GL_STENCIL_TEST);
+    state.StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    state.StencilFunc(GL_EQUAL, 1, 0xFF);
+    state.StencilMask(0x00);
+    state.DepthMask(GL_FALSE);
+    state.Enable(GL_SCISSOR_TEST);
+
+    GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
+    GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
+
+    //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
+    m_GaussianFrameBuffer_horiz.Bind();
+
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_BlurQuality, m_Renderer->GetViewportSize().Height/m_BlurQuality);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    
+    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
+        m_GaussianFrameBuffer_vert.Bind();
+        m_GaussianProgram_vert->Bind();
+
+		glActiveTexture(GL_TEXTURE0);
+        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_vert.Unbind();
+        m_GaussianFrameBuffer_horiz.Bind();
+        m_GaussianProgram_horiz->Bind();
+
+		glActiveTexture(GL_TEXTURE0);
+        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);
+		m_GaussianFrameBuffer_horiz.Unbind();
+    }
+
+    //final vertical gaussian after the iterations are done
+
+    m_GaussianFrameBuffer_vert.Bind();
+    m_GaussianProgram_vert->Bind();
+
+	glActiveTexture(GL_TEXTURE0);
+    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);
+
+    GLERROR("DrawBloomPass::Draw: END");
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+
+    return m_GaussianTexture_vert;
+}
+
+
+void BlurHUD::OnWindowResize()
+{
+    CommonFunctions::GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width/m_BlurQuality, m_Renderer->GetViewportSize().Height/m_BlurQuality), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_GaussianFrameBuffer_vert.Generate();
+    CommonFunctions::GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width/m_BlurQuality, m_Renderer->GetViewportSize().Height/m_BlurQuality), GL_RGB16F, GL_RGB, GL_FLOAT);
+    m_GaussianFrameBuffer_horiz.Generate();
+}
+
+void BlurHUD::FillStencil(RenderScene& scene)
+{
+    RenderState state;
+
+    state.BindFramebuffer(m_GaussianFrameBuffer_horiz.GetHandle());
+    state.Disable(GL_DEPTH_TEST);
+    state.Enable(GL_CULL_FACE);
+    state.Enable(GL_STENCIL_TEST);
+    state.StencilFunc(GL_ALWAYS, 1, 0xFF);
+    state.StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    state.StencilMask(0xFF);
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_BlurQuality, m_Renderer->GetViewportSize().Height/m_BlurQuality);
+
+    m_FillDepthStencilProgram->Bind();
+
+    GLuint shaderHandle = m_FillDepthStencilProgram->GetHandle();
+
+    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()));
+
+    for (auto& job : scene.Jobs.SpriteJob) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if (!spriteJob) {
+            continue;
+        }
+        if (!spriteJob->BlurBackground) {
+            continue;
+        }
+        glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(spriteJob->Matrix));
+
+        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)));
+    }
+
+    state.BindFramebuffer(m_GaussianFrameBuffer_vert.GetHandle());
+    for (auto& job : scene.Jobs.SpriteJob) {
+        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
+        if (!spriteJob) {
+            continue;
+        }
+        if(!spriteJob->BlurBackground) {
+            continue;
+        }
+        glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(spriteJob->Matrix));
+
+        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)));
+    }
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+}
+
+//Texture 1 will be used if texture 2 is black at that texel, else texture 2 is used.
+GLuint BlurHUD::CombineTextures(GLuint texture1, GLuint texture2)
+{
+    //RenderState state;
+    //state.BindFramebuffer(m_CombinedTextureBuffer.GetHandle());
+    //state.Disable(GL_DEPTH_TEST);
+    //state.Disable(GL_STENCIL_TEST);
+
+    m_CombineTexturesProgram->Bind();
+
+    glActiveTexture(GL_TEXTURE0);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, texture1);
+    glBindTexture(GL_TEXTURE_2D, texture2);
+    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);
+
+    return m_CombinedTexture;
+}
@@ -50,13 +50,15 @@ void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapp
        glm::vec4 perspective;
        glm::decompose(boneTransform, scale, rotation, translation, skew, perspective);

-        glm::vec3 angles = glm::vec3(-glm::pitch(rotation), -glm::yaw(rotation), -glm::roll(rotation));
+        rotation = glm::quat((glm::vec3)entity["BoneAttachment"]["OrientationOffset"]) * rotation;
+        rotation = glm::inverse(rotation);
+        glm::vec3 angles = glm::eulerAngles(rotation);
        
        if ((bool)entity["BoneAttachment"]["InheritPosition"]) {
            (glm::vec3&)entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"];
        }
        if ((bool)entity["BoneAttachment"]["InheritOrientation"]) {
-            (glm::vec3&)entity["Transform"]["Orientation"] = angles  + (glm::vec3)entity["BoneAttachment"]["OrientationOffset"];
+            (glm::vec3&)entity["Transform"]["Orientation"] = angles;
        }
        if ((bool)entity["BoneAttachment"]["InheritScale"]) {
            (glm::vec3&)entity["Transform"]["Scale"] = scale  * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"];
@@ -9,9 +9,14 @@ DrawBloomPass::DrawBloomPass(IRenderer* renderer, ConfigFile* config)
 	ChangeQuality(m_Config->Get<int>("GLOW.Quality", 2));
 }

+DrawBloomPass::~DrawBloomPass() {
+	CommonFunctions::DeleteTexture(&m_GaussianTexture_horiz);
+	CommonFunctions::DeleteTexture(&m_GaussianTexture_vert);
+}
+
 void DrawBloomPass::InitializeTextures()
 {
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
 }

 void DrawBloomPass::ChangeQuality(int quality)
@@ -13,13 +13,21 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
    InitializeFrameBuffers();
 }

+DrawFinalPass::~DrawFinalPass(){
+	CommonFunctions::DeleteTexture(&m_BloomTexture);
+	CommonFunctions::DeleteTexture(&m_SceneTexture);
+	CommonFunctions::DeleteTexture(&m_DepthBuffer);
+	CommonFunctions::DeleteTexture(&m_ShieldBuffer);
+	CommonFunctions::DeleteTexture(&m_CubeMapTexture);
+}
+
 void DrawFinalPass::InitializeTextures()
 {
-    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
-    m_BlackTexture = CommonFunctions::LoadTexture("Textures/Core/Black.png", false);
-    m_NeutralNormalTexture = CommonFunctions::LoadTexture("Textures/Core/NeutralNormalMap.png", false);
-    m_GreyTexture = CommonFunctions::LoadTexture("Textures/Core/Grey.png", false);
-    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
+    m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");
+    m_BlackTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Black.png");
+    m_NeutralNormalTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/NeutralNormalMap.png");
+    m_GreyTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/Grey.png");
+    m_ErrorTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/ErrorTexture.png");
 }

 void DrawFinalPass::InitializeFrameBuffers()
@@ -234,7 +242,7 @@ void DrawFinalPass::InitializeShaderPrograms()
 	
 }

-void DrawFinalPass::Draw(RenderScene& scene)
+void DrawFinalPass::Draw(RenderScene& scene, BlurHUD* blurHUDPass)
 {
    GLERROR("Pre");
 	DrawFinalPassState* stateDethp = new DrawFinalPassState(m_ShieldDepthFrameBuffer.GetHandle());
@@ -281,16 +289,32 @@ void DrawFinalPass::Draw(RenderScene& scene)
 	DrawModelRenderQueuesWithShieldCheck(scene.Jobs.TransparentObjects, scene); //might need changing
    GLERROR("Shielded Transparent objects");

+    //Generate blur texture.
+    delete state;
+    if (scene.ShouldBlur) {
+        //This needs to be drawn only when the full scene is being renderd, and then let be, otherwise sprite and other shit will show on it.
+        m_FullBlurredTexture = blurHUDPass->Draw(m_SceneTexture, scene);
+    }
+
+        DrawFinalPassState* stateSprite = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
+    if(scene.ShouldBlur) {
+        //Combine nonblur and blur texture
+        stateSprite->Disable(GL_DEPTH_TEST);
+        stateSprite->Disable(GL_STENCIL_TEST);
+        m_CombinedTexture = blurHUDPass->CombineTextures(m_SceneTexture, m_FullBlurredTexture);
+
+    }
 	//Draw Transparen objects
 	//state->BlendFunc(GL_ONE, GL_ONE);
 	//state->StencilFunc(GL_EQUAL, 1, 0xFF);
 	//DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
 	GLERROR("TransparentObjects");
 	//state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    stateSprite->Enable(GL_DEPTH_TEST);
 	DrawSprites(scene.Jobs.SpriteJob, scene);
 	GLERROR("SpriteJobs");

-	delete state;
+	delete stateSprite;
    GLERROR("END");
    
 }
@@ -336,6 +360,8 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 	GLuint explosionSkinnedHandle = m_ExplosionEffectSkinnedProgram->GetHandle();
 	GLuint explosionSplatMapSkinnedHandle = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
 	GLuint forwardSplatMapSkinnedHandle = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
+	GLuint lastShader = 0;
+	unsigned int lastModel = 0;

    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
@@ -359,9 +385,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 			case RawModel::MaterialType::SingleTextures:
 				{
                    if (explosionEffectJob->Model->IsSkinned()) {
-
-                        m_ExplosionEffectSkinnedProgram->Bind();
-                        GLERROR("Bind ExplosionEffectSkinned program");
+						if (lastShader != m_ExplosionEffectSkinnedProgram->GetHandle()) {
+							m_ExplosionEffectSkinnedProgram->Bind();
+							lastShader = m_ExplosionEffectSkinnedProgram->GetHandle();
+							GLERROR("Bind ExplosionEffectSkinned program");
+							glUniform1i(glGetUniformLocation(explosionSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(explosionSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(explosionSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ExplosionEffectSkinned Uniforms");
+						}
                        //bind uniforms
                        BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
                        //bind textures
@@ -381,8 +415,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&

                    }
 					else {
-						m_ExplosionEffectProgram->Bind();
-						GLERROR("Bind ExplosionEffect program");
+						if (lastShader != m_ExplosionEffectProgram->GetHandle()) {
+							m_ExplosionEffectProgram->Bind();
+							lastShader = m_ExplosionEffectProgram->GetHandle();
+							GLERROR("Bind ExplosionEffect program");
+							glUniform1i(glGetUniformLocation(explosionHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(explosionHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(explosionHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ExplosionEffect Uniforms");
+						}
 						//bind uniforms
 						BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
 						//bind textures
@@ -396,8 +439,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 			case RawModel::MaterialType::SplatMapping:
 				{
                    if (explosionEffectJob->Model->IsSkinned()) {
-                        m_ExplosionEffectSplatMapSkinnedProgram->Bind();
-                        GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+						if (lastShader != m_ExplosionEffectSplatMapSkinnedProgram->GetHandle()) {
+							m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+							lastShader = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
+							GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+							glUniform1i(glGetUniformLocation(explosionSplatMapSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(explosionSplatMapSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ExplosionEffectSplatMapSkinned Uniforms");
+						}
                        //bind uniforms
                        BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
                        //bind textures
@@ -413,9 +465,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&

                    }
 					else {
-						m_ExplosionEffectSplatMapProgram->Bind();
-						GLERROR("Bind ExplosionEffectSplatMap program");
-						//bind uniforms
+						if (lastShader != m_ExplosionEffectSplatMapProgram->GetHandle()) {
+							m_ExplosionEffectSplatMapProgram->Bind();
+							lastShader = m_ExplosionEffectSplatMapProgram->GetHandle();
+							GLERROR("Bind ExplosionEffectSplatMap program");
+							glUniform1i(glGetUniformLocation(explosionSplatMapHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(explosionSplatMapHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(explosionSplatMapHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ExplosionEffectSplatMap Uniforms");
+						}
 						//bind uniforms
 						BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
 						//bind textures
@@ -428,8 +488,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
            glDisable(GL_CULL_FACE);

            //draw
-            glBindVertexArray(explosionEffectJob->Model->VAO);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+			if (lastModel != explosionEffectJob->ModelID) {
+				glBindVertexArray(explosionEffectJob->Model->VAO);
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+				lastModel = explosionEffectJob->ModelID;
+			}
            glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
            glEnable(GL_CULL_FACE);
            GLERROR("explosion effect end");
@@ -443,8 +506,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 				case RawModel::MaterialType::SingleTextures:
 				{
 					if (modelJob->Model->IsSkinned()) {
-						m_ForwardPlusSkinnedProgram->Bind();
-						GLERROR("Bind ForwardPlusSkinnedProgram");
+						if (lastShader != m_ForwardPlusSkinnedProgram->GetHandle()) {
+							m_ForwardPlusSkinnedProgram->Bind();
+							lastShader = m_ForwardPlusSkinnedProgram->GetHandle();
+							GLERROR("Bind ForwardPlusSkinnedProgram program");
+							glUniform1i(glGetUniformLocation(forwardSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(forwardSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(forwardSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ForwardPlusSkinnedProgram Uniforms");
+						}
 						//bind uniforms
 						BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
 						//bind textures
@@ -462,8 +534,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
                        glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                    }
 					else {
-						m_ForwardPlusProgram->Bind();
-						GLERROR("Bind ForwardPlusProgram");
+						if (lastShader != m_ForwardPlusProgram->GetHandle()) {
+							m_ForwardPlusProgram->Bind();
+							lastShader = m_ForwardPlusProgram->GetHandle();
+							GLERROR("Bind ForwardPlusProgram program");
+							glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(forwardHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind ForwardPlusProgram Uniforms");
+						}
 						//bind uniforms
 						BindModelUniforms(forwardHandle, modelJob, scene);
 						//bind textures
@@ -477,8 +558,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 				case RawModel::MaterialType::SplatMapping:
 				{
 					if (modelJob->Model->IsSkinned()) {
-						m_ForwardPlusSplatMapSkinnedProgram->Bind();
-						GLERROR("Bind SplatMap program");
+						if (lastShader != m_ForwardPlusSplatMapSkinnedProgram->GetHandle()) {
+							m_ForwardPlusSplatMapSkinnedProgram->Bind();
+							lastShader = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
+							GLERROR("Bind SkinnedSplatMapProgram program");
+							glUniform1i(glGetUniformLocation(forwardSplatMapSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(forwardSplatMapSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind SkinnedSplatMapProgram Uniforms");
+						}
 						//bind uniforms
 						BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
 						//bind textures
@@ -494,8 +584,17 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&

 					}
 					else {
-						m_ForwardPlusSplatMapProgram->Bind();
-						GLERROR("Bind SplatMap program");
+						if (lastShader != m_ForwardPlusSplatMapProgram->GetHandle()) {
+							m_ForwardPlusSplatMapProgram->Bind();
+							lastShader = m_ForwardPlusSplatMapProgram->GetHandle();
+							GLERROR("Bind SplatMap program");
+							glUniform1i(glGetUniformLocation(forwardSplatMapHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+							glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+							glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+							glUniform2f(glGetUniformLocation(forwardSplatMapHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+							glUniform4fv(glGetUniformLocation(forwardSplatMapHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+							GLERROR("Bind SplatMap Uniforms");
+						}
 						//bind uniforms
 						BindModelUniforms(forwardSplatMapHandle, modelJob, scene);
 						//bind textures
@@ -506,8 +605,11 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 				}
                }
                //draw
-                glBindVertexArray(modelJob->Model->VAO);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+				if (lastModel != modelJob->ModelID) {
+					glBindVertexArray(modelJob->Model->VAO);
+					glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+					lastModel = modelJob->ModelID;
+				}
                glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
                if (GLERROR("models end")) {
                    continue;
@@ -536,6 +638,8 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 	GLuint explosionSkinnedShieldCheckHandle = m_ExplosionEffectSkinnedShieldCheckProgram->GetHandle();
 	GLuint explosionSplatMapSkinnedShieldCheckHandle = m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->GetHandle();
 	GLuint forwardSplatMapSkinnedShieldCheckHandle = m_ForwardPlusSplatMapSkinnedShieldCheckProgram->GetHandle();
+	GLuint lastShader = 0;
+	unsigned int lastModel = 0;

 	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
 	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
@@ -556,9 +660,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 				case RawModel::MaterialType::SingleTextures:
 					{
 						if (explosionEffectJob->Model->IsSkinned()) {
-
-							m_ExplosionEffectSkinnedShieldCheckProgram->Bind();
-							GLERROR("Bind ExplosionEffectSkinned program");
+							if (lastShader != m_ExplosionEffectSkinnedShieldCheckProgram->GetHandle()) {
+								m_ExplosionEffectSkinnedShieldCheckProgram->Bind();
+								lastShader = m_ExplosionEffectSkinnedShieldCheckProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSkinned program");
+								glUniform1i(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSkinnedShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSkinned Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSkinnedShieldCheckHandle, explosionEffectJob, scene);
 							//bind textures
@@ -577,8 +689,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p

 						}
 						else {
-							m_ExplosionEffectShieldCheckProgram->Bind();
-							GLERROR("Bind ExplosionEffect program");
+							if (lastShader != m_ExplosionEffectShieldCheckProgram->GetHandle()) {
+								m_ExplosionEffectShieldCheckProgram->Bind();
+								lastShader = m_ExplosionEffectShieldCheckProgram->GetHandle();
+								GLERROR("Bind ExplosionEffect program");
+								glUniform1i(glGetUniformLocation(explosionShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffect Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionShieldCheckHandle, explosionEffectJob, scene);
 							//bind textures
@@ -593,8 +714,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 				case RawModel::MaterialType::SplatMapping:
 					{
 						if (explosionEffectJob->Model->IsSkinned()) {
-							m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->Bind();
-							GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+							if (lastShader != m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->GetHandle()) {
+								m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->Bind();
+								lastShader = m_ExplosionEffectSplatMapSkinnedShieldCheckProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+								glUniform1i(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSplatMapSkinnedShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSplatMapSkinned Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSplatMapSkinnedShieldCheckHandle, explosionEffectJob, scene);
 							//bind textures
@@ -611,9 +741,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p

 						}
 						else {
-							m_ExplosionEffectSplatMapShieldCheckProgram->Bind();
-							GLERROR("Bind ExplosionEffectSplatMap program");
-							//bind uniforms
+							if (lastShader != m_ExplosionEffectSplatMapShieldCheckProgram->GetHandle()) {
+								m_ExplosionEffectSplatMapShieldCheckProgram->Bind();
+								lastShader = m_ExplosionEffectSplatMapShieldCheckProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSplatMap program");
+								glUniform1i(glGetUniformLocation(explosionSplatMapShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSplatMapShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSplatMapShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSplatMap Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSplatMapShieldCheckHandle, explosionEffectJob, scene);
 							//bind textures
@@ -629,9 +767,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 				case RawModel::MaterialType::SingleTextures:
 					{
 						if (explosionEffectJob->Model->IsSkinned()) {
-
-							m_ExplosionEffectSkinnedProgram->Bind();
-							GLERROR("Bind ExplosionEffectSkinned program");
+							if (lastShader != m_ExplosionEffectSkinnedProgram->GetHandle()) {
+								m_ExplosionEffectSkinnedProgram->Bind();
+								lastShader = m_ExplosionEffectSkinnedProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSkinned program");
+								glUniform1i(glGetUniformLocation(explosionSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSkinned Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
 							//bind textures
@@ -649,8 +795,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
                            glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                        }
 						else {
-							m_ExplosionEffectProgram->Bind();
-							GLERROR("Bind ExplosionEffect program");
+							if (lastShader != m_ExplosionEffectProgram->GetHandle()) {
+								m_ExplosionEffectProgram->Bind();
+								lastShader = m_ExplosionEffectProgram->GetHandle();
+								GLERROR("Bind ExplosionEffect program");
+								glUniform1i(glGetUniformLocation(explosionHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffect Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
 							//bind textures
@@ -664,8 +819,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 				case RawModel::MaterialType::SplatMapping:
 					{
 						if (explosionEffectJob->Model->IsSkinned()) {
-							m_ExplosionEffectSplatMapSkinnedProgram->Bind();
-							GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+							if (lastShader != m_ExplosionEffectSplatMapSkinnedProgram->GetHandle()) {
+								m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+								lastShader = m_ExplosionEffectSplatMapSkinnedProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSkinnedSplatMap program");
+								glUniform1i(glGetUniformLocation(explosionSplatMapSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSplatMapSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSkinnedSplatMap Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
 							//bind textures
@@ -681,9 +845,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p

 						}
 						else {
-							m_ExplosionEffectSplatMapProgram->Bind();
-							GLERROR("Bind ExplosionEffectSplatMap program");
-							//bind uniforms
+							if (lastShader != m_ExplosionEffectSplatMapProgram->GetHandle()) {
+								m_ExplosionEffectSplatMapProgram->Bind();
+								lastShader = m_ExplosionEffectSplatMapProgram->GetHandle();
+								GLERROR("Bind ExplosionEffectSplatMap program");
+								glUniform1i(glGetUniformLocation(explosionSplatMapHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+								glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+								glUniform2f(glGetUniformLocation(explosionSplatMapHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+								glUniform4fv(glGetUniformLocation(explosionSplatMapHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+								GLERROR("Bind ExplosionEffectSplatMap Uniforms");
+							}
 							//bind uniforms
 							BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
 							//bind textures
@@ -697,8 +869,11 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 			glDisable(GL_CULL_FACE);

 			//draw
-			glBindVertexArray(explosionEffectJob->Model->VAO);
-			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+			if (lastModel != explosionEffectJob->ModelID) {
+				glBindVertexArray(explosionEffectJob->Model->VAO);
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+				lastModel = explosionEffectJob->ModelID;
+			}
 			glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
 			glEnable(GL_CULL_FACE);
 			GLERROR("explosion effect end");
@@ -713,8 +888,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 					case RawModel::MaterialType::SingleTextures:
 						{
 							if (modelJob->Model->IsSkinned()) {
-								m_ForwardPlusSkinnedShieldCheckProgram->Bind();
-								GLERROR("Bind ForwardPlusSkinnedProgram");
+								if (lastShader != m_ForwardPlusSkinnedShieldCheckProgram->GetHandle()) {
+									m_ForwardPlusSkinnedShieldCheckProgram->Bind();
+									lastShader = m_ForwardPlusSkinnedShieldCheckProgram->GetHandle();
+									GLERROR("Bind ForwardPlusSkinnedProgram program");
+									glUniform1i(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSkinnedShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind ForwardPlusSkinnedProgram Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSkinnedShieldCheckHandle, modelJob, scene);
 								//bind textures
@@ -733,8 +917,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p

 							}
 							else {
-								m_ForwardPlusShieldCheckProgram->Bind();
-								GLERROR("Bind ForwardPlusProgram");
+								if (lastShader != m_ForwardPlusShieldCheckProgram->GetHandle()) {
+									m_ForwardPlusShieldCheckProgram->Bind();
+									lastShader = m_ForwardPlusShieldCheckProgram->GetHandle();
+									GLERROR("Bind ForwardPlusProgram program");
+									glUniform1i(glGetUniformLocation(forwardShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind ForwardPlusProgram Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardShieldCheckHandle, modelJob, scene);
 								//bind textures
@@ -748,8 +941,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 					case RawModel::MaterialType::SplatMapping:
 						{
 							if (modelJob->Model->IsSkinned()) {
-								m_ForwardPlusSplatMapSkinnedShieldCheckProgram->Bind();
-								GLERROR("Bind SplatMap program");
+								if (lastShader != m_ForwardPlusSplatMapSkinnedShieldCheckProgram->GetHandle()) {
+									m_ForwardPlusSplatMapSkinnedShieldCheckProgram->Bind();
+									lastShader = m_ForwardPlusSplatMapSkinnedShieldCheckProgram->GetHandle();
+									GLERROR("Bind ForwardPlusProgramSplatMapSkinned program");
+									glUniform1i(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind ForwardPlusProgramSplatMapSkinned Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSplatMapSkinnedShieldCheckHandle, modelJob, scene);
 								//bind textures
@@ -765,8 +967,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
                                glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedShieldCheckHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 							}
 							else {
-								m_ForwardPlusSplatMapShieldCheckProgram->Bind();
-								GLERROR("Bind SplatMap program");
+								if (lastShader != m_ForwardPlusSplatMapShieldCheckProgram->GetHandle()) {
+									m_ForwardPlusSplatMapShieldCheckProgram->Bind();
+									lastShader = m_ForwardPlusSplatMapShieldCheckProgram->GetHandle();
+									GLERROR("Bind SplatMap program");
+									glUniform1i(glGetUniformLocation(forwardSplatShieldCheckHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatShieldCheckHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatShieldCheckHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSplatShieldCheckHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSplatShieldCheckHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind SplatMap Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSplatShieldCheckHandle, modelJob, scene);
 								//bind textures
@@ -782,8 +993,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 					case RawModel::MaterialType::SingleTextures:
 						{
 							if (modelJob->Model->IsSkinned()) {
-								m_ForwardPlusSkinnedProgram->Bind();
-								GLERROR("Bind ForwardPlusSkinnedProgram");
+								if (lastShader != m_ForwardPlusSkinnedProgram->GetHandle()) {
+									m_ForwardPlusSkinnedProgram->Bind();
+									lastShader = m_ForwardPlusSkinnedProgram->GetHandle();
+									GLERROR("Bind ForwardPlusSkinnedProgram program");
+									glUniform1i(glGetUniformLocation(forwardSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind ForwardPlusSkinnedProgram Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
 								//bind textures
@@ -802,8 +1022,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p

 							}
 							else {
-								m_ForwardPlusProgram->Bind();
-								GLERROR("Bind ForwardPlusProgram");
+								if (lastShader != m_ForwardPlusProgram->GetHandle()) {
+									m_ForwardPlusProgram->Bind();
+									lastShader = m_ForwardPlusProgram->GetHandle();
+									GLERROR("Bind ForwardPlusProgram program");
+									glUniform1i(glGetUniformLocation(forwardHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind ForwardPlusProgram Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardHandle, modelJob, scene);
 								//bind textures
@@ -817,8 +1046,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 					case RawModel::MaterialType::SplatMapping:
 						{
 							if (modelJob->Model->IsSkinned()) {
-								m_ForwardPlusSplatMapSkinnedProgram->Bind();
-								GLERROR("Bind SplatMap program");
+								if (lastShader != m_ForwardPlusSplatMapSkinnedProgram->GetHandle()) {
+									m_ForwardPlusSplatMapSkinnedProgram->Bind();
+									lastShader = m_ForwardPlusSplatMapSkinnedProgram->GetHandle();
+									GLERROR("Bind SplatMap program");
+									glUniform1i(glGetUniformLocation(forwardSplatMapSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSplatMapSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind SplatMap Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
 								//bind textures
@@ -834,8 +1072,17 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
                                glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 							}
 							else {
-								m_ForwardPlusSplatMapProgram->Bind();
-								GLERROR("Bind SplatMap program");
+								if (lastShader != m_ForwardPlusSplatMapProgram->GetHandle()) {
+									m_ForwardPlusSplatMapProgram->Bind();
+									lastShader = m_ForwardPlusSplatMapProgram->GetHandle();
+									GLERROR("Bind SplatMap program");
+									glUniform1i(glGetUniformLocation(forwardSplatMapHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+									glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+									glUniform2f(glGetUniformLocation(forwardSplatMapHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+									glUniform4fv(glGetUniformLocation(forwardSplatMapHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+									GLERROR("Bind SplatMap Uniforms");
+								}
 								//bind uniforms
 								BindModelUniforms(forwardSplatMapHandle, modelJob, scene);
 								//bind textures
@@ -847,8 +1094,11 @@ void DrawFinalPass::DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_p
 					}
 				}
 				//draw
-				glBindVertexArray(modelJob->Model->VAO);
-				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+				if (lastModel != modelJob->ModelID) {
+					glBindVertexArray(modelJob->Model->VAO);
+					glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+					lastModel = modelJob->ModelID;
+				}
 				glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
 				if (GLERROR("models end")) {
 					continue;
@@ -953,17 +1203,26 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende

 void DrawFinalPass::DrawToDepthStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-    
-   
+	GLuint shaderSkinnedHandle = m_FillDepthStencilBufferSkinnedProgram->GetHandle();
+    GLuint shaderHandle = m_FillDepthStencilBufferProgram->GetHandle();
+	GLuint lastShader = 0;
    for (auto &job : jobs) {
        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
      
        if(modelJob->Model->IsSkinned()) {
-            m_FillDepthStencilBufferSkinnedProgram->Bind();
-            GLuint shaderHandle = m_FillDepthStencilBufferSkinnedProgram->GetHandle();
-            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()));
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+			if (lastShader != m_FillDepthStencilBufferSkinnedProgram->GetHandle()) {
+				m_FillDepthStencilBufferSkinnedProgram->Bind();
+				lastShader = m_FillDepthStencilBufferSkinnedProgram->GetHandle();
+				glUniform1i(glGetUniformLocation(shaderSkinnedHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+				glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+				glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+				glUniform2f(glGetUniformLocation(shaderSkinnedHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+				glUniform4fv(glGetUniformLocation(shaderSkinnedHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+				GLERROR("Bind Uniforms 1");
+			}
+
+			glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
+			GLERROR("Bind PVM uniform");

            std::vector<glm::mat4> frameBones;
            if (modelJob->BlendTree != nullptr) {
@@ -974,11 +1233,19 @@ void DrawFinalPass::DrawToDepthStencilBuffer(std::list<std::shared_ptr<RenderJob
            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));

        } else {
-            m_FillDepthStencilBufferProgram->Bind();
-            GLuint shaderHandle = m_FillDepthStencilBufferProgram->GetHandle();
-            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()));
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+			if (lastShader != m_FillDepthStencilBufferProgram->GetHandle()) {
+				m_FillDepthStencilBufferProgram->Bind();
+				lastShader = m_FillDepthStencilBufferProgram->GetHandle();
+				glUniform1i(glGetUniformLocation(shaderHandle, "SSAOQuality"), m_SSAOPass->TextureQuality());
+				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()));
+				glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+				glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
+				GLERROR("Bind Uniforms 2");
+			}
+
+			glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
+			GLERROR("Bind PVM uniform");
        }


@@ -1000,6 +1267,9 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend

    GLuint shaderHandle = m_SpriteProgram->GetHandle();

+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+	glUniform3fv(glGetUniformLocation(shaderHandle, "CameraPos"), 1, glm::value_ptr(scene.Camera->Position()));
+
    for(auto& job : jobs) {
        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
        RenderState jobState;
@@ -1008,10 +1278,7 @@ void DrawFinalPass::DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, Rend
            if(spriteJob->Depth == 0) {
                jobState.Disable(GL_DEPTH_TEST);
            }
-            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()));
-            glUniform3fv(glGetUniformLocation(shaderHandle, "CameraPos"), 1, glm::value_ptr(scene.Camera->Position()));
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * spriteJob->Matrix));
            glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(spriteJob->Color));
            glUniform4fv(glGetUniformLocation(shaderHandle, "FillColor"), 1, glm::value_ptr(spriteJob->FillColor));
            glUniform1f(glGetUniformLocation(shaderHandle, "FillPercentage"), spriteJob->FillPercentage);
@@ -1041,17 +1308,14 @@ 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");
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-	GLERROR("Bind 3 uniform");
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-	GLERROR("Bind 4 uniform");
-
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-	GLERROR("Bind 5 uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * job->Matrix));
+	GLERROR("Bind PVM uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "VM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix() * job->Matrix));
+	GLERROR("Bind VM uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "TIM"), 1, GL_FALSE, glm::value_ptr(glm::transpose(glm::inverse(job->Matrix))));
+	GLERROR("Bind TIM uniform");

    glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
 	GLERROR("Bind 6 uniform");
@@ -1082,8 +1346,6 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
 	GLERROR("Bind 18 uniform");
    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);

 	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
@@ -1094,21 +1356,15 @@ 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));
 	GLERROR("Bind 2 uniform");
-	GLint Location_V = glGetUniformLocation(shaderHandle, "V");
-	glUniformMatrix4fv(Location_V, 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-	GLERROR("Bind 3 uniform");
-	GLint Location_P = glGetUniformLocation(shaderHandle, "P");
-	glUniformMatrix4fv(Location_P, 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-	GLERROR("Bind 4 uniform");
-
-	GLint Location_ScreenDimensions = glGetUniformLocation(shaderHandle, "ScreenDimensions");
-	glUniform2f(Location_ScreenDimensions, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-	GLERROR("Bind 5 uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * job->Matrix));
+	GLERROR("Bind PVM uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "VM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix() * job->Matrix));
+	GLERROR("Bind VM uniform");
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "TIM"), 1, GL_FALSE, glm::value_ptr(glm::transpose(glm::inverse(job->Matrix))));
+	GLERROR("Bind TIM uniform");

 	GLint Location_FillPercentage = glGetUniformLocation(shaderHandle, "FillPercentage");
 	glUniform1f(Location_FillPercentage, job->FillPercentage);
@@ -1121,11 +1377,6 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 	GLERROR("Bind 8 uniform");
 	GLint Location_Color = glGetUniformLocation(shaderHandle, "Color");
 	glUniform4fv(Location_Color, 1, glm::value_ptr(job->Color));
-	GLERROR("Bind 9 uniform");
-	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);

@@ -10,31 +10,31 @@ Model::Model(std::string fileName)
 		case RawModel::MaterialType::SingleTextures:
 		{
 			RawModel::MaterialSingleTextures* materialSingleTexture = static_cast<RawModel::MaterialSingleTextures*>(materialProperty.material);
-            materialSingleTexture->ColorMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->ColorMap.TexturePath, false);
-            materialSingleTexture->NormalMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->NormalMap.TexturePath, false);
-            materialSingleTexture->SpecularMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->SpecularMap.TexturePath, false);
-            materialSingleTexture->IncandescenceMap.Texture = CommonFunctions::LoadTexture(materialSingleTexture->IncandescenceMap.TexturePath, false);
+            materialSingleTexture->ColorMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->ColorMap.TexturePath);
+            materialSingleTexture->NormalMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->NormalMap.TexturePath);
+            materialSingleTexture->SpecularMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->SpecularMap.TexturePath);
+            materialSingleTexture->IncandescenceMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSingleTexture->IncandescenceMap.TexturePath);
 		}
 			break;
 		case RawModel::MaterialType::SplatMapping:
 		{
 			RawModel::MaterialSplatMapping* materialSplatMapping = static_cast<RawModel::MaterialSplatMapping*>(materialProperty.material);
-			materialSplatMapping->SplatMap.Texture = CommonFunctions::LoadTexture(materialSplatMapping->SplatMap.TexturePath, false);
+			materialSplatMapping->SplatMap.Texture = CommonFunctions::TryLoadResource<Texture, false>(materialSplatMapping->SplatMap.TexturePath);
 			for (auto& texture : materialSplatMapping->ColorMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->NormalMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->SpecularMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 			for (auto& texture : materialSplatMapping->IncandescenceMaps)
 			{
-				texture.Texture = CommonFunctions::LoadTexture(texture.TexturePath, false);
+				texture.Texture = CommonFunctions::TryLoadResource<Texture, false>(texture.TexturePath);
 			}
 		}
 			break;
@@ -12,7 +12,8 @@ PickingPass::PickingPass(IRenderer* renderer, EventBroker* eb)

 PickingPass::~PickingPass()
 {
-
+	CommonFunctions::DeleteTexture(&m_PickingTexture);
+	CommonFunctions::DeleteTexture(&m_DepthBuffer);
 }


@@ -61,8 +62,9 @@ void PickingPass::Draw(RenderScene& scene)
    //TODO: Render: Add code for more jobs than modeljobs.
    GLuint shaderHandle = m_PickingProgram->GetHandle();
    GLuint shaderSkinnedHandle = m_PickingSkinnedProgram->GetHandle();
+	GLuint lastShader = 0;
+	unsigned int lastModel = 0;
    m_PickingProgram->Bind();
-
    if (scene.ClearDepth) {
        //glClear(GL_DEPTH_BUFFER_BIT);
 		state->Disable(GL_DEPTH_TEST);
@@ -98,10 +100,11 @@ void PickingPass::Draw(RenderScene& scene)
            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;

            if (modelJob->Model->IsSkinned()) {
-                m_PickingSkinnedProgram->Bind();
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+				if (lastShader != m_PickingSkinnedProgram->GetHandle()) {
+					m_PickingSkinnedProgram->Bind();
+					lastShader = m_PickingSkinnedProgram->GetHandle();
+				}
+                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));

                std::vector<glm::mat4> frameBones;
@@ -114,15 +117,19 @@ void PickingPass::Draw(RenderScene& scene)


            } else {
-                m_PickingProgram->Bind();
-                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+				if (lastShader != m_PickingProgram->GetHandle()) {
+					m_PickingProgram->Bind();
+					lastShader = m_PickingProgram->GetHandle();
+				}
+				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
            }

-            glBindVertexArray(modelJob->Model->VAO);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+			if (lastModel != modelJob->ModelID) {
+				glBindVertexArray(modelJob->Model->VAO);
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+				lastModel = modelJob->ModelID;
+			}
            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
        }
    }
@@ -208,10 +215,11 @@ void PickingPass::Draw(RenderScene& scene)
            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;

            if (modelJob->Model->IsSkinned()) {
-                m_PickingSkinnedProgram->Bind();
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+				if (lastShader != m_PickingSkinnedProgram->GetHandle()) {
+					m_PickingSkinnedProgram->Bind();
+					lastShader = m_PickingSkinnedProgram->GetHandle();
+				}
+				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
                glUniform2fv(glGetUniformLocation(shaderSkinnedHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));

                std::vector<glm::mat4> frameBones;
@@ -224,19 +232,24 @@ void PickingPass::Draw(RenderScene& scene)
                glUniformMatrix4fv(glGetUniformLocation(shaderSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));

            } else {
-                m_PickingProgram->Bind();
-                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->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()));
+				if (lastShader != m_PickingProgram->GetHandle()) {
+					m_PickingProgram->Bind();
+					lastShader = m_PickingProgram->GetHandle();
+				}
+				glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * modelJob->Matrix));
                glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
            }

-            glBindVertexArray(modelJob->Model->VAO);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+			if (lastModel != modelJob->ModelID) {
+				glBindVertexArray(modelJob->Model->VAO);
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+				lastModel = modelJob->ModelID;
+			}
            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
        }
    }

+	m_PickingProgram->Bind();
    for (auto& job : scene.Jobs.SpriteJob) {
        auto spriteJob = std::dynamic_pointer_cast<SpriteJob>(job);
        if (!spriteJob->Pickable) {
@@ -271,14 +284,11 @@ void PickingPass::Draw(RenderScene& scene)

            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()));
+			glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "PVM"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix() * scene.Camera->ViewMatrix() * spriteJob->Matrix));
            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);
+			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)));
        }
    }
@@ -437,6 +437,7 @@ void RenderSystem::Update(double dt)
    }

    RenderScene scene;
+    scene.ShouldBlur = true;
    scene.Camera = m_Camera;
    scene.Viewport = Rectangle(1280, 720);

@@ -450,7 +451,7 @@ void RenderSystem::Update(double dt)
    fillModels(scene.Jobs);
    fillPointLights(scene.Jobs.PointLight, m_World);
    //TODO: Make sure all objects needed are also sorted.
-	scene.Jobs.OpaqueObjects.sort();
+	scene.Jobs.OpaqueObjects.sort([](auto& a, auto& b) {return *a < *b; });
    fillSprites(scene.Jobs.SpriteJob, m_World);
    fillDirectionalLights(scene.Jobs.DirectionalLight, m_World);
    fillText(scene.Jobs.Text, m_World);
@@ -2,6 +2,19 @@

 std::unordered_map<GLFWwindow*, Renderer*> Renderer::m_WindowToRenderer;

+Renderer::~Renderer() {
+	delete m_PickingPass;
+	delete m_LightCullingPass;
+	delete m_ImGuiRenderPass;
+	delete m_DrawFinalPass;
+	delete m_DrawScreenQuadPass;
+	delete m_DrawBloomPass;
+	delete m_DrawColorCorrectionPass;
+	delete m_SSAOPass;
+	delete m_CubeMapPass;
+	delete m_TextPass;
+}
+
 void Renderer::Initialize()
 {
 	m_SSAO_Quality = m_Config->Get<int>("SSAO.Quality", 0);
@@ -110,7 +123,7 @@ void Renderer::Draw(RenderFrame& frame)
 {
    GLERROR("PRE");
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking\0Ambient Occlusion");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking\0Ambient Occlusion\0Combined Scene Texture\0Full Blurred Texture");
    ImGui::Combo("CubeMap", &m_CubeMapTexture, "Nevada(512)\0Sky(1024)");
    if(m_CubeMapTexture == 0) {
        m_CubeMapPass->LoadTextures("Nevada");
@@ -134,6 +147,7 @@ void Renderer::Draw(RenderFrame& frame)
    m_DrawBloomPass->ClearBuffer();
 	m_SSAOPass->ClearBuffer();
 	m_ShadowPass->ClearBuffer();
+    m_BlurHUDPass->ClearBuffer();
 	m_ShadowPass->DebugGUI();
    PerformanceTimer::StopTimer("Renderer-ClearBuffers");
    GLERROR("ClearBuffers");
@@ -163,7 +177,7 @@ void Renderer::Draw(RenderFrame& frame)
        m_LightCullingPass->CullLights(*scene);
        GLERROR("LightCulling");
 		PerformanceTimer::StartTimerAndStopPrevious("Renderer-Draw Geometry+Light");
-		m_DrawFinalPass->Draw(*scene);
+		m_DrawFinalPass->Draw(*scene, m_BlurHUDPass);
        GLERROR("Draw Geometry+Light");
        //m_DrawScenePass->Draw(*scene);

@@ -199,6 +213,12 @@ void Renderer::Draw(RenderFrame& frame)
 	if (m_DebugTextureToDraw == 5) {
 		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
 	}
+    if (m_DebugTextureToDraw == 6) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->CombinedSceneTexture());
+    }
+    if (m_DebugTextureToDraw == 7) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->FullBlurredTexture());
+    }
 	PerformanceTimer::StopTimer("Renderer-Misc Debug Draws");

    PerformanceTimer::StartTimer("Renderer-ImGuiRenderPass");
@@ -218,8 +238,8 @@ PickData Renderer::Pick(glm::vec2 screenCoord)

 void Renderer::InitializeTextures()
 {
-    m_ErrorTexture = CommonFunctions::LoadTexture("Textures/Core/ErrorTexture.png", false);
-    m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+    m_ErrorTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/ErrorTexture.png");
+    m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");
 }


@@ -250,9 +270,10 @@ void Renderer::InitializeRenderPasses()
    m_CubeMapPass = new CubeMapPass(this);
 	m_SSAOPass = new SSAOPass(this, m_Config);
 	m_ShadowPass = new ShadowPass(this);
+    m_BlurHUDPass = new BlurHUD(this);
    m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass, m_ShadowPass);
    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
    m_DrawBloomPass = new DrawBloomPass(this, m_Config);
    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
-  
+
 }
@@ -4,12 +4,19 @@ SSAOPass::SSAOPass(IRenderer* renderer, ConfigFile* config)
 	: m_Renderer(renderer)
 	, m_Config(config)
 {
-	m_WhiteTexture = CommonFunctions::LoadTexture("Textures/Core/White.png", false);
+	m_WhiteTexture = CommonFunctions::TryLoadResource<Texture, false>("Textures/Core/White.png");

 	ChangeQuality(m_Config->Get<int>("SSAO.Quality", 0));

 }

+SSAOPass::~SSAOPass() {
+	CommonFunctions::DeleteTexture(&m_SSAOTexture);
+	CommonFunctions::DeleteTexture(&m_SSAOViewSpaceZTexture);
+	CommonFunctions::DeleteTexture(&m_Gaussian_horiz);
+	CommonFunctions::DeleteTexture(&m_Gaussian_vert);
+}
+
 void SSAOPass::ChangeQuality(int quality)
 {
 	if (m_Quality == quality) {
@@ -4,22 +4,32 @@ GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
 {
 	LOG_INFO("Compiling shader \"%s\"", fileName.c_str());

-	std::string shaderFile;
-	std::ifstream in(fileName, std::ios::in);
-	if (!in) {
-		LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
-		return 0;
-	}
-	in.seekg(0, std::ios::end);
-	shaderFile.resize((int)in.tellg());
-	in.seekg(0, std::ios::beg);
-	in.read(&shaderFile[0], shaderFile.size());
-	in.close();
+    std::string shaderFile = ReadFile(fileName);

 	GLuint shader = glCreateShader(shaderType);
 	if (GLERROR("glCreateShader"))
 		return 0;

+    std::size_t startPos = 0;
+    std::size_t SEofNewFile[2];
+    std::string key = "#include";
+    while((startPos = shaderFile.find(key, startPos)) != std::string::npos)
+    {
+        SEofNewFile[0] = shaderFile.find('"', startPos+key.length())+1;
+        SEofNewFile[1] = shaderFile.find('"', SEofNewFile[0]);
+        if (SEofNewFile[0] == std::string::npos || SEofNewFile[1] == std::string::npos)
+            return 0;
+
+        std::string replacementFileName = shaderFile.substr(SEofNewFile[0], SEofNewFile[1] - SEofNewFile[0]);
+        std::string replacementString = ReadFile(replacementFileName);
+        size_t firstof = replacementString.find_first_of((char)0);
+        replacementString.erase(firstof, replacementString.size() - firstof);
+        if (replacementString.length() <= 0)
+            return 0;
+        shaderFile.replace(startPos, SEofNewFile[1]+2 - startPos, replacementString + "\n");
+        startPos += replacementString.length(); //This might not be wanted.
+    }
+
 	const GLchar* shaderFiles = shaderFile.c_str();
 	const GLint length = static_cast<GLint>(shaderFile.length());
 	glShaderSource(shader, 1, &shaderFiles, &length);
@@ -46,6 +56,24 @@ GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
 	return shader;
 }

+std::string Shader::ReadFile(std::string fileName)
+{
+    std::string shaderFile;
+    std::ifstream in(fileName, std::ios::in);
+    if (!in) {
+        LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
+        return "";
+    }
+
+    in.seekg(0, std::ios::end);
+    shaderFile.resize((int)in.tellg());
+    in.seekg(0, std::ios::beg);
+    in.read(&shaderFile[0], shaderFile.size());
+    in.close();
+    return shaderFile;
+}
+
+
 Shader::Shader(GLenum shaderType, std::string fileName) : m_ShaderType(shaderType), m_FileName(fileName)
 {
 	m_ShaderHandle = 0;
@@ -321,6 +321,8 @@ Skeleton::~Skeleton()
    for (auto &kv : Bones) {
        delete kv.second;
    }
+
+    BlendTrees.clear();
 }

 const Skeleton::Animation* Skeleton::GetAnimation(std::string name)
@@ -4,18 +4,6 @@ Texture::Texture(std::string path)
 {
    PNG* img = ResourceManager::Load<PNG, true>(path); //TODO: Make this threaded. Catch exeptions in all other load places.

-    //PNG image(path);
-
-    //if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
-    //    //image = PNG("Textures/Core/ErrorTexture.png");
-    //    //return; // Temporary fix to remove crash
-
-    //    if (img->Width == 0 && img->Height == 0 || img->Format == Image::ImageFormat::Unknown) {
-    //        LOG_ERROR("Couldn't even load the error texture. This is a dark day indeed.");
-    //        return;
-    //    }
-    //}
-
    this->Width = img->Width;
    this->Height = img->Height;
    this->Data = img->Data;
@@ -29,9 +17,9 @@ Texture::Texture(std::string path)
        format = GL_RGBA;
        break;
    }
-    
-
+   
    // Construct the OpenGL texture
+
    glGenTextures(1, &m_Texture);
    glBindTexture(GL_TEXTURE_2D, m_Texture);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
@@ -0,0 +1,11 @@
+#include "Rendering/TextureSprite.h"
+
+TextureSprite::TextureSprite(std::string path)
+    :Texture(path)
+{
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+    GLERROR("Texture load");
+}
@@ -1,23 +1,5 @@
 #include "Rendering/Util/CommonFunctions.h"

-Texture* CommonFunctions::LoadTexture(std::string path, bool threaded)
-{
-    Texture* img;
-    try {
-        if(threaded) {
-            img = ResourceManager::Load<Texture, true>(path);
-        } else {
-            img = ResourceManager::Load<Texture, false>(path);
-        }
-    } catch (const Resource::StillLoadingException&) {
-        img = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
-    } catch (const std::exception&) {
-        img = nullptr;
-    }
-
-    return img;
-}
-
 void CommonFunctions::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)
 {
 	glDeleteTextures(1, texture);
@@ -37,7 +37,7 @@ ScreenCoords::PixelData ScreenCoords::ToPixelData(float x, float y, FrameBuffer*
    glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pdata);
 	GLERROR("glReadPixels(pdata) Error");
    PickDataBuffer->Unbind();
-
+	GLERROR("Unbind Error");
    glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer); 
 	GLERROR("glBindFramebuffer(DepthBuffer) Error");
    float depthData;