Lots of things done

include/Engine/Rendering/DrawScenePass.h

@@ -31,6 +31,12 @@ private:
 
     ShaderProgram* m_BasicForwardProgram;
 
+    ShaderProgram* m_CoolDeathAnimProgram;
+
+    glm::vec3 Origin;
+    GLfloat TimeDeath = 0.f;
+    GLfloat EndDeath = 0.f;
+
 };
 
 #endif 

include/Engine/Rendering/RenderQueue.h

@@ -63,6 +63,17 @@ struct ModelJob : RenderJob
 	}
 };
 
+// Cool Death Animation
+struct CoolDeathAnimationJob : ModelJob
+{
+    glm::vec3 OriginPos;
+    float TimeSinceDeath = 0.f;
+    float EndOfDeath = 15.0f;
+
+};
+
+
+
 struct SpriteJob : RenderJob
 {
 	unsigned int ShaderID = 0;

include/Engine/Rendering/RenderQueueFactory.h

@@ -25,6 +25,8 @@ private:
     void FillModels(World* world, RenderQueue* renderQueue);
     void FillLights(World* world, RenderQueue* renderQueue);
 
+    void FillCoolDeathAnim(World* world, RenderQueue* renderQueue);
+
     glm::mat4 ModelMatrix(World* world, EntityID entity);
 };
 

include/Engine/Rendering/Renderer.h

@@ -119,6 +119,8 @@ private:
     ShaderProgram* m_CalculateFrustumProgram;
     ShaderProgram* m_LightCullProgram;
 
+    ShaderProgram* m_CoolDeathAnimProgram;
+
 };
 
 #endif

resources/Schema/Components.xsd

@@ -8,4 +8,5 @@
 	<xs:include schemaLocation="Components/Player.xsd"/>
 	<xs:include schemaLocation="Components/AABB.xsd"/>
 	<xs:include schemaLocation="Components/Trigger.xsd"/>
+	<xs:include schemaLocation="Components/CoolDeathAnim.xsd"/>
 </xs:schema>

resources/Schema/Components/CoolDeathAnim.xml

@@ -0,0 +1,5 @@
+<c:CoolDeathAnim>
+	<OriginPos X="0" Y="0" Z="0"/>
+	<TimeSinceDeath>0</TimeSinceDeath>
+	<EndOfDeath>15</EndOfDeath>
+</c:CoolDeathAnim>

resources/Schema/Components/CoolDeathAnim.xsd

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="CoolDeathAnim">
+		<xs:annotation>
+			<xs:documentation>A component that trigger the death effect</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="OriginPos" type="t:Vector" minOccurs="0">
+					<xs:annotation><xs:documentation>The position in which to spawn the component</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="TimeSinceDeath" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>Time since death</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="EndOfDeath" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>How long the death animation should be</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/Test.xml

@@ -66,12 +66,17 @@
 					<Components>
 						<c:Transform>
 							<Position X="0" Y="0"/>
-							<Orientation X="0.0" Y="0" Z="1.0"/>
+							<Orientation X="0.0" Y="0.0" Z="0"/>
 						</c:Transform>
 						<c:Model>
 							<Resource>Models/Core/UnitRaptor.obj</Resource>
 							<Color R="1" G="0.4" B="0.8"/>
 						</c:Model>
+						<c:CoolDeathAnim>
+							<OriginPos X="0" Y="0" Z="0"/>
+							<TimeSinceDeath>0</TimeSinceDeath>
+							<EndOfDeath>15</EndOfDeath>
+						</c:CoolDeathAnim>
 					</Components>
 					<Children>
 						<Entity>

resources/Schema/Types/Entity.xsd

@@ -15,6 +15,7 @@
 							<xs:element ref="c:Test" minOccurs="0"/>
 							<xs:element ref="c:RaptorCopter" minOccurs="0"/>
 							<xs:element ref="c:Player" minOccurs="0"/>
+							<xs:element ref="c:CoolDeathAnim" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

resources/Shaders/CoolDeathAnim.frag.glsl

@@ -0,0 +1,22 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec4 Color;
+
+uniform sampler2D texture0;
+
+in vec3 Normal;
+in vec3 Position;
+in vec2 TextureCoordinate;
+in vec4 DiffuseColor;
+
+out vec4 fragmentColor;
+
+
+void main()
+{
+	vec4 texel = texture2D(texture0, TextureCoordinate);
+	fragmentColor = texel * DiffuseColor * Color;
+}

resources/Shaders/CoolDeathAnim.geom.glsl

@@ -0,0 +1,98 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec3 OriginPos;
+uniform float TimeSinceDeath; 
+uniform float EndOfDeath; 
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+	vec4 DiffuseColor;
+}Input[];
+
+out vec3 Normal;
+out vec3 Position;
+out vec2 TextureCoordinate;
+out vec4 DiffuseColor;
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+void main()
+{
+	// surface vectors for triangle
+	//vec3 v1 = Input[1].Position - Input[0].Position;
+	//vec3 v2 = Input[2].Position - Input[0].Position;
+	
+	//vec3 v3 = Input[1].Position - OriginPos;
+	//v3 = normalize(v3);
+	
+	// surface normal
+	//vec3 normal = cross(v1, v2);
+	//normal = normalize(normal);
+	
+	// calculate middle of a vectors
+	vec3 v1 = Input[1].Position - Input[0].Position;
+	vec3 v2 = Input[2].Position - Input[0].Position;
+	vec3 v3 = Input[2].Position - (v1 / 2);
+	vec3 v4 = Input[1].Position - (v2 / 2);
+	
+	// 
+	//vec3 oriToTri = Input[1].Position - OriginPos;
+	//v5 = normalize(v3);
+	
+	
+	// calculate intersection
+	// normalize direction
+	vec3 dir1 = normalize(v1);
+	vec3 dir2 = normalize(v2);
+	
+	vec3 vecA = Input[2].Position - Input[1].Position; //o2 - o1
+	vec3 vecB = cross(dir1, dir2);
+	
+	mat3 matrisA = mat3(vecA, dir2, vecB);
+	mat3 matrisB = mat3(vecA, dir1, vecB);
+	
+	float lengthA = length(cross(dir1, dir2));
+	lengthA = lengthA * lengthA;
+
+	float s = determinant(matrisA) / lengthA;
+	float t = determinant(matrisB) / lengthA;
+	
+	// center position of triangle
+	vec3 centerPosS = Input[1].Position + (s * dir1);
+	//vec3 centerPosT = Input[2].Position + (t * dir2);
+	
+	
+	// center position of triangle to origin
+	vec3 oriToCenterTri = normalize(centerPosS - OriginPos);
+	
+	for(int i = 0; i < gl_in.length(); i++)
+	{	
+		vec4 screenPos = gl_in[i].gl_Position;
+		
+		if (distance(OriginPos, Input[0].Position) <= TimeSinceDeath)
+		{
+			vec4 changedPos = M * vec4(Input[i].Position  + (oriToCenterTri * TimeSinceDeath), 1.0); //objectspace
+			changedPos = vec4(changedPos.x, changedPos.y - pow(TimeSinceDeath, 2), changedPos.z, changedPos.w); //objectspace
+			screenPos = P*V * changedPos; //sceenspace
+		}
+		// Explosion from origin
+		
+		
+
+		Normal = Input[i].Normal;
+		Position = Input[i].Position;
+		TextureCoordinate = Input[i].TextureCoordinate;
+		DiffuseColor = vec4(Input[i].DiffuseColor.rg, Input[i].DiffuseColor.b + TimeSinceDeath, Input[i].DiffuseColor.a);
+		
+		gl_Position = screenPos;
+		//gl_Position = gl_in[i].gl_Position;
+		EmitVertex();
+	}
+	
+}

resources/Shaders/CoolDeathAnim.vert.glsl

@@ -0,0 +1,34 @@
+#version 430
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout(location = 0) in vec3 Position;
+layout(location = 1) in vec3 Normal;
+layout(location = 2) in vec3 Tangent;
+layout(location = 3) in vec3 BiTangent;
+layout(location = 4) in vec2 TextureCoords;
+layout(location = 5) in vec4 DiffuseVertexColor;
+layout(location = 6) in vec4 SpecularVertexColor;
+layout(location = 7) in vec4 BoneIndices1;
+layout(location = 8) in vec4 BoneIndices2;
+layout(location = 9) in vec4 BoneWeights1;
+layout(location = 10) in vec4 BoneWeights2;
+
+out VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+	vec4 DiffuseColor;
+}Output;
+
+void main()
+{
+	gl_Position = P*V*M * vec4(Position, 1.0);
+
+	Output.Position = Position;
+	Output.TextureCoordinate = TextureCoords;
+	Output.Normal = Normal;
+	Output.DiffuseColor = DiffuseVertexColor;
+}

src/Engine/Rendering/DrawScenePass.cpp

@@ -16,18 +16,32 @@ void DrawScenePass::InitializeShaderPrograms()
 {
     //Gör så att shaders är en resource, tex som texture classen. Konstruktorn måste vara privat.
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#BasicForwardProgram");
-
     m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/BasicForward.vert.glsl")));
     m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/BasicForward.frag.glsl")));
     m_BasicForwardProgram->Compile();
     m_BasicForwardProgram->Link();
 
+    m_CoolDeathAnimProgram = ResourceManager::Load<ShaderProgram>("#CoolDeathAnimProgram");
+    m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/CoolDeathAnim.vert.glsl")));
+    m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/CoolDeathAnim.geom.glsl")));
+    m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/CoolDeathAnim.frag.glsl")));
+    m_CoolDeathAnimProgram->Compile();
+    m_CoolDeathAnimProgram->Link();
     
 }
 
 void DrawScenePass::Draw(RenderQueueCollection& rq)
 {
-    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    if (TimeDeath > 2.f) {
+        TimeDeath = 0.f;
+    }
+
+    Origin = glm::vec3(0.f, 0.0f, 0.f);
+    TimeDeath = TimeDeath + 0.01f;
+    EndDeath = EndDeath + 0.05f;
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
     GLERROR("Renderer::Draw PickingPass");
 
     DrawScenePassState state;
@@ -35,17 +49,47 @@ void DrawScenePass::Draw(RenderQueueCollection& rq)
 
     //TODO: Render: Add code for more jobs than modeljobs.
     for (auto &job : rq.Forward) {
+        auto coolDeathAnimationJob = std::dynamic_pointer_cast<CoolDeathAnimationJob>(job);
+        if (coolDeathAnimationJob) {
+            GLuint ShaderHandle = m_CoolDeathAnimProgram->GetHandle(); //---
+                                                                       //---
+            m_CoolDeathAnimProgram->Bind();
+            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(coolDeathAnimationJob->ModelMatrix));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
+            glUniform4fv(glGetUniformLocation(ShaderHandle, "Color"), 1, glm::value_ptr(coolDeathAnimationJob->Color));
+            glUniform3fv(glGetUniformLocation(ShaderHandle, "OriginPos"), 1, glm::value_ptr(Origin));
+            glUniform1f(glGetUniformLocation(ShaderHandle, "TimeSinceDeath"), TimeDeath);
+            glUniform1f(glGetUniformLocation(ShaderHandle, "EndOfDeath"), EndDeath);
+
+            //TODO: Renderer: bättre textur felhantering samt fler texturer stöd
+            if (coolDeathAnimationJob->DiffuseTexture != nullptr) {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, coolDeathAnimationJob->DiffuseTexture->m_Texture);
+            } else {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+            }
+            glBindVertexArray(coolDeathAnimationJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, coolDeathAnimationJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, coolDeathAnimationJob->EndIndex - coolDeathAnimationJob->StartIndex + 1, GL_UNSIGNED_INT, 0, coolDeathAnimationJob->StartIndex);
+            continue;
+        }
+        
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
         if (modelJob) {
-            GLuint ShaderHandle = m_BasicForwardProgram->GetHandle();
+            GLuint ShaderHandle = m_BasicForwardProgram->GetHandle(); //---
-
+            GLERROR("1");
+            //---
             m_BasicForwardProgram->Bind();
+            GLERROR("2.1");
             //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
             glUniform4fv(glGetUniformLocation(ShaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
-
+            GLERROR("2");
             //TODO: Renderer: bättre textur felhantering samt fler texturer stöd
             if (modelJob->DiffuseTexture != nullptr) {
                 glActiveTexture(GL_TEXTURE0);
@@ -54,11 +98,11 @@ void DrawScenePass::Draw(RenderQueueCollection& rq)
                 glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
-
+            GLERROR("3");
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
             glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
-
+            GLERROR("4");
             continue;
         }
     }

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -90,21 +90,47 @@ void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
         }
 
         for (auto texGroup : model->TextureGroups) {
-            ModelJob job;
+            auto deathComp = world->HasComponent(modelC.EntityID, "CoolDeathAnim");
-            job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+            if (!deathComp) {
-            job.DiffuseTexture = texGroup.Texture.get();
+                ModelJob job;
-            job.NormalTexture = texGroup.NormalMap.get();
-            job.SpecularTexture = texGroup.SpecularMap.get();
-            job.Model = model;
-            job.StartIndex = texGroup.StartIndex;
-            job.EndIndex = texGroup.EndIndex;
-            job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
-            job.Color = color;
 
-            //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
+                job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-            job.Entity = modelC.EntityID;
+                job.DiffuseTexture = texGroup.Texture.get();
+                job.NormalTexture = texGroup.NormalMap.get();
+                job.SpecularTexture = texGroup.SpecularMap.get();
+                job.Model = model;
+                job.StartIndex = texGroup.StartIndex;
+                job.EndIndex = texGroup.EndIndex;
+                job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+                job.Color = color;
 
-            renderQueue->Add(job);
+                //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
+                job.Entity = modelC.EntityID;
+
+                renderQueue->Add(job);
+            }
+            else {
+                CoolDeathAnimationJob job;
+
+                job.TimeSinceDeath = 1.f;
+                job.EndOfDeath = 15.f;
+                job.OriginPos = glm::vec3(1000.f, 2.f, 0.f);
+
+                job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+                job.DiffuseTexture = texGroup.Texture.get();
+                job.NormalTexture = texGroup.NormalMap.get();
+                job.SpecularTexture = texGroup.SpecularMap.get();
+                job.Model = model;
+                job.StartIndex = texGroup.StartIndex;
+                job.EndIndex = texGroup.EndIndex;
+                job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+                job.Color = color;
+
+                //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
+                job.Entity = modelC.EntityID;
+
+                renderQueue->Add(job);
+            }
         }
     }
 }

src/Engine/Rendering/Renderer.cpp

@@ -76,6 +76,15 @@ void Renderer::InitializeShaders()
     m_DrawScreenQuadProgram->Compile();
     m_DrawScreenQuadProgram->Link();
 
+    m_CoolDeathAnimProgram = ResourceManager::Load<ShaderProgram>("#CoolDeathAnimProgram");
+    //m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/CoolDeathAnim.vert.glsl")));
+    //m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/CoolDeathAnim.geom.glsl")));
+    //m_CoolDeathAnimProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/CoolDeathAnim.frag.glsl")));
+    //m_CoolDeathAnimProgram->Compile();
+    //m_CoolDeathAnimProgram->Link();
+
+
+
     //m_CalculateFrustumProgram = ResourceManager::Load<ShaderProgram>("#CalculateFrustumProgram");
     //m_CalculateFrustumProgram.AddShader(std::shared_ptr<Shader>(new ComputeShader("Shaders/GridFrustum.comp.glsl")));
     //m_CalculateFrustumProgram.Compile();