Merge fixes

include/Engine/Collision/Collision.h

@@ -64,7 +64,7 @@ bool RayVsModel(const Ray& ray,
     float& outVCoord);
 
 bool AABBvsTriangles(const AABB& box,
-    const std::vector<RawModel::Vertex>& modelVertices,
+    const RawModel::Vertex* modelVertices,
     const std::vector<unsigned int>& modelIndices,
     const glm::mat4& modelMatrix,
     glm::vec3& boxVelocity,

include/Engine/Rendering/DrawFinalPass.h

@@ -78,6 +78,8 @@ private:
 	ShaderProgram* m_ExplosionEffectSkinnedProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapSkinnedProgram;
 	ShaderProgram* m_ForwardPlusSplatMapSkinnedProgram;
+    ShaderProgram* m_ShieldToStencilSkinnedProgram;
+    ShaderProgram* m_FillDepthBufferSkinnedProgram;
 };
 
 #endif 

resources/Shaders/FillDepthBufferSkinned.vert.glsl

@@ -0,0 +1,33 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+
+layout(location = 0) in vec3 Position;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{
+	mat4 boneTransform = mat4(1);
+
+	if(BoneWeights[0] > 0.0f){ 
+	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
+				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
+				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
+				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
+	}
+
+	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
+
+	Output.Position = vec3(0.0);
+}

resources/Shaders/ForwardPlusSkinned.vert.glsl

@@ -38,7 +38,7 @@ void main()
 	
 	Output.Position = (boneTransform * vec4(Position, 1.0)).xyz;
 	Output.TextureCoordinate = TextureCoords;
-	Output.Normal = vec3(M * vec4(Normal, 0.0));
+	Output.Normal = vec3(M * boneTransform * vec4(Normal, 0.0));
 	Output.Tangent = vec3(M * vec4(Tangent, 0.0));
  	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);

resources/Shaders/ShieldStencilSkinned.vert.glsl

@@ -0,0 +1,33 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 Bones[100];
+
+
+layout(location = 0) in vec3 Position;
+layout(location = 5) in vec4 BoneIndices;
+layout(location = 6) in vec4 BoneWeights;
+
+
+
+out VertexData{
+	vec3 Position;
+}Output;
+
+void main()
+{
+	mat4 boneTransform = mat4(1);
+
+	if(BoneWeights[0] > 0.0f){ 
+	boneTransform = BoneWeights[0] * Bones[int(BoneIndices[0])]
+				  + BoneWeights[1] * Bones[int(BoneIndices[1])]
+				  + BoneWeights[2] * Bones[int(BoneIndices[2])]
+				  + BoneWeights[3] * Bones[int(BoneIndices[3])];
+	}
+
+	gl_Position = P*V*M*boneTransform * vec4(Position, 1.0);
+
+	Output.Position = vec3(0.0);
+}

src/Engine/Collision/Collision.cpp

@@ -183,7 +183,7 @@ bool RayVsTriangle(const Ray& ray,
     }
     outDistance = dist;
     outUCoord = glm::dot(m, DxE2) * DetInv;
-    outVCoord  = glm::dot(ray.Direction(), MxE1) * DetInv;
+    outVCoord = glm::dot(ray.Direction(), MxE1) * DetInv;
 
     //u,v can be very close to 0 but still negative sometimes. added a deltafactor to compensate for that problem
     //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
@@ -330,7 +330,7 @@ bool rectangleVsTriangle(const glm::vec2& boxMin,
         float push = rightRes < -leftRes ? rightRes : leftRes;
         float absPushSq = abs(push);
         absPushSq *= absPushSq;
-        
+
         if (absPushSq < resolutionDistanceSq) {
             resolutionDistanceSq = absPushSq;
             resolutionDirection = push * normal;
@@ -355,8 +355,8 @@ constexpr bool FaceIsGround(float faceNormalY)
 //An array containing 3 int pairs { 0, 2 }, { 0, 1 }, { 1, 2 }
 constexpr std::array<std::pair<int, int>, 3> dimensionPairs({ std::pair<int, int>(0, 2), std::pair<int, int>(0, 1), std::pair<int, int>(1, 2) });
 
-bool AABBvsTriangle(const AABB& box, 
+bool AABBvsTriangle(const AABB& box,
-    const std::array<glm::vec3, 3>& triPos, 
+    const std::array<glm::vec3, 3>& triPos,
     const glm::vec3& originalBoxVelocity,
     float verticalStepHeight,
     bool& isOnGround,
@@ -385,7 +385,7 @@ bool AABBvsTriangle(const AABB& box,
         Resolution()
             : DistanceSq(INFINITY)
             , Vector(0.f)
-        {}
+        { }
         BoxTriResolveCase Case;
         float DistanceSq;
         glm::vec3 Vector;
@@ -525,9 +525,9 @@ bool AABBvsTriangle(const AABB& box,
     return true;
 }
 
-bool AABBvsTriangles(const AABB& box, 
+bool AABBvsTriangles(const AABB& box,
-    const std::vector<RawModel::Vertex>& modelVertices, 
+    const RawModel::Vertex* modelVertices,
-    const std::vector<unsigned int>& modelIndices, 
+    const std::vector<unsigned int>& modelIndices,
     const glm::mat4& modelMatrix,
     glm::vec3& boxVelocity,
     float verticalStepHeight,
@@ -579,12 +579,11 @@ bool AttachAABBComponentFromModel(EntityWrapper entity)
 
     glm::vec3 mini(INFINITY);
     glm::vec3 maxi(-INFINITY);
-    for (const auto& v : model->m_Vertices) {
+    for (unsigned int i = 0; i < model->NumVertices(); i++) {
+        const auto& v = model->Vertices()[i];
         mini = glm::min(mini, v.Position);
-	for (unsigned int i = 0; i < modelRes->NumberOfVertices(); i++) {
+        maxi = glm::max(maxi, v.Position);
-		const auto& v = modelRes->Vertices()[i];
     }
-
     entity.AttachComponent("AABB");
     entity["AABB"]["Origin"] = 0.5f * (maxi + mini);
     entity["AABB"]["Size"] = maxi - mini;
@@ -609,4 +608,4 @@ boost::optional<EntityAABB> EntityAbsoluteAABB(EntityWrapper& entity)
     return aabb;
 }
 
-}
+}

src/Engine/Collision/CollisionSystem.cpp

@@ -41,7 +41,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
-            if (Collision::AABBvsTriangles(boxA, model->m_Vertices, model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
+            if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
                 (glm::vec3&)cTransform["Position"] += resolutionVector;
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {

src/Engine/Rendering/DrawFinalPass.cpp

@@ -142,12 +142,26 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ShieldToStencilProgram->Link();
     GLERROR("Creating Shield program");
 
+    m_ShieldToStencilSkinnedProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgramSkinned");
+    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencilSkinned.vert.glsl")));
+    m_ShieldToStencilSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
+    m_ShieldToStencilSkinnedProgram->Compile();
+    m_ShieldToStencilSkinnedProgram->Link();
+    GLERROR("Creating Shield Skinned program");
+
     m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
     m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
     m_FillDepthBufferProgram->Compile();
     m_FillDepthBufferProgram->Link();
     GLERROR("Creating DepthFill program");
+
+    m_FillDepthBufferSkinnedProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgramSkinned");
+    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBufferSkinned.vert.glsl")));
+    m_FillDepthBufferSkinnedProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthBufferSkinnedProgram->Compile();
+    m_FillDepthBufferSkinnedProgram->Link();
+    GLERROR("Creating DepthFill program");
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
@@ -181,11 +195,11 @@ void DrawFinalPass::Draw(RenderScene& scene)
     //Draw Opaque shielded objects
     state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
     state->StencilMask(0x00);
-    DrawShieldedModelRenderQueue(scene.Jobs.OpaqueShieldedObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.OpaqueShieldedObjects, scene); //might need changing
     GLERROR("Shielded Opaque object");
 
     //Draw Transparen Shielded objects
-    DrawShieldedModelRenderQueue(scene.Jobs.TransparentShieldedObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.TransparentShieldedObjects, scene); //might need changing
     GLERROR("Shielded Transparent objects");
 
     GLERROR("END");
@@ -298,100 +312,186 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
-    for(auto &job : jobs)
-    {
-        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
-        if(explosionEffectJob) {
-            //Bind program
-            if(GLERROR("Prebind")) {
-                continue;
-            }
-            m_ExplosionEffectProgram->Bind();
-            if(GLERROR("BindProgram")) {
-                continue;
-            }
 
+    for (auto &job : jobs) {
+        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
+        if (explosionEffectJob) {
+            switch (explosionEffectJob->Type) {
+            case RawModel::MaterialType::Basic:
+            case RawModel::MaterialType::SingleTextures:
+            {
+                if (explosionEffectJob->Model->isSkined()) {
+                    m_ExplosionEffectSkinnedProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSkinned program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
+                    std::vector<glm::mat4> frameBones;
+                    if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+                    } else {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+                    }
+                    glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                } else {
+                    m_ExplosionEffectProgram->Bind();
+                    GLERROR("Bind ExplosionEffect program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionHandle, explosionEffectJob);
+                }
+                break;
+            }
+            case RawModel::MaterialType::SplatMapping:
+            {
+                if (explosionEffectJob->Model->isSkined()) {
+                    m_ExplosionEffectSplatMapSkinnedProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSplatMapSkinned program");
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
+                    GLERROR("asdasd");
+                    std::vector<glm::mat4> frameBones;
+                    if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+                    } else {
+                        frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+                    }
+                    glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+                } else {
+                    m_ExplosionEffectSplatMapProgram->Bind();
+                    GLERROR("Bind ExplosionEffectSplatMap program");
+                    //bind uniforms
+                    //bind uniforms
+                    BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
+                    //bind textures
+                    BindExplosionTextures(explosionSplatMapHandle, explosionEffectJob);
+                    GLERROR("asdasd");
+                }
+                break;
+            }
+            }
             glDisable(GL_CULL_FACE);
 
-            //Bind uniforms
-            BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
-            if(GLERROR("BindExplosionUniforms")) {
-                continue;
-            }
-
-            if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                if (explosionEffectJob->Animation != nullptr) {
-                    std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
-                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-                }
-            }
-            if(GLERROR("Animation")) {
-                continue;
-            }
-
-            //bind textures
-            BindExplosionTextures(explosionEffectJob);
-            if(GLERROR("BindExplosionTextures")) {
-                continue;
-            }
             //draw
             glBindVertexArray(explosionEffectJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
             glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
             glEnable(GL_CULL_FACE);
-            if(GLERROR("explosion effect end")) {
+            GLERROR("explosion effect end");
-                continue;
+            } else {
-            }
+                auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+                if (modelJob) {
+                    //bind forward program
+                    //TODO: JOHAN/TOBIAS: Bind shader based on ModelJob->ShaderID;
+                    switch (modelJob->Type) {
+                    case RawModel::MaterialType::Basic:
+                    case RawModel::MaterialType::SingleTextures:
+                    {
+                        if (modelJob->Model->isSkined()) {
+                            m_ForwardPlusSkinnedProgram->Bind();
+                            GLERROR("Bind ForwardPlusSkinnedProgram");
+                            //bind uniforms
+                            BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardSkinnedHandle, modelJob);
+                            std::vector<glm::mat4> frameBones;
+                            if (modelJob->AnimationOffset.animation != nullptr) {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                            } else {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                            }
+                            glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-        } else {
+                        } else {
-            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+                            m_ForwardPlusProgram->Bind();
-            if (modelJob) {
+                            GLERROR("Bind ForwardPlusProgram");
-                //bind forward program
+                            //bind uniforms
-                m_ForwardPlusProgram->Bind();
+                            BindModelUniforms(forwardHandle, modelJob, scene);
-                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+                            //bind textures
-
+                            BindModelTextures(forwardHandle, modelJob);
-                //bind uniforms
+                        }
-                BindModelUniforms(forwardHandle, modelJob, scene);
+                        break;
-
-                //bind textures
-                BindModelTextures(modelJob);
-
-                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
-
-                    if (modelJob->Animation != nullptr) {
-                        std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
-                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                     }
-                }
+                    case RawModel::MaterialType::SplatMapping:
+                    {
+                        if (modelJob->Model->isSkined()) {
+                            m_ForwardPlusSplatMapSkinnedProgram->Bind();
+                            GLERROR("Bind SplatMap program");
+                            //bind uniforms
+                            BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
+                            //bind textures
+                            BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
+                            GLERROR("asdasd");
+                            std::vector<glm::mat4> frameBones;
+                            if (modelJob->AnimationOffset.animation != nullptr) {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                            } else {
+                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                            }
+                            glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-                //draw
+                        } else {
-                glBindVertexArray(modelJob->Model->VAO);
+                            m_ForwardPlusSplatMapProgram->Bind();
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+                            GLERROR("Bind SplatMap program");
-                glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
+                            //bind uniforms
-                if(GLERROR("models end")) {
+                            BindModelUniforms(forwardSplatHandle, modelJob, scene);
-                    continue;
+                            //bind textures
+                            BindModelTextures(forwardSplatHandle, modelJob);
+                            GLERROR("asdasd");
+                        }
+                        break;
+                    }
+                    }
+                    //draw
+                    glBindVertexArray(modelJob->Model->VAO);
+                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+                    glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
+                    if (GLERROR("models end")) {
+                        continue;
+                    }
                 }
             }
         }
-    }
-
 }
 
 
 void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-    m_ShieldToStencilProgram->Bind();
-    GLuint shaderHandle = m_ShieldToStencilProgram->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 : jobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
         if (modelJob) {
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
 
+            if(modelJob->Model->isSkined()) {
+                m_ShieldToStencilSkinnedProgram->Bind();
+                GLuint shaderHandle = m_ShieldToStencilSkinnedProgram->GetHandle();
+
+                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()));
+                std::vector<glm::mat4> frameBones;
+                if (modelJob->AnimationOffset.animation != nullptr) {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
+                } else {
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
+                }
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+            } else {
+                m_ShieldToStencilProgram->Bind();
+                GLuint shaderHandle = m_ShieldToStencilProgram->GetHandle();
+
+                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()));
+
+            }
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -417,139 +517,70 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
     for (auto &job : jobs) {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if (explosionEffectJob) {
-			switch (explosionEffectJob->Type) {
+            //Bind program
-				case RawModel::MaterialType::Basic:
+            if (GLERROR("Prebind")) {
-				case RawModel::MaterialType::SingleTextures:
+                continue;
-				{
+            }
-					if (explosionEffectJob->Model->isSkined()) {
+            m_ExplosionEffectProgram->Bind();
-						m_ExplosionEffectSkinnedProgram->Bind();
+            if (GLERROR("BindProgram")) {
-						GLERROR("Bind ExplosionEffectSkinned program");
+                continue;
-						//bind uniforms
+            }
-						BindExplosionUniforms(explosionSkinnedHandle, explosionEffectJob, scene);
-						//bind textures
-						BindExplosionTextures(explosionSkinnedHandle, explosionEffectJob);
-                        std::vector<glm::mat4> frameBones;
-                        if (explosionEffectJob->AnimationOffset.animation != nullptr) {
-                            frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
-                        } else {
-                            frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
-                        }
-                        glUniformMatrix4fv(glGetUniformLocation(explosionSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-					}
-					else {
-						m_ExplosionEffectProgram->Bind();
-						GLERROR("Bind ExplosionEffect program");
-						//bind uniforms
-						BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
-						//bind textures
-						BindExplosionTextures(explosionHandle, explosionEffectJob);
-					}
-					break;
-				}
-				case RawModel::MaterialType::SplatMapping:
-				{
-					if (explosionEffectJob->Model->isSkined()) {
-						m_ExplosionEffectSplatMapSkinnedProgram->Bind();
-						GLERROR("Bind ExplosionEffectSplatMapSkinned program");
-						//bind uniforms
-						BindExplosionUniforms(explosionSplatMapSkinnedHandle, explosionEffectJob, scene);
-						//bind textures
-						BindExplosionTextures(explosionSplatMapSkinnedHandle, explosionEffectJob);
-						GLERROR("asdasd");
-                        std::vector<glm::mat4> frameBones;
-                        if (explosionEffectJob->AnimationOffset.animation != nullptr) {
-                            frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
-                        } else {
-                            frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
-                        }
-                        glUniformMatrix4fv(glGetUniformLocation(explosionSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-					}
-					else {
-						m_ExplosionEffectSplatMapProgram->Bind();
-						GLERROR("Bind ExplosionEffectSplatMap program");
-						//bind uniforms
-						//bind uniforms
-						BindExplosionUniforms(explosionSplatMapHandle, explosionEffectJob, scene);
-						//bind textures
-						BindExplosionTextures(explosionSplatMapHandle, explosionEffectJob);
-						GLERROR("asdasd");
-					}
-					break;
-				}
-			}
             glDisable(GL_CULL_FACE);
 
+            //Bind uniforms
+            BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+            if (GLERROR("BindExplosionUniforms")) {
+                continue;
+            }
+
+            std::vector<glm::mat4> frameBones;
+            if (explosionEffectJob->AnimationOffset.animation != nullptr) {
+                frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations, explosionEffectJob->AnimationOffset);
+            } else {
+                frameBones = explosionEffectJob->Skeleton->GetFrameBones(explosionEffectJob->Animations);
+            }
+            glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+            if (GLERROR("Animation")) {
+                continue;
+            }
+
+            //bind textures
+            BindExplosionTextures(explosionHandle, explosionEffectJob);
+            if (GLERROR("BindExplosionTextures")) {
+                continue;
+            }
             //draw
             glBindVertexArray(explosionEffectJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
             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");
+            if (GLERROR("explosion effect end")) {
+                continue;
+            }
+
         } else {
             auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
             if (modelJob) {
                 //bind forward program
-				//TODO: JOHAN/TOBIAS: Bind shader based on ModelJob->ShaderID;
+                m_ForwardPlusProgram->Bind();
-				switch (modelJob->Type) {
+                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-					case RawModel::MaterialType::Basic:
-					case RawModel::MaterialType::SingleTextures:
-					{
-						if (modelJob->Model->isSkined()) {
-							m_ForwardPlusSkinnedProgram->Bind();
-							GLERROR("Bind ForwardPlusSkinnedProgram");
-							//bind uniforms
-							BindModelUniforms(forwardSkinnedHandle, modelJob, scene);
-							//bind textures
-							BindModelTextures(forwardSkinnedHandle, modelJob);
-                            std::vector<glm::mat4> frameBones;
-                            if (modelJob->AnimationOffset.animation != nullptr) {
-                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                            } else {
-                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                            }
-                            glUniformMatrix4fv(glGetUniformLocation(forwardSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-						} else {
+                //bind uniforms
-							m_ForwardPlusProgram->Bind();
+                BindModelUniforms(forwardHandle, modelJob, scene);
-							GLERROR("Bind ForwardPlusProgram");
+
-							//bind uniforms
+                //bind textures
-							BindModelUniforms(forwardHandle, modelJob, scene);
+                BindModelTextures(forwardHandle ,modelJob);
-							//bind textures
+
-							BindModelTextures(forwardHandle, modelJob);
+                std::vector<glm::mat4> frameBones;
-						}
+                if (modelJob->AnimationOffset.animation != nullptr) {
-						break;
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-					}
+                } else {
-					case RawModel::MaterialType::SplatMapping:
+                    frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-					{
+                }
-						if (modelJob->Model->isSkined()) {
+                glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
-							m_ForwardPlusSplatMapSkinnedProgram->Bind();
-							GLERROR("Bind SplatMap program");
-							//bind uniforms
-							BindModelUniforms(forwardSplatMapSkinnedHandle, modelJob, scene);
-							//bind textures
-							BindModelTextures(forwardSplatMapSkinnedHandle, modelJob);
-							GLERROR("asdasd");
-                            std::vector<glm::mat4> frameBones;
-                            if (modelJob->AnimationOffset.animation != nullptr) {
-                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                            } else {
-                                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                            }
-                            glUniformMatrix4fv(glGetUniformLocation(forwardSplatMapSkinnedHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
 
-						} else {
-							m_ForwardPlusSplatMapProgram->Bind();
-							GLERROR("Bind SplatMap program");
-							//bind uniforms
-							BindModelUniforms(forwardSplatHandle, modelJob, scene);
-							//bind textures
-							BindModelTextures(forwardSplatHandle, modelJob);
-							GLERROR("asdasd");
-						}
-						break;
-					}
-				}
 
                 //draw
                 glBindVertexArray(modelJob->Model->VAO);
@@ -566,25 +597,35 @@ void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<Rende
 
 void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
-    m_FillDepthBufferProgram->Bind();
+    
-    GLuint shaderHandle = m_FillDepthBufferProgram->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 : jobs) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
       
-        //bind uniforms
+        if(modelJob->Model->isSkined()) {
-        glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+            m_FillDepthBufferSkinnedProgram->Bind();
+            GLuint shaderHandle = m_FillDepthBufferSkinnedProgram->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 (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+            std::vector<glm::mat4> frameBones;
-
+            if (modelJob->AnimationOffset.animation != nullptr) {
-            if (modelJob->Animation != nullptr) {
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+            } else {
-                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
             }
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
+        } else {
+            m_FillDepthBufferProgram->Bind();
+            GLuint shaderHandle = m_FillDepthBufferProgram->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));
         }
 
+
         //draw
         glBindVertexArray(modelJob->Model->VAO);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);

src/Engine/Rendering/PickingPass.cpp

@@ -184,13 +184,14 @@ void PickingPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
             glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+            std::vector<glm::mat4> frameBones;
-
+            if (modelJob->AnimationOffset.animation != nullptr) {
-                if (modelJob->Animation != nullptr) {
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+            } else {
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                }
             }
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -230,13 +231,14 @@ void PickingPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
             glUniform2fv(glGetUniformLocation(shaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
-            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+            std::vector<glm::mat4> frameBones;
-
+            if (modelJob->AnimationOffset.animation != nullptr) {
-                if (modelJob->Animation != nullptr) {
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations, modelJob->AnimationOffset);
-                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+            } else {
-                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                frameBones = modelJob->Skeleton->GetFrameBones(modelJob->Animations);
-                }
             }
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);

src/Engine/Rendering/RenderSystem.cpp

@@ -109,7 +109,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     fillPercentage
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")){
-                TODO Calc hash
+                    explosionEffectJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(explosionEffectJob);
                 } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
                     || m_World->HasComponent(cModel.EntityID, "Player")) {
@@ -119,10 +119,9 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     }
 
                     if (cModel["Transparent"]) {
-                    TODO: Calc hash
                         Jobs.TransparentShieldedObjects.push_back(explosionEffectJob);
                     } else {
-					explosionEffectJob->CalculateHash();
+					    explosionEffectJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(explosionEffectJob);
                     }
                 } else {
@@ -131,10 +130,9 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     }
 
                     if (cModel["Transparent"]) {
-                    TODO CALC HASH
                         Jobs.TransparentObjects.push_back(explosionEffectJob);
                     } else {
-                    TODO CALC HASH
+                        explosionEffectJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(explosionEffectJob);
                     }
                 }
@@ -150,7 +148,7 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     fillPercentage
                 ));
                 if (m_World->HasComponent(cModel.EntityID, "Shield")) {
-                TODO: CALC HASH
+                    modelJob->CalculateHash();
                     Jobs.ShieldObjects.push_back(modelJob);
                 } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
                     || m_World->HasComponent(cModel.EntityID, "Player")) {
@@ -160,10 +158,9 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     }
 
                     if (cModel["Transparent"]) {
-                    TODO CALC HASH
                         Jobs.TransparentShieldedObjects.push_back(modelJob);
                     } else {
-					modelJob->CalculateHash();
+					    modelJob->CalculateHash();
                         Jobs.OpaqueShieldedObjects.push_back(modelJob);
                     }
                 } else {
@@ -172,10 +169,9 @@ void RenderSystem::fillModels(RenderScene::Queues &Jobs)
                     }
 
                     if (cModel["Transparent"]) {
-                    CALC HASH
                         Jobs.TransparentObjects.push_back(modelJob);
                     } else {
-                    CALC HASH
+                        modelJob->CalculateHash();
                         Jobs.OpaqueObjects.push_back(modelJob);
                     }
                 }
@@ -298,7 +294,8 @@ void RenderSystem::Update(double dt)
 
     fillModels(scene.Jobs);
     fillPointLights(scene.Jobs.PointLight, m_World);
-	scene.OpaqueObjects.sort();
+    //TODO: Make sure all objects needed are also sorted.
+	scene.Jobs.OpaqueObjects.sort();
     fillDirectionalLights(scene.Jobs.DirectionalLight, m_World);
     fillText(scene.Jobs.Text, m_World);
     m_RenderFrame->Add(scene);