BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #173 from teamfisk/ExplosionEffectV2

Browse Source 
Explosion effect v2
This commit is contained in:
Simon Holmberg
2016-03-12 15:25:12 +01:00
parent e7a3793486 4df936ca70
commit 068e151741
7 changed files with 138 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Rendering/ExplosionEffectJob.h
+5 -1
View File
@@ -27,6 +27,8 @@ struct ExplosionEffectJob : ModelJob
Velocity = (glm::vec2)explosionEffectComponent["Velocity"];
ColorByDistance = (bool)explosionEffectComponent["ColorByDistance"];
ExponentialAccelaration = (bool)explosionEffectComponent["ExponentialAccelaration"];
Reverse = (bool)explosionEffectComponent["Reverse"];
ColorDistanceScalar = (double)explosionEffectComponent["ColorDistanceScalar"];
};
glm::vec3 ExplosionOrigin;
@@ -38,12 +40,14 @@ struct ExplosionEffectJob : ModelJob
glm::vec4 EndColor;
bool Randomness = false;
float RandomnessScalar = 1.f;
double RandomnessScalar = 1.f;
glm::vec2 Velocity;
bool ColorByDistance = false;
//bool ReverseAnimation = false;
//bool Wireframe = false;
bool ExponentialAccelaration = false;
bool Reverse = false;
double ColorDistanceScalar = 1.f;
std::array<float, 50> RandomNumbers = {
0.3257552917701f,
include/Game/Systems/ExplosionEffectSystem.h
+1
View File
@@ -3,6 +3,7 @@
#include "Common.h"
#include "Core/System.h"
#include "Engine/GLM.h"
class ExplosionEffectSystem : public PureSystem
{
resources/Schema/Components/ExplosionEffect.xml
+9 -7
View File
@@ -1,19 +1,21 @@
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<ExplosionEffect xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ExplosionEffect.xsd">
<ExplosionOrigin X="0" Y="0" Z="0"/>
<TimeSinceDeath>0</TimeSinceDeath>
<ExplosionDuration>2</ExplosionDuration>
<TimeSinceDeath>0.0</TimeSinceDeath>
<ExplosionDuration>2.0</ExplosionDuration>
<Speed>1</Speed>
<Delay>0</Delay>
<!--<Gravity>1</Gravity>-->
<!--<GravityForce>1</GravityForce>-->
<!--<ObjectRadius>2</ObjectRadius>-->
<EndColor R="0" G="0" B="0" A="0"/>
<Randomness>0</Randomness>
<RandomnessScalar>1</RandomnessScalar>
<Randomness>false</Randomness>
<RandomnessScalar>1.0</RandomnessScalar>
<Velocity X="2" Y="2"/>
<ColorByDistance>0</ColorByDistance>
<!--<ReverseAnimation>0</ReverseAnimation>-->
<ColorByDistance>false</ColorByDistance>
<!--<Wireframe>0</Wireframe>-->
<ExponentialAccelaration>0</ExponentialAccelaration>
<ExponentialAccelaration>false</ExponentialAccelaration>
<Pulsate>false</Pulsate>
<Reverse>false</Reverse>
<ColorDistanceScalar>1.0</ColorDistanceScalar>
</ExplosionEffect>
resources/Schema/Components/ExplosionEffect.xsd
+9 -3
View File
@@ -44,15 +44,21 @@
<xs:element name="ColorByDistance" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Change the color by its moved distance instead of by its time</xs:documentation></xs:annotation>
</xs:element>
<!--<xs:element name="ReverseAnimation" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Implosions are cooler</xs:documentation></xs:annotation>
</xs:element>-->
<!--<xs:element name="Wireframe" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Enable/disable wireframe</xs:documentation></xs:annotation>
</xs:element>-->
<xs:element name="ExponentialAccelaration" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Linear/Exponential accelaration</xs:documentation></xs:annotation>
</xs:element>
<xs:element name="Pulsate" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Pulsate the effect</xs:documentation></xs:annotation>
</xs:element>
<xs:element name="Reverse" type="t:bool" minOccurs="0">
<xs:annotation><xs:documentation>Reverse the effect</xs:documentation></xs:annotation>
</xs:element>
<xs:element name="ColorDistanceScalar" type="t:double" minOccurs="0">
<xs:annotation><xs:documentation>Scale the distance of the color change</xs:documentation></xs:annotation>
</xs:element>
</xs:all>
</xs:complexType>
</xs:element>
resources/Shaders/ExplosionEffect.geom.glsl
+94 -122
View File
@@ -15,6 +15,11 @@ uniform float RandomnessScalar;
uniform vec2 Velocity;
uniform bool ColorByDistance;
uniform bool ExponentialAccelaration;
uniform bool Reverse;
uniform float ColorDistanceScalar;
//uniform bool Gravity;
//uniform bool Rotation;
//uniform bool MaxRadius;
in VertexData{
vec3 Position;
@@ -41,169 +46,136 @@ out VertexData{
layout(triangles) in;
layout(triangle_strip, max_vertices = 3) out;
float EqualTo(float x, float y) {
return 1.0 - abs(sign(x - y));
}
float NotEqualTo(float x, float y) {
return abs(sign(x - y));
}
float GreaterThan(float x, float y) {
return max(sign(x - y), 0.0);
}
float LessThan(float x, float y) {
return max(sign(y - x), 0.0);
}
float GreaterEqualTo(float x, float y) {
return 1.0 - LessThan(x, y);
}
float LessEqualTo(float x, float y) {
return 1.0 - GreaterThan(x, y);
}
// returns a "random" number based on input parameter
float GetRandomNumber(int polygon_index)
{
int randomIndex = int(mod(polygon_index, 50));
return RandomNumbers[randomIndex];
return RandomNumbers[int(mod(polygon_index, 50))];
}
float randomNumber = 0.0;
float randomDistance = 0.0;
void main()
vec3 CalcCenterOfTriangle(vec3 vertex0, vec3 vertex1, vec3 vertex2)
{
// calculate middle of 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 dir1 = normalize(vertex1 - vertex0);
vec3 dir2 = normalize(vertex2 - vertex0);
// calculate intersection
// normalize direction
vec3 dir1 = normalize(v1);
vec3 dir2 = normalize(v2);
vec3 vecA = Input[2].Position - Input[1].Position; //o2 - o1
vec3 vecA = vertex2 - vertex1; //o2 - o1
vec3 vecB = cross(dir1, dir2);
mat3 matrisA = mat3(vecA, dir2, vecB);
float lengthA = length(vecB);
lengthA = lengthA * lengthA;
float s = determinant(matrisA) / lengthA;
// center position of triangle
vec3 centerOfTriangle = Input[1].Position + (s * dir1);
return vertex1 + (s * dir1);
}
void PassThingsThrough(int index)
{
// pass through vertex data
Output.Normal = Input[index].Normal;
Output.Position = Input[index].Position;
Output.TextureCoordinate = Input[index].TextureCoordinate;
Output.Tangent = Input[index].Tangent;
Output.BiTangent = Input[index].BiTangent;
Output.ExplosionColor = EndColor;
}
void main()
{
vec3 centerOfTriangle = CalcCenterOfTriangle(Input[0].Position, Input[1].Position, Input[2].Position);
// center position of triangle to origin vector
vec3 origin2TriangleCenterVector = centerOfTriangle - ExplosionOrigin;
vec3 normalizedOrigin2TriangleCenterVector = normalize(origin2TriangleCenterVector);
// distance between origin and the center of the current triangle
float origin2TriangleCenterDistance = length(origin2TriangleCenterVector);
// time percentage until end of explosion (0.0-1.0)
float timePercetage = TimeSinceDeath / ExplosionDuration;
// get a random number if randomness is enabled, otherwise the random number will be zero and won't affect the other algorithms
if (Randomness == true)
{
randomDistance = GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar;
}
// get a random number if randomness is enabled, otherwise the random distance will be zero and won't affect the other algorithms
float randomDistance = float(Randomness) * GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar;
vec2 randomVelocity = Velocity * (randomDistance + 1.0);
// accelaration to use on current frame. is a interpolation between start and end value
float currentVelocity = mix(randomVelocity.x, randomVelocity.y, timePercetage);
if (ExponentialAccelaration == true)
{
currentVelocity = pow(currentVelocity, 2) / 2.0;
}
// if the accelaration should be exponential
currentVelocity = currentVelocity * max(currentVelocity * float(ExponentialAccelaration), 1.0);
// distance between origin and the center of the current triangle
float origin2TriangleCenterDistance = length(origin2TriangleCenterVector);
// the distance the blast has moved since the beginning, i.e. its radius
float blastWave = TimeSinceDeath * currentVelocity;
// the distance from origin to the triangle center with eventual randomness added
float fullDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
// vector from the triangle center to the explosion's shockwave
vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * (TimeSinceDeath * currentVelocity)) - (normalizedOrigin2TriangleCenterVector * fullDistanceWithRandomness);
float origin2TriangleCenterDistanceWithRandomness = origin2TriangleCenterDistance + randomDistance;
// if the triangle is inside the blast radius...
if (fullDistanceWithRandomness <= (TimeSinceDeath * currentVelocity))
vec3 triangleCenter2ExplosionRadius = (normalizedOrigin2TriangleCenterVector * blastWave) - (normalizedOrigin2TriangleCenterVector * origin2TriangleCenterDistanceWithRandomness);
// if the triangle is inside the blast's radius...
float isInsideBlastRadius = LessEqualTo(origin2TriangleCenterDistanceWithRandomness, blastWave);
// calculate the max distance (s) the triangle will move
float accelaration = (randomVelocity.y - randomVelocity.x) / ExplosionDuration;
float maxDistance = (randomVelocity.x * ExplosionDuration) + (0.5 * accelaration * ExplosionDuration * ExplosionDuration);
// if explosion color should be affected by distance instead of time...
if (ColorByDistance == true)
{
float maxRadius = max(TimeSinceDeath * currentVelocity, (ExplosionDuration * currentVelocity));
float a = (randomVelocity.y - randomVelocity.x) / ExplosionDuration;
//float t = sqrt((2 * origin2TriangleCenterDistance) / a);
// if explosion color should be affected by distance instead of time...
if (ColorByDistance == true)
{
// calculate the max distance (s) the triangle will move
float s = (randomVelocity.x * ExplosionDuration) + (0.5 * a * pow(ExplosionDuration, 2));
float te = (length(triangleCenter2ExplosionRadius) / s);
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = te;
}
else
{
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = timePercetage;
}
// for every vertex on the triangle...
for (int i = 0; i < gl_in.length(); i++)
{
// move the triangle to the blast radius
vec3 ExplodedPosition = Input[i].Position + triangleCenter2ExplosionRadius;
// pass through vertex data
Output.Normal = Input[i].Normal;
Output.Position = Input[i].Position;
Output.TextureCoordinate = Input[i].TextureCoordinate;
Output.Tangent = Input[i].Tangent;
Output.BiTangent = Input[i].BiTangent;
for (int j = 0; j < MAX_SPLITS; j++)
{
Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
}
// convert to model space for the gravity to always be in -y
vec4 ExplodedPositionInModelSpace = M * vec4(ExplodedPosition, 1.0);
// if there is gravity, apply it
//if (Gravity == true)
//{
// // ---DO THIS----> //ExplodedPositionInModelSpace.y = ExplodedPositionInModelSpace.y - TimeSinceHit;
//
// ExplodedPositionInModelSpace.y = ExplodedPositionInModelSpace.y - pow(TimeSinceDeath, 2);
//}
// convert to screen space
gl_Position = P*V * ExplodedPositionInModelSpace;
EmitVertex();
}
Output.ExplosionPercentageElapsed = (length(triangleCenter2ExplosionRadius) / maxDistance) * isInsideBlastRadius * ColorDistanceScalar;
}
else
{
// if explosion color should be affected by distance instead of time...
if (ColorByDistance == true)
{
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = 0.0;
}
else
{
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = timePercetage;
Output.ExplosionPercentageElapsed = timePercetage;
}
vec3 ExplodedPosition;
for (int i = 0; i < gl_in.length(); i++)
{
// move the triangle to the blast radius
ExplodedPosition = Input[i].Position + (triangleCenter2ExplosionRadius * isInsideBlastRadius);
}
// for every vertex on the triangle...
for(int i = 0; i < gl_in.length(); i++)
{
// pass through vertex data
Output.Normal = Input[i].Normal;
Output.Position = Input[i].Position;
Output.TextureCoordinate = Input[i].TextureCoordinate;
Output.Tangent = Input[i].Tangent;
Output.BiTangent = Input[i].BiTangent;
// pass through vertex data
PassThingsThrough(i);
for (int j = 0; j < MAX_SPLITS; j++)
{
Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
}
// no change in position, pass through vertex
gl_Position = gl_in[i].gl_Position;
EmitVertex();
}
for (int j = 0; j < MAX_SPLITS; j++)
{
Output.PositionLightSpace[j] = Input[i].PositionLightSpace[j];
}
// convert to window space
gl_Position = P * V * M * vec4(ExplodedPosition, 1.0);
EmitVertex();
}
//EndPrimitive();
}
}
src/Engine/Rendering/DrawFinalPass.cpp
+10 -1
View File
@@ -1333,7 +1333,12 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
glUniform3fv(glGetUniformLocation(shaderHandle, "ExplosionOrigin"), 1, glm::value_ptr(job->ExplosionOrigin));
GLERROR("Bind 6 uniform");
glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
if (job->Reverse == false) {
glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), job->TimeSinceDeath);
}
else {
glUniform1f(glGetUniformLocation(shaderHandle, "TimeSinceDeath"), (job->ExplosionDuration - job->TimeSinceDeath));
}
GLERROR("Bind 7 uniform");
glUniform1f(glGetUniformLocation(shaderHandle, "ExplosionDuration"), job->ExplosionDuration);
GLERROR("Bind 8 uniform");
@@ -1351,6 +1356,10 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
GLERROR("Bind 14 uniform");
glUniform1i(glGetUniformLocation(shaderHandle, "ExponentialAccelaration"), job->ExponentialAccelaration);
GLERROR("Bind 15 uniform");
glUniform1i(glGetUniformLocation(shaderHandle, "Reverse"), job->Reverse);
GLERROR("Bind 15-2 uniform");
glUniform1f(glGetUniformLocation(shaderHandle, "ColorDistanceScalar"), job->ColorDistanceScalar);
GLERROR("Bind 15-3 uniform");
glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(job->Color));
GLERROR("Bind 16 uniform");
src/Game/Systems/ExplosionEffectSystem.cpp
+10 -7
View File
@@ -7,12 +7,15 @@ void ExplosionEffectSystem::UpdateComponent(EntityWrapper& entity, ComponentWrap
delay = std::max(0.0, delay - dt);
}
if (delay <= 0) {
double& timeSinceDeath = component["TimeSinceDeath"];
timeSinceDeath += (double)component["Speed"] * dt;
if (timeSinceDeath < 0 || timeSinceDeath > (double)component["ExplosionDuration"]) {
timeSinceDeath = 0.0;
}
}
if (delay <= 0) {
double& timeSinceDeath = component["TimeSinceDeath"];
timeSinceDeath += (double)component["Speed"] * dt;
if (timeSinceDeath < 0) {
timeSinceDeath = 0.0;
}
else if (timeSinceDeath >(double)component["ExplosionDuration"]) {
timeSinceDeath = (double)component["ExplosionDuration"];
}
}
}