118 lines
3.6 KiB
C
118 lines
3.6 KiB
C
|
|
uniform mat4 g_ModelViewProjectionMatrix;
|
|
uniform mat4 g_ModelMatrixInverse;
|
|
|
|
uniform vec3 g_OrientationUp;
|
|
uniform vec3 g_OrientationRight;
|
|
uniform vec3 g_OrientationForward;
|
|
|
|
uniform vec3 g_ViewUp;
|
|
uniform vec3 g_ViewRight;
|
|
uniform vec3 g_EyePosition;
|
|
|
|
uniform vec4 g_RenderVar0;
|
|
uniform vec4 g_RenderVar1;
|
|
uniform vec4 g_Texture0Resolution;
|
|
|
|
#if REFRACT
|
|
uniform float g_RefractAmount; // {"material":"ui_editor_properties_refract_amount","default":0.05,"range":[-1,1]}
|
|
#endif
|
|
|
|
void ComputeParticleTangents(in vec3 rotation, inout mat3 mRotation, out vec3 right, out vec3 up)
|
|
{
|
|
vec3 rCos = cos(rotation);
|
|
vec3 rSin = sin(rotation);
|
|
// Apply particle rotation
|
|
mRotation = mul(mul(
|
|
mat3(rCos.z, -rSin.z, 0,
|
|
rSin.z, rCos.z, 0,
|
|
0, 0, 1),
|
|
mat3(1, 0, 0,
|
|
0, rCos.x, -rSin.x,
|
|
0, rSin.x, rCos.x)),
|
|
mat3(rCos.y, 0, rSin.y,
|
|
0, 1, 0,
|
|
-rSin.y, 0, rCos.y));
|
|
// Apply screen orientation
|
|
mRotation = mul(mRotation, mat3(g_OrientationRight, g_OrientationUp, g_OrientationForward));
|
|
right = mul(vec3(1, 0, 0), mRotation);
|
|
up = mul(vec3(0, 1, 0), mRotation);
|
|
}
|
|
|
|
void ComputeParticleTrailTangents(vec3 localPosition, vec3 localVelocity, out vec3 right, out vec3 up)
|
|
{
|
|
//vec3 eyeDirection = mul(g_OrientationForward, CAST3X3(g_ModelMatrixInverse));
|
|
vec3 eyeDirection = localPosition - mul(vec4(g_EyePosition, 1.0), g_ModelMatrixInverse).xyz;
|
|
right = cross(localVelocity, eyeDirection);
|
|
|
|
right = normalize(right);
|
|
float trailLength = length(localVelocity);
|
|
localVelocity /= trailLength;
|
|
up = localVelocity * min(trailLength * g_RenderVar0.x, g_RenderVar0.y);
|
|
}
|
|
|
|
vec3 ComputeParticlePosition(vec2 uvs, float textureRatio, vec4 positionAndSize, vec3 right, vec3 up)
|
|
{
|
|
return positionAndSize.xyz +
|
|
(positionAndSize.w * right * (uvs.x-0.5) -
|
|
positionAndSize.w * up * (uvs.y-0.5) * textureRatio);
|
|
}
|
|
|
|
void ComputeSpriteFrame(float lifetime, out vec4 uvs, out vec2 uvFrameSize, out float frameBlend)
|
|
{
|
|
float numFrames = g_RenderVar1.z;
|
|
float frameWidth = g_RenderVar1.x;
|
|
float frameHeight = g_RenderVar1.y;
|
|
|
|
float currentFrame = floor(lifetime * numFrames);
|
|
float nextFrame = min(numFrames - 1.0, currentFrame + 1.0);
|
|
|
|
#if SPRITESHEETBLENDNPOT
|
|
float unpaddedWidth = g_Texture0Resolution.z / g_Texture0Resolution.x;
|
|
float scaledFrameWidth = frameWidth / unpaddedWidth;
|
|
uvs.y = floor(currentFrame * scaledFrameWidth) * frameHeight;
|
|
uvs.x = frac(currentFrame * scaledFrameWidth) * unpaddedWidth;
|
|
uvs.w = floor(nextFrame * scaledFrameWidth) * frameHeight;
|
|
uvs.z = frac(nextFrame * scaledFrameWidth) * unpaddedWidth;
|
|
#else
|
|
uvs.y = floor(currentFrame * frameWidth) * frameHeight;
|
|
uvs.x = frac(currentFrame * frameWidth);
|
|
uvs.w = floor(nextFrame * frameWidth) * frameHeight;
|
|
uvs.z = frac(nextFrame * frameWidth);
|
|
#endif
|
|
|
|
frameBlend = frac(lifetime * numFrames);
|
|
uvFrameSize = vec2(frameWidth, frameHeight);
|
|
}
|
|
|
|
void ComputeScreenRefractionTangents(in vec3 projectedPositionXYW, in mat3 matZRotation, out vec3 v_ScreenCoord, out vec4 v_ScreenTangents)
|
|
{
|
|
v_ScreenCoord = projectedPositionXYW;
|
|
#ifdef HLSL
|
|
v_ScreenCoord.y = -v_ScreenCoord.y;
|
|
#endif
|
|
|
|
vec3 right = mul(matZRotation, g_ViewRight);
|
|
vec3 up = mul(matZRotation, g_ViewUp);
|
|
|
|
|
|
right = mul(right, CAST3X3(g_ModelMatrixInverse));
|
|
up = mul(up, CAST3X3(g_ModelMatrixInverse));
|
|
|
|
right = normalize(right);
|
|
up = normalize(up);
|
|
|
|
right.y = -right.y;
|
|
up.y = -up.y;
|
|
|
|
v_ScreenTangents.xy = vec3(dot(right, g_ViewRight),
|
|
dot(up, -g_ViewRight), 0).xy;
|
|
v_ScreenTangents.zw = vec3(dot(right, g_ViewUp),
|
|
dot(up, -g_ViewUp), 0).xy;
|
|
|
|
#if REFRACT
|
|
v_ScreenTangents *= g_RefractAmount;
|
|
#endif
|
|
}
|
|
|