Files
cocos4/editor/assets/chunks/particle-vs-gpu.chunk
T
2022-02-22 16:19:15 +08:00

355 lines
11 KiB
Plaintext

precision mediump float;
#include <transform>
#include <particle-common>
#include <cc-local>
#pragma define CURVE_MODE_FIX 1
#pragma define CURVE_MODE_BLEND 2
#pragma define GRADIENT_MODE_FIX 1
#pragma define GRADIENT_MODE_BLEND 2
#pragma define SIMULATE_SPACE_LOCAL 0
#pragma define SIMULATE_SPACE_WORLD 1
#pragma define ANIMATION_MODE_WHOLE_SHEET 0
#pragma define ANIMATION_MODE_SINGLE_ROW 1
#pragma define COLOR_OVERTIME_RAND_OFFSET 91041.
#pragma define FORCE_OVERTIME_RAND_OFFSET 212165.
#pragma define ROTATION_OVERTIME_RAND_OFFSET 125292.
#pragma define SIZE_OVERTIME_RAND_OFFSET 39825.
#pragma define TEXTURE_ANIMATION_RAND_OFFSET 90794.
#pragma define VELOCITY_OVERTIME_RAND_OFFSET 197866.
uniform SampleConstants {
vec4 u_sampleInfo;
};
uniform TickConstants {
vec4 u_worldRot;
vec4 u_timeDelta;
};
in vec4 a_position_starttime; // center position,particle start time
in vec4 a_size_uv; // xyz:size, w:uv_0
in vec4 a_rotation_uv; // xyz:rotation, w:uv_1
in vec4 a_color;
in vec4 a_dir_life; // xyz:particle start velocity,w:particle lifetime
in float a_rndSeed;
#if CC_RENDER_MODE == RENDER_MODE_MESH
in vec3 a_texCoord; // mesh uv
in vec3 a_texCoord3; // mesh vertices
in vec3 a_normal; // mesh normal
in vec4 a_color1; // mesh color
#endif
vec3 unpackCurveData (sampler2D tex, vec2 coord) {
vec4 a = texture(tex, coord);
vec4 b = texture(tex, coord + u_sampleInfo.y);
float c = fract(coord.x * u_sampleInfo.x);
return mix(a.xyz, b.xyz, c);
}
vec3 unpackCurveData (sampler2D tex, vec2 coord, out float w) {
vec4 a = texture(tex, coord);
vec4 b = texture(tex, coord + u_sampleInfo.y);
float c = fract(coord.x * u_sampleInfo.x);
w = mix(a.w, b.w, c);
return mix(a.xyz, b.xyz, c);
}
vec4 unpackGradientData (sampler2D tex, vec2 coord) {
return texture(tex, coord);
}
vec4 scaleAndAdd (vec4 a, vec4 b, float scale) {
a.x += b.x * scale;
a.y += b.y * scale;
a.z += b.z * scale;
return a;
}
// Vulkan compatible issue#9858, do not use large number (more than 100) in mod function
float pseudoRandom(float x) {
#if USE_VK_SHADER
float o = x;
x = mod(x - 1.0, 2.0) - 1.0;
float freqVar = 10.16640753482; //3.1415927*(sqrt(5.0)+1.0);
float y = sin(freqVar * floor(o * 0.5 - 0.5)); // some pseudorandom hash
float v = max(0.0, 1.0-abs(x));
v *= 0.7071067812; // fix sheared 'distance' measurements - but this is 1D so unsure it's even a good thing to try
v = y < 0.0 ? -v : v;
return v;
#else
float seed = mod(x, 233280.);
float q = (seed * 9301. + 49297.) / 233280.;
return fract(q);
#endif
}
#if COLOR_OVER_TIME_MODULE_ENABLE
uniform sampler2D color_over_time_tex0;
uniform ColorConstant {
int u_color_mode;
};
#endif
#if ROTATION_OVER_TIME_MODULE_ENABLE
uniform sampler2D rotation_over_time_tex0;
uniform RotationConstant {
int u_rotation_mode;
};
#endif
#if SIZE_OVER_TIME_MODULE_ENABLE
uniform sampler2D size_over_time_tex0;
uniform SizeConstant {
int u_size_mode;
};
#endif
#if FORCE_OVER_TIME_MODULE_ENABLE
uniform sampler2D force_over_time_tex0;
uniform ForceConstant {
int u_force_mode;
int u_force_space;
};
#endif
#if VELOCITY_OVER_TIME_MODULE_ENABLE
uniform sampler2D velocity_over_time_tex0;
uniform VelocityConstant {
int u_velocity_mode;
int u_velocity_space;
};
#endif
#if TEXTURE_ANIMATION_MODULE_ENABLE
uniform sampler2D texture_animation_tex0;
uniform AnimationConstant {
vec4 u_anim_info;
};
#endif
float repeat (float t, float length) {
return t - floor(t / length) * length;
}
vec4 rotateQuat (vec4 p, vec4 q) {
vec3 iv = cross(q.xyz, p.xyz) + q.w * p.xyz;
vec3 res = p.xyz + 2.0 * cross(q.xyz, iv);
return vec4(res.xyz, p.w);
}
float random (float seed) {
seed = mod(seed, 233280.);
float q = (seed * 9301. + 49297.) / 233280.;
return fract(q);
}
#pragma define INDENTIFY_NEG_QUAT 10.0
vec4 toQuat(vec3 rotation) {
vec3 rotTmp = rotation;
float mulFactor = 1.0;
if (rotTmp.x > INDENTIFY_NEG_QUAT * 0.5) {
rotTmp.x -= INDENTIFY_NEG_QUAT;
mulFactor = -1.0;
}
vec4 rot = vec4(rotTmp, 0.0);
rot.w = mulFactor * sqrt(abs(1.0 - rot.x * rot.x - rot.y * rot.y - rot.z * rot.z));
return rot;
}
vec4 gpvs_main () {
float activeTime = u_timeDelta.x - a_position_starttime.w;
float normalizedTime = clamp(activeTime / a_dir_life.w, 0.0, 1.0);
vec2 timeCoord0 = vec2(normalizedTime, 0.);
vec2 timeCoord1 = vec2(normalizedTime, 1.);
#if CC_RENDER_MODE == RENDER_MODE_MESH
vec2 vertIdx = vec2(a_texCoord.x, a_texCoord.y);
#else
vec2 vertIdx = vec2(a_size_uv.w, a_rotation_uv.w);
#endif
vec4 velocity = vec4(a_dir_life.xyz, 0.);
vec4 pos = vec4(a_position_starttime.xyz, 1.);
// size
vec3 size = a_size_uv.xyz;
#if SIZE_OVER_TIME_MODULE_ENABLE
if (u_size_mode == CURVE_MODE_FIX) {
size *= unpackCurveData(size_over_time_tex0, timeCoord0);
} else {
vec3 size_0 = unpackCurveData(size_over_time_tex0, timeCoord0);
vec3 size_1 = unpackCurveData(size_over_time_tex0, timeCoord1);
float factor_s = pseudoRandom(a_rndSeed + SIZE_OVERTIME_RAND_OFFSET);
size *= mix(size_0, size_1, factor_s);
}
#endif
vec3 compScale = scale.xyz * size;
// force
#if FORCE_OVER_TIME_MODULE_ENABLE
vec3 forceAnim = vec3(0.);
if (u_force_mode == CURVE_MODE_FIX) {
forceAnim = unpackCurveData(force_over_time_tex0, timeCoord0);
} else {
vec3 force_0 = unpackCurveData(force_over_time_tex0, timeCoord0);
vec3 force_1 = unpackCurveData(force_over_time_tex0, timeCoord1);
float factor_f = pseudoRandom(a_rndSeed + FORCE_OVERTIME_RAND_OFFSET);
forceAnim = mix(force_0, force_1, factor_f);
}
vec4 forceTrack = vec4(forceAnim, 0.);
if (u_force_space == SIMULATE_SPACE_LOCAL) {
forceTrack = rotateQuat(forceTrack, u_worldRot);
}
velocity.xyz += forceTrack.xyz;
#endif
// velocity
#if VELOCITY_OVER_TIME_MODULE_ENABLE
float speedModifier0 = 1.;
float speedModifier1 = 1.;
vec3 velocityAnim = vec3(0.);
if (u_velocity_mode == CURVE_MODE_FIX) {
velocityAnim = unpackCurveData(velocity_over_time_tex0, timeCoord0, speedModifier0);
} else {
vec3 vectory_0 = unpackCurveData(velocity_over_time_tex0, timeCoord0, speedModifier0);
vec3 vectory_1 = unpackCurveData(velocity_over_time_tex0, timeCoord1, speedModifier1);
float factor_v = pseudoRandom(a_rndSeed + VELOCITY_OVERTIME_RAND_OFFSET);
velocityAnim = mix(vectory_0, vectory_1, factor_v);
speedModifier0 = mix(speedModifier0, speedModifier1, factor_v);
}
vec4 velocityTrack = vec4(velocityAnim, 0.);
if (u_velocity_space == SIMULATE_SPACE_LOCAL) {
velocityTrack = rotateQuat(velocityTrack, u_worldRot);
}
velocity.xyz += velocityTrack.xyz;
velocity.xyz *= speedModifier0;
#endif
pos.xyz += velocity.xyz * normalizedTime * a_dir_life.w;
#if !CC_USE_WORLD_SPACE
pos = cc_matWorld * pos;
#if CC_RENDER_MODE == RENDER_MODE_STRETCHED_BILLBOARD
velocity = rotateQuat(velocity, u_worldRot);
#endif
#endif
// rotation
vec3 startRotation = a_rotation_uv.xyz;
#if CC_RENDER_MODE != RENDER_MODE_MESH
#if CC_RENDER_MODE == RENDER_MODE_BILLBOARD
vec3 rotEuler = startRotation.xyz;
#elif CC_RENDER_MODE == RENDER_MODE_STRETCHED_BILLBOARD
vec3 rotEuler = vec3(0.);
#else
vec3 rotEuler = vec3(0., 0., startRotation.z);
#endif
vec4 rot = quaternionFromEuler(rotEuler);
#else
vec4 rot = quaternionFromEuler(startRotation);
#endif
#if ROTATION_OVER_TIME_MODULE_ENABLE
if (u_rotation_mode == CURVE_MODE_FIX) {
vec3 euler = unpackCurveData(rotation_over_time_tex0, timeCoord0) * normalizedTime * a_dir_life.w;
vec4 quat = eulerToQuat(euler);
mat3 mLocal = quatToMat3(quat);
mat3 mStart = quatToMat3(rot);
rot = mat3ToQuat(mStart * mLocal);
} else {
vec3 rotation_0 = unpackCurveData(rotation_over_time_tex0, timeCoord0);
vec3 rotation_1 = unpackCurveData(rotation_over_time_tex0, timeCoord1);
float factor_r = pseudoRandom(a_rndSeed + ROTATION_OVERTIME_RAND_OFFSET);
vec3 euler = mix(rotation_0, rotation_1, factor_r) * normalizedTime * a_dir_life.w;
#if CC_RENDER_MODE == RENDER_MODE_VERTICAL_BILLBOARD || CC_RENDER_MODE == RENDER_MODE_HORIZONTAL_BILLBOARD
euler = vec3(0.0, 0.0, euler.z);
#endif
vec4 quat = eulerToQuat(euler);
mat3 mLocal = quatToMat3(quat);
mat3 mStart = quatToMat3(rot);
rot = mat3ToQuat(mStart * mLocal);
}
#endif
// color
#if COLOR_OVER_TIME_MODULE_ENABLE
if (u_color_mode == GRADIENT_MODE_FIX) {
color = a_color * texture(color_over_time_tex0, timeCoord0);
} else {
vec4 color_0 = texture(color_over_time_tex0, timeCoord0);
vec4 color_1 = texture(color_over_time_tex0, timeCoord1);
float factor_c = pseudoRandom(a_rndSeed + COLOR_OVERTIME_RAND_OFFSET);
color = a_color * mix(color_0, color_1, factor_c);
}
#else
color = a_color;
#endif
#if CC_RENDER_MODE != RENDER_MODE_MESH
vec2 cornerOffset = vec2((vertIdx - 0.5));
#if CC_RENDER_MODE == RENDER_MODE_STRETCHED_BILLBOARD
rot = vec4(0.0, 0.0, 0.0, 1.0);
#endif
computeVertPos(pos, cornerOffset, rot, compScale
#if CC_RENDER_MODE == RENDER_MODE_BILLBOARD || CC_RENDER_MODE == RENDER_MODE_VERTICAL_BILLBOARD
, cc_matViewInv
#endif
#if CC_RENDER_MODE == RENDER_MODE_STRETCHED_BILLBOARD
, cc_cameraPos.xyz
, velocity
, frameTile_velLenScale.z
, frameTile_velLenScale.w
, a_size_uv.w
#endif
);
#else
mat3 rotMat = quatToMat3(rot);
mat3 nodeMat = quatToMat3(nodeRotation);
rotMat = nodeMat * rotMat;
rot = mat3ToQuat(rotMat);
mat4 xformNoScale = matrixFromRT(rot, pos.xyz);
mat4 xform = matFromRTS(rot, pos.xyz, compScale);
pos = xform * vec4(a_texCoord3, 1);
vec4 normal = xformNoScale * vec4(a_normal, 0);
color *= a_color1;
#endif
pos = cc_matViewProj * pos;
float frameIndex = 0.;
#if TEXTURE_ANIMATION_MODULE_ENABLE
float startFrame = 0.;
vec3 frameInfo = vec3(0.);
if (int(u_anim_info.x) == GRADIENT_MODE_FIX) {
frameInfo = unpackCurveData(texture_animation_tex0, timeCoord0);
} else {
vec3 frameInfo0 = unpackCurveData(texture_animation_tex0, timeCoord0);
vec3 frameInfo1 = unpackCurveData(texture_animation_tex0, timeCoord1);
float factor_t = pseudoRandom(a_rndSeed + TEXTURE_ANIMATION_RAND_OFFSET);
frameInfo = mix(frameInfo0, frameInfo1, factor_t);
}
startFrame = frameInfo.x / u_anim_info.y;
frameIndex = repeat(u_anim_info.z * (frameInfo.y + startFrame), 1.);
#endif
uv = computeUV(frameIndex, vertIdx, frameTile_velLenScale.xy) * mainTiling_Offset.xy + mainTiling_Offset.zw;
return pos;
}