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

Redid many a thing for the sake of efficiency

Browse Source
This commit is contained in:
FakeShemp
2016-02-23 10:06:21 +01:00
parent 2c18068059
commit fb80d088e4
4 changed files with 118 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
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/Entities/GameMap.xml
+7
View File
@@ -245,6 +245,13 @@
</Entity>
</Children>
</Entity>
<Entity name="Ambient">
<Components>
<c:SceneLight/>
<c:Transform/>
</Components>
<Children/>
</Entity>
</Children>
</Entity>
resources/Shaders/ExplosionEffect.geom.glsl
+98 -113
View File
@@ -13,6 +13,11 @@ uniform float RandomnessScalar;
uniform vec2 Velocity;
uniform bool ColorByDistance;
uniform bool ExponentialAccelaration;
uniform bool Reverse;
//uniform bool Gravity;
//uniform bool Rotation;
//uniform bool MaxRadius;
//uniform bool Pulsate;
in VertexData{
vec3 Position;
@@ -37,161 +42,141 @@ out VertexData{
layout(triangles) in;
layout(triangle_strip, max_vertices = 3) out;
vec3 EqualTo(vec3 x, vec3 y) {
return 1.0 - abs(sign(x - y));
}
vec3 NotEqualTo(vec3 x, vec3 y) {
return abs(sign(x - y));
}
vec3 GreaterThan(vec3 x, vec3 y) {
return max(sign(x - y), 0.0);
}
vec3 LessThan(vec3 x, vec3 y) {
return max(sign(y - x), 0.0);
}
vec3 GreaterEqualTo(vec3 x, vec3 y) {
return 1.0 - LessThan(x, y);
}
vec3 LessEqualTo(vec3 x, vec3 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 = GetRandomNumber(gl_PrimitiveIDIn) * RandomnessScalar * float(Randomness);
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(vec3(origin2TriangleCenterDistanceWithRandomness), vec3(blastWave)).x;
// 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;
// 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;
}
else
{
// if explosion color should be affected by distance instead of time...
if (ColorByDistance == true)
Output.ExplosionPercentageElapsed = timePercetage;
}
vec3 ExplodedPosition;
for (int i = 0; i < gl_in.length(); i++)
{
// move the triangle to the blast radius
if(Reverse == false)
{
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = 0.0;
ExplodedPosition = Input[i].Position + (triangleCenter2ExplosionRadius * isInsideBlastRadius);
}
else
{
Output.ExplosionColor = EndColor;
Output.ExplosionPercentageElapsed = timePercetage;
// TODO:
// Remove ifs
// account for randomness
// account for velocity
// account for color
ExplodedPosition = Input[i].Position + (triangleCenter2ExplosionRadius * maxDistance * (ExplosionDuration - TimeSinceDeath));
}
// pass through vertex data
PassThingsThrough(i);
// 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;
// no change in position, pass through vertex
gl_Position = gl_in[i].gl_Position;
EmitVertex();
}
// convert to window space
gl_Position = P * V * M * vec4(ExplodedPosition, 1.0);
EmitVertex();
}
//EndPrimitive();
}
}
src/Game/Systems/ExplosionEffectSystem.cpp
+12 -8
View File
@@ -2,13 +2,17 @@
void ExplosionEffectSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt)
{
if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
(double)component["TimeSinceDeath"] = 0.f;
}
(double&)component["TimeSinceDeath"] += dt;
if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"]) {
(double)component["TimeSinceDeath"] = 0.f;
}
//if ((bool)Component["Gravity"] == true) {
// (bool)Component["ExponentialAccelaration"] = false;
//}
}
//((glm::vec2)component["Velocity"]).x = min(((glm::vec2)component["Velocity"]).x, ((glm::vec2)component["Velocity"]).y);
(double&)component["TimeSinceDeath"] += dt;
//if ((bool)component["Pulsate"] == true) {
// if ((double)component["TimeSinceDeath"] > (double)component["ExplosionDuration"] * 0.5) {
// (bool)component["Reverse"] = true;
// }
//}
}