diff --git a/Directory.Packages.props b/Directory.Packages.props index cee916b1..a08b1f07 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -14,6 +14,7 @@ + diff --git a/Game.Assets/Assets.cs b/Game.Assets/Assets.cs index 4db9a793..b8607de5 100644 --- a/Game.Assets/Assets.cs +++ b/Game.Assets/Assets.cs @@ -33,6 +33,7 @@ public static List GetRequiredAssets() { new("platform", "platform", IsDirectory: true), new("sdn/maps", "garrysmod/maps", IsDirectory: true), new("sdn/materials", "garrysmod/materials", IsDirectory: true), + new("sdn/particles", "garrysmod/particles", IsDirectory: true), new("sdn/resource", "garrysmod/resource", IsDirectory: true), new("sdn/scenes", "garrysmod/scenes", IsDirectory: true), #if GMOD_DLL diff --git a/Game.Assets/sdn/shaders/splinecard_gl460.vs b/Game.Assets/sdn/shaders/splinecard_gl460.vs new file mode 100644 index 00000000..81f56c5e --- /dev/null +++ b/Game.Assets/sdn/shaders/splinecard_gl460.vs @@ -0,0 +1,63 @@ +#version 460 + +layout(location = 0) in vec3 v_Parms; +layout(location = 2) in vec4 v_Tint; +layout(location = 10) in vec4 v_SplinePt0; +layout(location = 11) in vec4 v_SplinePt1; +layout(location = 12) in vec4 v_SplinePt2; +layout(location = 13) in vec4 v_SplinePt3; + +layout(std140, binding = 0) uniform source_matrices { + mat4 viewMatrix; + mat4 projectionMatrix; + mat4 modelMatrix; +}; + +layout(std140, binding = 5) uniform source_vs_constants { + vec4 vs_const[256]; +}; + +#include "common_gl460.vs" + +layout(location = 0) out vec2 vs_TexCoord0; +layout(location = 1) out vec2 vs_TexCoord1; +layout(location = 2) out vec4 vs_Color; +layout(location = 3) out vec4 vs_BlendFactor0; +layout(location = 4) out vec2 vs_TexCoord2; +layout(location = 5) out vec4 vs_BlendFactor1; +layout(location = 6) out vec2 vs_Seq2TexCoord0; +layout(location = 7) out vec2 vs_Seq2TexCoord1; + +#include "common_clipplanes_gl460.vs" + +vec3 DCatmullRomSpline3(vec3 a, vec3 b, vec3 c, vec3 d, float t) +{ + return 0.5 * (c - a + t * (2.0 * a - 5.0 * b + 4.0 * c - d + t * (3.0 * b - a - 3.0 * c + d)) + + t * (2.0 * a - 5.0 * b + 4.0 * c - d + 2.0 * (t * (3.0 * b - a - 3.0 * c + d)))); +} + +vec4 CatmullRomSpline(vec4 a, vec4 b, vec4 c, vec4 d, float t) +{ + return b + 0.5 * t * (c - a + t * (2.0 * a - 5.0 * b + 4.0 * c - d + t * (-a + 3.0 * b - 3.0 * c + d))); +} + +void main() +{ + vec4 posrad = CatmullRomSpline(v_SplinePt0, v_SplinePt1, v_SplinePt2, v_SplinePt3, v_Parms.x); + vec3 v2p = posrad.xyz - cEyePos; + vec3 tangent = DCatmullRomSpline3(v_SplinePt0.xyz, v_SplinePt1.xyz, v_SplinePt2.xyz, v_SplinePt3.xyz, v_Parms.x); + vec3 ofs = normalize(cross(v2p, normalize(tangent))); + posrad.xyz += ofs * (posrad.w * (v_Parms.z - 0.5)); + + gl_Position = projectionMatrix * viewMatrix * vec4(posrad.xyz, 1.0); + WriteUserClipDistances(gl_Position); + + vs_TexCoord0 = vec2(1.0 - v_Parms.z, v_Parms.y); + vs_TexCoord1 = vs_TexCoord0; + vs_Color = v_Tint; + vs_BlendFactor0 = vec4(0.0); + vs_TexCoord2 = vec2(0.0); + vs_BlendFactor1 = vec4(0.0); + vs_Seq2TexCoord0 = vec2(0.0); + vs_Seq2TexCoord1 = vec2(0.0); +} diff --git a/Game.Assets/sdn/shaders/spritecard_gl460.fs b/Game.Assets/sdn/shaders/spritecard_gl460.fs new file mode 100644 index 00000000..d9a3711b --- /dev/null +++ b/Game.Assets/sdn/shaders/spritecard_gl460.fs @@ -0,0 +1,175 @@ +#version 460 +// STATIC: "DUALSEQUENCE" "0..1" +// STATIC: "SEQUENCE_BLEND_MODE" "0..2" +// STATIC: "ADDBASETEXTURE2" "0..1" +// STATIC: "MAXLUMFRAMEBLEND1" "0..1" +// STATIC: "MAXLUMFRAMEBLEND2" "0..1" +// STATIC: "EXTRACTGREENALPHA" "0..1" +// STATIC: "COLORRAMP" "0..1" +// STATIC: "ANIMBLEND" "0..1" +// STATIC: "ADDSELF" "0..1" + +#define COMBINE_MODE_AVERAGE 0 +#define COMBINE_MODE_USE_FIRST_AS_ALPHA_MASK_ON_SECOND 1 +#define COMBINE_MODE_USE_FIRST_OVER_SECOND 2 + +layout(location = 0) in vec2 vs_TexCoord0; +layout(location = 1) in vec2 vs_TexCoord1; +layout(location = 2) in vec4 vs_Color; +layout(location = 3) in vec4 vs_BlendFactor0; +layout(location = 4) in vec2 vs_TexCoord2; +layout(location = 5) in vec4 vs_BlendFactor1; +layout(location = 6) in vec2 vs_Seq2TexCoord0; +layout(location = 7) in vec2 vs_Seq2TexCoord1; + +layout(std140, binding = 3) uniform source_pixel_sharedUBO { + bool isAlphaTesting; + int alphaTestFunc; + float alphaTestRef; +}; + +layout(std140, binding = 6) uniform source_ps_constants { + vec4 ps_const[256]; +}; + +out vec4 fragColor; + +#include "common_gl460.fs" + +layout(binding = 0) uniform sampler2D BaseTextureSampler; +layout(binding = 1) uniform sampler2D ColorRampSampler; + +#define g_Parameters ps_const[0] +#define fAdditiveBlendWeight g_Parameters.x +#define fOverbrightFactor g_Parameters.y +#define fAdditiveSelfBlendWeight g_Parameters.z + +void main() +{ + bool bMaxLumFrameBlend1 = MAXLUMFRAMEBLEND1 != 0; + bool bMaxLumFrameBlend2 = MAXLUMFRAMEBLEND2 != 0; + bool bExtractGreenAlpha = EXTRACTGREENALPHA != 0; + bool bAddBaseTexture2 = ADDBASETEXTURE2 != 0; + bool bDualSequence = DUALSEQUENCE != 0; + bool bColorRamp = COLORRAMP != 0; + int nSequenceBlendMode = SEQUENCE_BLEND_MODE; + + vec4 argbcolor = vs_Color; + + vec4 baseTex0 = texture(BaseTextureSampler, vs_TexCoord0); + vec4 baseTex1 = texture(BaseTextureSampler, vs_TexCoord1); + +#if ANIMBLEND + vec4 blended_rgb = mix(baseTex0, baseTex1, vs_BlendFactor0.x); +#else + vec4 blended_rgb = baseTex0; +#endif + + if (bMaxLumFrameBlend1) + { + float lum0 = dot(vec3(0.3, 0.59, 0.11), baseTex0.rgb * (1.0 - vs_BlendFactor0.x)); + float lum1 = dot(vec3(0.3, 0.59, 0.11), baseTex1.rgb * vs_BlendFactor0.x); + + if (lum0 > lum1) + blended_rgb = baseTex0; + else + blended_rgb = baseTex1; + } + else if (bExtractGreenAlpha) + { + blended_rgb = vec4(dot(baseTex0, vs_BlendFactor0) + dot(baseTex1, vs_BlendFactor1)); + } + +#if DUALSEQUENCE + if (bDualSequence) + { + baseTex0 = texture(BaseTextureSampler, vs_Seq2TexCoord0); + baseTex1 = texture(BaseTextureSampler, vs_Seq2TexCoord1); + + vec4 rgb2 = mix(baseTex0, baseTex1, vs_BlendFactor0.z); + + if (bMaxLumFrameBlend2) + { + float tlum0 = dot(vec3(0.3, 0.59, 0.11), baseTex0.rgb * (1.0 - vs_BlendFactor0.x)); + float tlum1 = dot(vec3(0.3, 0.59, 0.11), baseTex1.rgb * vs_BlendFactor0.x); + + if (tlum0 > tlum1) + rgb2 = baseTex0; + else + rgb2 = baseTex1; + } + + if (nSequenceBlendMode == COMBINE_MODE_AVERAGE) + { + blended_rgb = 0.5 * (blended_rgb + rgb2); + } + else if (nSequenceBlendMode == COMBINE_MODE_USE_FIRST_AS_ALPHA_MASK_ON_SECOND) + { + blended_rgb.rgb = rgb2.rgb; + } + else if (nSequenceBlendMode == COMBINE_MODE_USE_FIRST_OVER_SECOND) + { + blended_rgb.rgb = mix(blended_rgb.rgb, rgb2.rgb, rgb2.a); + } + } +#endif + + if (bColorRamp) + { + blended_rgb.rgb = texture(ColorRampSampler, vec2(blended_rgb.r, blended_rgb.g)).rgb; + } + + blended_rgb.rgb *= fOverbrightFactor; + +#if ADDBASETEXTURE2 + if (bAddBaseTexture2) + { + blended_rgb.a *= argbcolor.a; + + if (!bColorRamp) + { + blended_rgb.rgb *= blended_rgb.a; + } + + if (bExtractGreenAlpha) + { + blended_rgb.rgb += fAdditiveBlendWeight * argbcolor.a * blended_rgb.rgb; + } + else + { + blended_rgb.rgb += fOverbrightFactor * fAdditiveBlendWeight * argbcolor.a * texture(BaseTextureSampler, vs_TexCoord2).rgb; + } + + blended_rgb.rgb *= argbcolor.rgb; + } + else +#endif + { +#if ADDSELF + blended_rgb.a *= argbcolor.a; + blended_rgb.rgb *= blended_rgb.a; + blended_rgb.rgb += fOverbrightFactor * fAdditiveSelfBlendWeight * argbcolor.a * blended_rgb.rgb; + blended_rgb.rgb *= argbcolor.rgb; +#else + blended_rgb *= argbcolor; +#endif + } + + vec4 result = FinalOutput(blended_rgb, 0.0, PIXEL_FOG_TYPE_NONE, TONEMAP_SCALE_LINEAR); + + if (isAlphaTesting) + { + switch (alphaTestFunc) + { + case 0: discard; break; + case 1: if (result.a >= alphaTestRef) { discard; } break; + case 2: if (result.a != alphaTestRef) { discard; } break; + case 3: if (result.a > alphaTestRef) { discard; } break; + case 4: if (result.a <= alphaTestRef) { discard; } break; + case 5: if (result.a == alphaTestRef) { discard; } break; + case 6: if (result.a < alphaTestRef) { discard; } break; + } + } + + fragColor = result; +} diff --git a/Game.Assets/sdn/shaders/spritecard_gl460.vs b/Game.Assets/sdn/shaders/spritecard_gl460.vs new file mode 100644 index 00000000..ba043dd3 --- /dev/null +++ b/Game.Assets/sdn/shaders/spritecard_gl460.vs @@ -0,0 +1,212 @@ +#version 460 +// STATIC: "ZOOM_ANIMATE_SEQ2" "0..1" +// STATIC: "DUALSEQUENCE" "0..1" +// STATIC: "EXTRACTGREENALPHA" "0..1" +// DYNAMIC: "ORIENTATION" "0..2" + +layout(location = 0) in vec3 v_Position; +layout(location = 2) in vec4 v_Tint; +layout(location = 10) in vec4 v_TexCoord0; +layout(location = 11) in vec4 v_TexCoord1; +layout(location = 12) in vec4 v_Parms; +layout(location = 13) in vec2 v_CornerID; +layout(location = 14) in vec4 v_TexCoord2; +#if DUALSEQUENCE +layout(location = 15) in vec4 v_Seq2TexCoord0; +layout(location = 6) in vec4 v_Seq2TexCoord1; +layout(location = 3) in vec4 v_Parms1; +#endif + +layout(std140, binding = 0) uniform source_matrices { + mat4 viewMatrix; + mat4 projectionMatrix; + mat4 modelMatrix; +}; + +layout(std140, binding = 5) uniform source_vs_constants { + vec4 vs_const[256]; +}; + +#include "common_gl460.vs" + +const int SHADER_SPECIFIC_CONST_7 = 55; +const int SHADER_SPECIFIC_CONST_8 = 56; +const int SHADER_SPECIFIC_CONST_9 = 57; + +#define ScaleParms vs_const[SHADER_SPECIFIC_CONST_7] +#define OLDFRM_SCALE_START (ScaleParms.x) +#define OLDFRM_SCALE_END (ScaleParms.y) + +#define SizeParms vs_const[SHADER_SPECIFIC_CONST_8] +#define SizeParms2 vs_const[SHADER_SPECIFIC_CONST_9] + +#define MINIMUM_SIZE_FACTOR (SizeParms.x) +#define MAXIMUM_SIZE_FACTOR (SizeParms.y) +#define START_FADE_SIZE_FACTOR (SizeParms.z) +#define END_FADE_SIZE_FACTOR (SizeParms.w) +#define START_FAR_FADE (SizeParms2.x) +#define FAR_FADE_FACTOR (SizeParms2.y) + +#define BLENDFACTOR v_Parms.x +#define ROTATION v_Parms.y +#define RADIUS v_Parms.z +#define YAW v_Parms.w + +layout(location = 0) out vec2 vs_TexCoord0; +layout(location = 1) out vec2 vs_TexCoord1; +layout(location = 2) out vec4 vs_Color; +layout(location = 3) out vec4 vs_BlendFactor0; +layout(location = 4) out vec2 vs_TexCoord2; +layout(location = 5) out vec4 vs_BlendFactor1; +layout(location = 6) out vec2 vs_Seq2TexCoord0; +layout(location = 7) out vec2 vs_Seq2TexCoord1; + +#include "common_clipplanes_gl460.vs" + +#if ZOOM_ANIMATE_SEQ2 +float getlerpscaled(float l_in, float s0, float s1, float ts) +{ + l_in = 2.0 * (l_in - 0.5); + l_in *= mix(s0, s1, ts); + return 0.5 + 0.5 * l_in; +} + +float getlerpscale_for_old_frame(float l_in, float ts) +{ + return getlerpscaled(l_in, OLDFRM_SCALE_START, OLDFRM_SCALE_END, ts); +} + +float getlerpscale_for_new_frame(float l_in, float ts) +{ + return getlerpscaled(l_in, 1.0, OLDFRM_SCALE_START, ts); +} +#endif + +void main() +{ + vec4 tint = vec4(GammaToLinear(v_Tint.rgb), v_Tint.a); + + vec2 sc_yaw = vec2(cos(YAW), sin(YAW)); + vec2 sc = vec2(cos(ROTATION), sin(ROTATION)); + + vec2 ix = 2.0 * v_CornerID.xy - 1.0; + float x1 = dot(ix, sc); + float y1 = sc.x * ix.y - sc.y * ix.x; + + vec4 projPos; + vec3 worldPos = (modelMatrix * vec4(v_Position, 1.0)).xyz; + + float rad = RADIUS; + vec3 v2p = worldPos - cEyePos; + float l = length(v2p); + rad = max(rad, MINIMUM_SIZE_FACTOR * l); + + if (rad > START_FADE_SIZE_FACTOR * l) + { + if (rad > END_FADE_SIZE_FACTOR * l) + { + tint = vec4(0.0); + rad = 0.0; + } + else + { + tint *= 1.0 - (rad - START_FADE_SIZE_FACTOR * l) / (END_FADE_SIZE_FACTOR * l - START_FADE_SIZE_FACTOR * l); + } + } + + float tscale = 1.0 - min(1.0, max(0.0, (l - START_FAR_FADE) * FAR_FADE_FACTOR)); + tint *= tscale; + + if (tscale <= 0.0) + rad = 0.0; + + rad = min(rad, MAXIMUM_SIZE_FACTOR * l); + +#if ORIENTATION == 0 + vec3 viewPos = (viewMatrix * vec4(worldPos, 1.0)).xyz; + + vec3 disp = vec3(-x1, y1, 0.0); + float tmpx = disp.x * sc_yaw.x + disp.z * sc_yaw.y; + disp.z = disp.z * sc_yaw.x - disp.x * sc_yaw.y; + disp.x = tmpx; + + viewPos.xyz += disp * rad; + + projPos = projectionMatrix * vec4(viewPos, 1.0); +#endif + +#if ORIENTATION == 1 + if (l > rad / 2.0) + { + vec3 up = vec3(0.0, 0.0, 1.0); + vec3 right = normalize(cross(up, v2p)); + float tmpx = right.x * sc_yaw.x + right.y * sc_yaw.y; + right.y = right.y * sc_yaw.x - right.x * sc_yaw.y; + right.x = tmpx; + + worldPos += (x1 * rad) * right; + worldPos.z += (y1 * rad) * up.z; + + if (l < rad * 2.0) + { + tint *= smoothstep(rad / 2.0, rad, l); + } + } + projPos = projectionMatrix * viewMatrix * vec4(worldPos, 1.0); +#endif + +#if ORIENTATION == 2 + vec3 wpos = v_Position + RADIUS * vec3(y1, x1, 0.0); + projPos = projectionMatrix * viewMatrix * modelMatrix * vec4(wpos, 1.0); +#endif + + vs_BlendFactor0 = vec4(BLENDFACTOR, 0.0, 0.0, 0.0); + gl_Position = projPos; + WriteUserClipDistances(gl_Position); + + vs_TexCoord0 = mix(v_TexCoord0.zw, v_TexCoord0.xy, v_CornerID.xy); + vs_TexCoord1 = mix(v_TexCoord1.zw, v_TexCoord1.xy, v_CornerID.xy); + vs_TexCoord2 = mix(v_TexCoord2.zw, v_TexCoord2.xy, v_CornerID.xy); + + vs_Seq2TexCoord0 = vec2(0.0); + vs_Seq2TexCoord1 = vec2(0.0); + +#if DUALSEQUENCE + vec2 lerpold = v_CornerID.xy; + vec2 lerpnew = v_CornerID.xy; + +#if ZOOM_ANIMATE_SEQ2 + lerpold.x = getlerpscale_for_old_frame(v_CornerID.x, v_Parms1.x); + lerpold.y = getlerpscale_for_old_frame(v_CornerID.y, v_Parms1.x); + lerpnew.x = getlerpscale_for_new_frame(v_CornerID.x, v_Parms1.x); + lerpnew.y = getlerpscale_for_new_frame(v_CornerID.y, v_Parms1.x); +#endif + + vs_Seq2TexCoord0 = mix(v_Seq2TexCoord0.zw, v_Seq2TexCoord0.xy, lerpold); + vs_Seq2TexCoord1 = mix(v_Seq2TexCoord1.zw, v_Seq2TexCoord1.xy, lerpnew); + + vs_BlendFactor0.z = v_Parms1.x; +#endif + + vs_BlendFactor1 = vec4(0.0); + +#if EXTRACTGREENALPHA + if (BLENDFACTOR < 0.25) + { + vs_BlendFactor0.a = BLENDFACTOR * 2.0 + 0.5; + vs_BlendFactor0.g = 1.0 - vs_BlendFactor0.a; + } + else if (BLENDFACTOR < 0.75) + { + vs_BlendFactor1.g = BLENDFACTOR * 2.0 - 0.5; + vs_BlendFactor0.a = 1.0 - vs_BlendFactor1.g; + } + else + { + vs_BlendFactor1.a = BLENDFACTOR * 2.0 - 1.5; + vs_BlendFactor1.g = 1.0 - vs_BlendFactor1.a; + } +#endif + + vs_Color = tint; +} diff --git a/Game.Client/C_BaseAnimating.cs b/Game.Client/C_BaseAnimating.cs index c6ff6d8d..dc4f4748 100644 --- a/Game.Client/C_BaseAnimating.cs +++ b/Game.Client/C_BaseAnimating.cs @@ -286,6 +286,24 @@ public void Dispose() { BoneMergeCache? BoneMergeCache; + public void GetBoneTransform(int bone, out Matrix3x4 boneToWorld) { + BoneCache cache = GetBoneCache(null); + ref Matrix3x4 matrix = ref cache.GetCachedBone(bone); + if (Unsafe.IsNullRef(ref matrix)) { + MathLib.MatrixCopy(EntityToWorldTransform(), out boneToWorld); + return; + } + MathLib.MatrixCopy(matrix, out boneToWorld); + } + + public bool GetRootBone(out Matrix3x4 rootBone) { + if (IsEffectActive(EntityEffects.BoneMerge) && GetMoveParent() != null && BoneMergeCache != null) + return BoneMergeCache.GetRootBone(out rootBone); + + GetBoneTransform(0, out rootBone); + return true; + } + static long ModelBoneCounter; long MostRecentModelBoneCounter; long MostRecentBoneSetupRequest; @@ -408,12 +426,84 @@ public virtual void FireEvent(in Vector3 origin, in QAngle angles, int ev, strin case (int)AnimEventId.AE_CL_STOPSOUND: StopSound(GetSoundSourceIndex(), options); break; + case (int)AnimEventId.AE_CL_CREATE_PARTICLE_EFFECT: { + int attachment = -1; + nexttoken(out ReadOnlySpan token, options, ' ', out ReadOnlySpan next); + ReadOnlySpan mtoken = ModifyEventParticles(token); + if (mtoken.IsEmpty) + return; + string particleEffect = mtoken.ToString(); + + nexttoken(out token, next, ' ', out next); + int attachType = GetAttachTypeFromString(token); + if (attachType == -1) { + Warning($"Invalid attach type specified for particle effect anim event. Trying to spawn effect '{particleEffect}' with attach type of '{token}'\n"); + return; + } + + nexttoken(out token, next, ' ', out _); + if (!token.IsEmpty) { + attachment = atoi(token); + if (token[0] != '0' && attachment == 0) { + attachment = LookupAttachment(token); + if (attachment <= 0) { + Warning($"Failed to find attachment point specified for particle effect anim event. Trying to spawn effect '{particleEffect}' on attachment named '{token}'\n"); + return; + } + } + } + + ParticleProp().Create(particleEffect, (ParticleAttachment)attachType, attachment); + } + break; + case (int)AnimEventId.AE_CL_STOP_PARTICLE_EFFECT: { + nexttoken(out ReadOnlySpan token, options, ' ', out ReadOnlySpan next); + string particleEffect = token.ToString(); + nexttoken(out token, next, ' ', out _); + ParticleProp().StopParticlesNamed(particleEffect, token.Equals("instantly", StringComparison.OrdinalIgnoreCase)); + } + break; + case (int)AnimEventId.AE_CL_ADD_PARTICLE_EFFECT_CP: { + nexttoken(out ReadOnlySpan token, options, ' ', out ReadOnlySpan next); + string particleEffect = token.ToString(); + + nexttoken(out token, next, ' ', out next); + int controlPoint = atoi(token); + + nexttoken(out token, next, ' ', out next); + int attachType = GetAttachTypeFromString(token); + if (attachType == -1) { + Warning($"Invalid attach type specified for particle effect anim event. Trying to spawn effect '{particleEffect}' with attach type of '{token}'\n"); + return; + } + + nexttoken(out token, next, ' ', out _); + int attachment = atoi(token); + if ((token.IsEmpty || token[0] != '0') && attachment == 0) { + attachment = LookupAttachment(token); + if (attachment == -1) { + Warning($"Failed to find attachment point specified for particle effect anim event. Trying to spawn effect '{particleEffect}' on attachment named '{token}'\n"); + return; + } + } + + int effectIndex = ParticleProp().FindEffect(particleEffect); + if (effectIndex == -1) { + Warning($"Failed to find specified particle effect. Trying to add CP to '{particleEffect}' on attachment named '{token}'\n"); + return; + } + + ParticleProp().AddControlPoint(effectIndex, controlPoint, this, (ParticleAttachment)attachType, attachment); + } + break; case CL_EVENT_SOUND: FireObsoleteEvent(in origin, in angles, ev, options); break; } } + public virtual ReadOnlySpan ModifyEventParticles(ReadOnlySpan token) => token; + public virtual void FireObsoleteEvent(in Vector3 origin, in QAngle angles, int ev, string options) { switch (ev) { case CL_EVENT_SOUND: { @@ -556,7 +646,51 @@ protected virtual void ApplyBoneMatrixTransform(ref Matrix3x4 transform) { } } - public void DelayedInitModelEffects() { /* todo */ } + public void InitModelEffects() { + DelayInitModelEffects = true; + ParticleProp().StopParticlesInvolving(this); + HasAttachedParticles = false; + } + + public void DelayedInitModelEffects() { + if (!ShouldDraw()) + return; + + DelayInitModelEffects = false; + + ReadOnlySpan keyValueText = modelinfo.GetModelKeyValueText(GetModel()); + KeyValues modelKeyValues = new(""); + if (keyValueText.IsEmpty || !modelKeyValues.LoadFromBuffer(modelinfo.GetModelName(GetModel()), keyValueText)) + return; + + KeyValues? allParticleEffects = modelKeyValues.FindKey("Particles"); + if (allParticleEffects == null) + return; + + for (KeyValues? singleEffect = allParticleEffects.GetFirstSubKey(); singleEffect != null; singleEffect = singleEffect.GetNextKey()) { + string particleEffect = singleEffect.GetString("name", "").ToString(); + ReadOnlySpan attachmentName = singleEffect.GetString("attachment_point", ""); + ReadOnlySpan attachTypeName = singleEffect.GetString("attachment_type", ""); + + int attachType = GetAttachTypeFromString(attachTypeName); + if (attachType == -1) { + Warning($"Invalid attach type specified for particle effect in model '{GetModelName()}' keyvalues section. Trying to spawn effect '{particleEffect}' with attach type of '{attachTypeName}'\n"); + return; + } + + int attachment = atoi(attachmentName); + if ((attachmentName.IsEmpty || attachmentName[0] != '0') && attachment == 0) { + attachment = LookupAttachment(attachmentName); + if (attachment <= 0) { + Warning($"Failed to find attachment point specified for particle effect in model '{GetModelName()}' keyvalues section. Trying to spawn effect '{particleEffect}' on attachment named '{attachmentName}'\n"); + return; + } + } + + ParticleProp().Create(particleEffect, (ParticleAttachment)attachType, attachment); + HasAttachedParticles = true; + } + } public void ClearRagdoll() { /* todo */ } public override void Simulate() { @@ -595,6 +729,23 @@ public void RemoveBaseAnimatingInterpolatedVars() { memhandle_t HitboxBoneCacheHandle; + public bool HitboxToWorldTransforms(out Span bones, Span boneIndices) { + bones = default; + if (GetModel() == null) + return false; + StudioHdr? studioHdr = GetModelPtr(); + if (studioHdr == null) + return false; + int hitboxSet = GetHitboxSet(); + if (hitboxSet < 0 || hitboxSet >= studioHdr.NumHitboxSets()) + return false; + if (studioHdr.HitboxSet(hitboxSet).NumHitboxes == 0) + return false; + BoneCache cache = GetBoneCache(studioHdr); + cache.ReadCachedBonePointers(out bones, boneIndices); + return true; + } + public BoneCache GetBoneCache(StudioHdr? studioHdr) { int boneMask = Studio.BONE_USED_BY_HITBOX; BoneCache cache = Studio.GetBoneCache(HitboxBoneCacheHandle); @@ -1168,6 +1319,8 @@ public static class SequenceProxy SetPoseParameter(hdr, i, 0.0f); } + InitModelEffects(); + EyeAttachment = LookupAttachment("eyes"); if (ShouldInterpolate()) @@ -1339,15 +1492,15 @@ public C_BaseAnimating() { DynamicModelPending = false; ResetSequenceInfoOnLoad = false; - InitModelEffects = false; DelayInitModelEffects = false; + HasAttachedParticles = false; Cycle = 0; OldCycle = 0; } bool DelayInitModelEffects; - bool InitModelEffects; + bool HasAttachedParticles; bool DynamicModelAllowed; bool DynamicModelPending; @@ -1470,6 +1623,14 @@ public override void PostDataUpdate(DataUpdateType updateType) { iv_Cycle.Reset(); } } + + bool shouldDraw = ShouldDraw(); + if (shouldDraw && shouldDraw != OldShouldDraw) + InitModelEffects(); + else if (!shouldDraw && HasAttachedParticles) { + ParticleProp().StopParticlesInvolving(this); + HasAttachedParticles = false; + } } [Flags] diff --git a/Game.Client/C_BaseCombatWeapon.cs b/Game.Client/C_BaseCombatWeapon.cs index ee088128..e9c30c70 100644 --- a/Game.Client/C_BaseCombatWeapon.cs +++ b/Game.Client/C_BaseCombatWeapon.cs @@ -54,6 +54,8 @@ public bool IsCarriedByLocalPlayer() { public bool ShouldDrawUsingViewModel() => IsCarriedByLocalPlayer() && !C_BasePlayer.ShouldDrawLocalPlayer(); + public virtual bool GetTracerOrigin(ref System.Numerics.Vector3 origin) => false; + public void Redraw() { // if (clientMode.ShouldDrawCrosshair()) todo DrawCrosshair(); diff --git a/Game.Client/C_BaseEntity.cs b/Game.Client/C_BaseEntity.cs index a34dd59b..15aaf3d9 100644 --- a/Game.Client/C_BaseEntity.cs +++ b/Game.Client/C_BaseEntity.cs @@ -285,6 +285,10 @@ public partial class C_BaseEntity : IClientEntity public virtual C_BaseAnimating? GetBaseAnimating() => null; + readonly ParticleProperty Particles = new(); + public ParticleProperty ParticleProp() => Particles; + public virtual void OnNewParticleEffect(string particleName, CNewParticleEffect newParticleEffect) { } + public virtual bool IsWorld() => EntIndex() == 0; public virtual bool IsPlayer() => false; public virtual bool IsBaseCombatCharacter() => false; @@ -783,6 +787,7 @@ private static void RecvProxy_MoveType(ref readonly RecvProxyData data, object i public float Gravity; public C_BaseEntity() { + ParticleProp().Init(this); GMOD_EHANDLEForModify() = new(); AddVar(this, DA_Origin, IV_Origin, LatchFlags.LatchSimulationVar); AddVar(this, DA_Rotation, IV_Rotation, LatchFlags.LatchSimulationVar); @@ -1265,6 +1270,8 @@ public virtual bool GetRenderBoundsOverride(out Vector3 mins, out Vector3 maxs) } #endif + public bool IsBrushModel() => modelinfo.GetModelType(Model) == ModelType.Brush; + public void GetRenderBounds(out Vector3 mins, out Vector3 maxs) { #if GMOD_DLL if (GetRenderBoundsOverride(out mins, out maxs)) @@ -1473,6 +1480,8 @@ public virtual void Term() { DestroyModelInstance(); RemoveFromLeafSystem(); RemoveFromAimEntsList(); + + Particles.StopEmission(null, false, true); } public bool OnPredictedEntityRemove(bool isbeingremoved, C_BaseEntity predicted) { @@ -1867,6 +1876,8 @@ protected void MarkMessageReceived() { public void SetDormant(bool dormant) { Dormant = dormant; UpdateVisibility(); + + ParticleProp().OwnerSetDormantTo(dormant); } public ref readonly BaseHandle GetClientHandle() => ref RefEHandle; @@ -2596,7 +2607,7 @@ private void RemoveAllDecals() { public bool DestroyedOnRecreateEntities; public void SetDestroyedOnRecreateEntities() { - // ParticleProp().StopEmission(null, false); + ParticleProp().StopEmissionAndDestroyImmediately(); DestroyedOnRecreateEntities = true; } diff --git a/Game.Client/C_BasePlayer.cs b/Game.Client/C_BasePlayer.cs index 814b7e05..a510094c 100644 --- a/Game.Client/C_BasePlayer.cs +++ b/Game.Client/C_BasePlayer.cs @@ -748,6 +748,12 @@ public virtual float GetFOV() { return vm; } + public virtual C_BaseAnimating? GetRenderedWeaponModel() { + if (!ShouldDrawLocalPlayer() && IsLocalPlayer()) + return GetViewModel(0, true); + return GetActiveWeapon(); + } + public IClientVehicle? GetVehicle() { C_BaseEntity? vehicleEnt = Vehicle.Get(); return vehicleEnt?.GetClientVehicle(); diff --git a/Game.Client/C_ParticleSystem.cs b/Game.Client/C_ParticleSystem.cs index cab86ef4..15728ad3 100644 --- a/Game.Client/C_ParticleSystem.cs +++ b/Game.Client/C_ParticleSystem.cs @@ -2,6 +2,9 @@ using Source; using Source.Common; +using Source.Common.Mathematics; + +using System.Numerics; namespace Game.Client; @@ -36,5 +39,136 @@ public partial class C_ParticleSystem : C_BaseEntity public InlineArrayNewMaxControlPoints ControlPointParents = new(); [NetworkVar("m_bWeatherEffect")] public bool WeatherEffect; -} + bool OldActive; + + public override void PreDataUpdate(DataUpdateType updateType) { + OldActive = Active; + + base.PreDataUpdate(updateType); + } + + public override void PostDataUpdate(DataUpdateType updateType) { + base.PostDataUpdate(updateType); + + if (updateType == DataUpdateType.Created) { + if (Active) + SetNextClientThink(gpGlobals.CurTime); + } + else if (OldActive != Active) { + if (Active) + SetNextClientThink(gpGlobals.CurTime); + else + ParticleProp().StopEmission(); + } + } + + public override void ClientThink() { + if (!Active) + return; + + ReadOnlySpan name = HLClient.GetParticleSystemNameFromIndex(EffectIndex); + if (name.IsEmpty) + return; + + if (!GameRules.g_pGameRules!.AllowMapParticleEffect(name)) + return; + + if (WeatherEffect && !GameRules.g_pGameRules.AllowWeatherParticles()) + return; + + CNewParticleEffect? effect = ParticleProp().Create(name.ToString(), ParticleAttachment.AbsOriginFollow); + AssertMsg(effect != null, $"Particle system couldn't make {name}"); + if (effect == null) + return; + + for (int i = 0; i < InlineArrayNewMaxControlPoints.kMAXCONTROLPOINTS; ++i) { + C_BaseEntity? onEntity = ControlPointEnts[i].Get(); + if (onEntity != null) + ParticleProp().AddControlPoint(effect, i + 1, onEntity, ParticleAttachment.AbsOriginFollow); + + AssertMsg(ControlPointParents[i] <= InlineArrayNewMaxControlPoints.kMAXCONTROLPOINTS, $"Particle system specified bogus control point parent ({ControlPointParents[i]}) for point {i}."); + + if (ControlPointParents[i] != 0) + effect.SetControlPointParent(i + 1, ControlPointParents[i]); + } + + ParticleProp().OnParticleSystemUpdated(effect, 0.0f); + + float timeDelta = (float)(gpGlobals.CurTime - (float)StartTime); + if (timeDelta > 0.01f) + effect.SkipToTime(timeDelta); + } + + static void ParticleEffectCallback(EffectData data) { + if (EffectData.SuppressingParticleEffects()) + return; + + string name = HLClient.GetParticleSystemNameFromIndex(data.HitBox).ToString(); + + CNewParticleEffect? effect; + if ((data.Flags & PARTICLE_DISPATCH_FROM_ENTITY) != 0) { + if (!data.Entity.IsValid()) + return; + C_BaseEntity? ent = Instance(data.Entity); + if (ent == null || ent.IsDormant()) + return; + + if ((data.Flags & PARTICLE_DISPATCH_RESET_PARTICLES) != 0) + ent.ParticleProp().StopEmission(); + + Vector3 offset = Vector3.Zero; + ParticleAttachment attachType = (ParticleAttachment)data.DamageType; + if (attachType == ParticleAttachment.AbsOriginFollow || attachType == ParticleAttachment.PointFollow || attachType == ParticleAttachment.RootBoneFollow) + offset = data.Start; + + effect = ent.ParticleProp().Create(name, attachType, data.AttachmentIndex, offset); + if (effect == null) + return; + + effect.AddRef(); + if (effect.IsValid() && attachType == ParticleAttachment.CustomOrigin) + SetupCustomOrigin(effect, data); + } + else { + if (GameRules.g_pGameRules != null) + name = GameRules.g_pGameRules.TranslateEffectForVisionFilter("particles", name).ToString(); + + effect = CNewParticleEffect.Create(null, name); + effect.AddRef(); + if (effect.IsValid()) + SetupCustomOrigin(effect, data); + } + + if (effect.IsValid()) { + if (data.HasCustomColors) { + effect.SetControlPoint(EffectData.CUSTOM_COLOR_CP1, data.CustomColors.Color1); + effect.SetControlPoint(EffectData.CUSTOM_COLOR_CP2, data.CustomColors.Color2); + } + + if (data.HasControlPoint1) + effect.SetControlPoint(1, data.ControlPoint1.Offset); + } + + effect.Release(); + } + + static void SetupCustomOrigin(CNewParticleEffect effect, EffectData data) { + effect.SetSortOrigin(data.Origin); + effect.SetControlPoint(0, data.Origin); + effect.SetControlPoint(1, data.Start); + MathLib.AngleVectors(data.Angles, out Vector3 forward, out Vector3 right, out Vector3 up); + effect.SetControlPointOrientation(0, forward, right, up); + } + + static readonly ClientEffectRegistration ClientEffectReg_ParticleEffectCallback = new("ParticleEffect", ParticleEffectCallback); + + static void ParticleEffectStopCallback(EffectData data) { + if (!data.Entity.IsValid()) + return; + C_BaseEntity? ent = Instance(data.Entity); + ent?.ParticleProp().StopEmission(); + } + + static readonly ClientEffectRegistration ClientEffectReg_ParticleEffectStopCallback = new("ParticleEffectStop", ParticleEffectStopCallback); +} diff --git a/Game.Client/C_TEEffectDispatch.cs b/Game.Client/C_TEEffectDispatch.cs index 83407e24..eaa72cf7 100644 --- a/Game.Client/C_TEEffectDispatch.cs +++ b/Game.Client/C_TEEffectDispatch.cs @@ -3,7 +3,25 @@ using Source.Common; using System.Numerics; -namespace Game.Client; +namespace Game.Client; + +public delegate void ClientEffectCallback(EffectData data); + +public sealed class ClientEffectRegistration +{ + public static ClientEffectRegistration? Head; + + public readonly string EffectName; + public readonly ClientEffectCallback Function; + public readonly ClientEffectRegistration? Next; + + public ClientEffectRegistration(string effectName, ClientEffectCallback fn) { + EffectName = effectName; + Function = fn; + Next = Head; + Head = this; + } +} [NetworkName("CTEEffectDispatch")] public partial class C_TEEffectDispatch : C_BaseTempEntity @@ -15,11 +33,36 @@ public partial class C_TEEffectDispatch : C_BaseTempEntity [NetworkVar("m_EffectData")] public readonly EffectData EffectData = new(); + + public override void PostDataUpdate(DataUpdateType updateType) { + ReadOnlySpan effectName = HLClient.g_pStringTableEffectDispatch!.GetString(EffectData.EffectName); + if (!effectName.IsEmpty) + DispatchEffectToCallback(effectName, EffectData); + } } public static partial class TempEnts { - public static void TE_DispatchEffect(IRecipientFilter filter, float delay, in Vector3 pos, ReadOnlySpan name, EffectData data) { - throw new NotImplementedException(); + public static void DispatchEffectToCallback(ReadOnlySpan effectName, EffectData data) { + if (g_Lua == null) + return; + + for (ClientEffectRegistration? reg = ClientEffectRegistration.Head; reg != null; reg = reg.Next) { + if (effectName.Equals(reg.EffectName, StringComparison.OrdinalIgnoreCase)) { + reg.Function(data); + return; + } + } + + DevMsg($"DispatchEffect: effect '{effectName}' not found on client\n"); } + + public static void TE_DispatchEffect(IRecipientFilter filter, float delay, in Vector3 pos, ReadOnlySpan name, EffectData data) => DispatchEffectToCallback(name, data); + + public static void DispatchEffect(ReadOnlySpan name, EffectData data) { + PASFilter filter = new(data.Origin); + DispatchEffect(name, data, filter); + } + + public static void DispatchEffect(ReadOnlySpan name, EffectData data, C_RecipientFilter filter) => te.DispatchEffect(filter, 0.0f, data.Origin, name, data); } diff --git a/Game.Client/ClientEntityList.cs b/Game.Client/ClientEntityList.cs index 3c063110..a199bab9 100644 --- a/Game.Client/ClientEntityList.cs +++ b/Game.Client/ClientEntityList.cs @@ -67,6 +67,13 @@ public void Release() { MaxUsedServerIndex = -1; } + public BaseHandle EntIndexToHandle(int entnum) { + if (entnum < -1) + return INVALID_CLIENTENTITY_HANDLE; + IClientUnknown? unk = GetListedEntity(entnum); + return unk != null ? unk.GetRefEHandle() : INVALID_CLIENTENTITY_HANDLE; + } + public IClientUnknown? GetClientUnknownFromHandle(in BaseHandle ent) { return (IClientUnknown?)LookupEntity(ent); } diff --git a/Game.Client/ClientModeShared.cs b/Game.Client/ClientModeShared.cs index c9a87219..456530cf 100644 --- a/Game.Client/ClientModeShared.cs +++ b/Game.Client/ClientModeShared.cs @@ -109,6 +109,7 @@ public void Init() { public bool IsTyping() => ChatElement!.GetMessageMode() != MessageModeType.None; public bool ShouldDrawDetailObjects() => true; + public bool ShouldDrawParticles() => true; public void Enable() { IPanel? root = enginevgui.GetPanel(VGuiPanelType.ClientDll); diff --git a/Game.Client/FX_Tracer.cs b/Game.Client/FX_Tracer.cs new file mode 100644 index 00000000..c52a01d3 --- /dev/null +++ b/Game.Client/FX_Tracer.cs @@ -0,0 +1,145 @@ +using Game.Shared; + +using Source; +using Source.Common; +using Source.Common.Audio; +using Source.Common.Engine; +using Source.Common.Mathematics; +using Source.Common.SoundEmitterSystem; + +using System.Numerics; + +namespace Game.Client; + +public static class FX_Tracer +{ + static float NextWhizTime; + + public static Vector3 GetTracerOrigin(EffectData data) { + Vector3 vecStart = data.Start; + int attachment = data.AttachmentIndex; + + if ((data.Flags & TRACER_FLAG_USEATTACHMENT) == 0) + return vecStart; + + IClientRenderable? renderable = cl_entitylist.GetClientRenderableFromHandle(data.Entity); + if (renderable == null) + return vecStart; + + C_BaseEntity? ent = C_BaseEntity.Instance(data.Entity); + if (ent != null && ent.IsDormant()) + return vecStart; + + if (ent is C_BaseCombatWeapon wpn) { + if (wpn.GetTracerOrigin(ref vecStart)) + return vecStart; + + C_BasePlayer? player = ToBasePlayer(wpn.GetOwner()); + C_BaseViewModel? viewModel = player?.GetViewModel(0); + if (viewModel != null && wpn.ShouldDrawUsingViewModel()) + renderable = viewModel; + } + + if (renderable.GetAttachment(attachment, out Vector3 attachOrigin, out _)) + vecStart = attachOrigin; + + return vecStart; + } + + public static void FX_TracerSound(in Vector3 start, in Vector3 end, int tracerType, ReadOnlySpan customSoundName = default) { + Vector3 vecListenOrigin = MainViewOrigin(); + ReadOnlySpan soundName; + float whizDistSqr; + float minWhizTime = 0.1f; + float maxWhizTime = 0.1f; + + switch (tracerType) { + case TRACER_TYPE_DEFAULT: { + soundName = "Bullets.DefaultNearmiss"; + whizDistSqr = 24.0f * 24.0f; + + Ray bullet = default; + bullet.Init(start, end); + + Vector3 vecLower = vecListenOrigin; + vecLower.Z -= 24.0f; + Ray listener = default; + listener.Init(vecListenOrigin, vecLower); + + CollisionUtils.IntersectRayWithRay(bullet, listener, out _, out float t); + if (t <= 0.0f) + t = 0.0f; + if (1.0f <= t) + t = 1.0f; + vecListenOrigin.Z -= t * 24.0f; + } + break; + case TRACER_TYPE_GUNSHIP: + soundName = "Bullets.GunshipNearmiss"; + whizDistSqr = 72.0f * 72.0f; + break; + case TRACER_TYPE_STRIDER: + soundName = "Bullets.StriderNearmiss"; + whizDistSqr = 72.0f * 72.0f; + break; + case TRACER_TYPE_WATERBULLET: + soundName = "Underwater.BulletImpact"; + whizDistSqr = 48.0f * 48.0f; + minWhizTime = 0.3f; + maxWhizTime = 0.6f; + break; + default: + return; + } + + if (!customSoundName.IsEmpty) + soundName = customSoundName; + + if ((float)(NextWhizTime - gpGlobals.CurTime) > 0.0f) + return; + + if (MathLib.CalcDistanceSqrToLineSegment(vecListenOrigin, start, end) >= whizDistSqr) + return; + + SoundParameters parms = new(); + if (C_BaseEntity.GetParametersForSound(soundName, ref parms, null)) { + Vector3 shotDir = end - start; + MathLib.VectorNormalize(ref shotDir); + + LocalPlayerFilter filter = new(); + enginesound.EmitSound(filter, EngineSoundGlobals.SOUND_FROM_WORLD, (int)SoundEntityChannel.Static, ((Span)parms.SoundName).SliceNullTerminatedString(), + parms.Volume, AttenuationValues.SNDLVL_TO_ATTN(parms.SoundLevel), 0, parms.Pitch, 0, start, shotDir, null, true); + } + + NextWhizTime = (float)(gpGlobals.CurTime + random.RandomFloat(minWhizTime, maxWhizTime)); + } + + static void ParticleTracerCallback(EffectData data) { + C_BasePlayer? player = C_BasePlayer.GetLocalPlayer(); + if (player == null) + return; + + Vector3 vecStart = GetTracerOrigin(data); + Vector3 vecEnd = data.Origin; + + C_BaseEntity? entity = C_BaseEntity.Instance(data.Entity); + int entIndex = entity != null ? entity.EntIndex() : -1; + if (entIndex != 0 && entIndex == player.EntIndex()) { + engine.GetViewAngles(out QAngle vangles); + MathLib.AngleVectors(vangles, out _, out Vector3 vright, out _); + + MathLib.VectorMA(data.Start, 4, vright, out vecStart); + vecStart.Z -= 0.5f; + } + + Vector3 vecToEnd = vecEnd - vecStart; + MathLib.VectorNormalize(ref vecToEnd); + MathLib.VectorAngles(vecToEnd, out QAngle vecAngles); + DispatchParticleEffect(data.HitBox, vecStart, vecEnd, vecAngles, entity); + + if ((data.Flags & TRACER_FLAG_WHIZ) != 0) + FX_TracerSound(vecStart, vecEnd, TRACER_TYPE_DEFAULT); + } + + static readonly ClientEffectRegistration ClientEffectReg_ParticleTracerCallback = new("ParticleTracer", ParticleTracerCallback); +} diff --git a/Game.Client/Game.Client.csproj b/Game.Client/Game.Client.csproj index c618aea0..556018d4 100644 --- a/Game.Client/Game.Client.csproj +++ b/Game.Client/Game.Client.csproj @@ -6,6 +6,7 @@ + diff --git a/Game.Client/GarrysMod/LuaParticleEffect.cs b/Game.Client/GarrysMod/LuaParticleEffect.cs new file mode 100644 index 00000000..0064cf1b --- /dev/null +++ b/Game.Client/GarrysMod/LuaParticleEffect.cs @@ -0,0 +1,426 @@ +using Game.Shared; + +using Source.Common.GarrysMod.Lua; +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; +using Source.Particles; + +using System.Numerics; + +namespace Game.Client.GarrysMod; + +public static partial class LuaParticleEffect +{ + [LuaClass(typeof(CNewParticleEffect), NullError = "Tried to use a NULL CNewParticleEffect!")] + public static readonly LuaClass LC_CNewParticleEffect = new("CNewParticleEffect", LuaType.ParticleSystem, null, null); + + public static void Push_NewParticleEffect(CNewParticleEffect effect) => LC_CNewParticleEffect.Push(effect); + + static CNewParticleEffect? Get_ValidEffect(ILuaInterface lua) { + CNewParticleEffect? effect = LC_CNewParticleEffect.Get(1) as CNewParticleEffect; + if (effect == null) + lua.Error("Tried to use a NULL CNewParticleEffect!"); + return effect.IsValid() ? effect : null; + } + + internal static int ClampAttachType(double value) => Math.Clamp((int)value, 0, (int)ParticleAttachment.RootBoneFollow); + + [LuaGlobal] + static int CreateParticleSystem(ILuaInterface lua) { + C_BaseEntity ent = LuaEntity.Get_Entity(1, false)!; + int attachType = ClampAttachType(lua.CheckNumber(3)); + int attachment = (int)lua.CheckNumberOpt(4, 0); + Vector3 offset = lua.GetType(5) == LuaType.Nil ? Vector3.Zero : LuaVector.Get_Vector(5); + string name = lua.CheckString(2); + + CNewParticleEffect? effect = ent.ParticleProp().Create(name, (ParticleAttachment)attachType, attachment, offset); + if (effect == null || !effect.IsValid()) + return 0; + + Push_NewParticleEffect(effect); + return 1; + } + + [LuaGlobal] + static int CreateParticleSystemNoEntity(ILuaInterface lua) { + string name = lua.CheckString(1); + Vector3 pos = LuaVector.Get_Vector(2); + QAngle ang = lua.GetType(3) == LuaType.Nil ? MathLibConsts.vec3_angle : LuaAngle.Get_Angle(3); + + CNewParticleEffect effect = CNewParticleEffect.Create(null, name); + effect.AddRef(); + effect.Release(); + if (!effect.IsValid()) + return 0; + + effect.SetSortOrigin(pos); + effect.SetControlPoint(0, pos); + effect.SetControlPoint(1, pos); + if (lua.GetType(3) != LuaType.Nil) { + MathLib.AngleVectors(ang, out Vector3 forward, out Vector3 right, out Vector3 up); + effect.SetControlPointOrientation(0, forward, right, up); + } + + Push_NewParticleEffect(effect); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect____tostring(ILuaInterface lua) { + if (LC_CNewParticleEffect.Get(1) is CNewParticleEffect effect && effect.IsValid()) + lua.PushString($"CNewParticleEffect [{effect.GetEffectName()}]"); + else + lua.PushString("CNewParticleEffect [NULL]"); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__IsValid(ILuaInterface lua) { + lua.PushBool(LC_CNewParticleEffect.Get(1) is CNewParticleEffect effect && effect.IsValid()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__IsFinished(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushBool(effect.IsFinished()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__IsViewModelEffect(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushBool(effect.GetIsViewModelEffect()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__SetIsViewModelEffect(ILuaInterface lua) { + Get_ValidEffect(lua)?.SetIsViewModelEffect(lua.GetBool(2)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__GetShouldSimulate(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushBool(effect.ShouldSimulate()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__SetShouldSimulate(ILuaInterface lua) { + Get_ValidEffect(lua)?.SetShouldSimulate(lua.GetBool(2)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPoint(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPoint(point, LuaVector.Get_Vector(3)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointEntity(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPointEntity(point, LuaEntity.Get_Entity(3, false)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointForwardVector(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPointForwardVector(point, LuaVector.Get_Vector(3)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointRightVector(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPointRightVector(point, LuaVector.Get_Vector(3)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointUpVector(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPointUpVector(point, LuaVector.Get_Vector(3)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointParent(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point >= ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + return 0; + int parent = (int)lua.CheckNumber(3); + if ((uint)parent < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + effect.SetControlPointParent(point, parent); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetControlPointOrientation(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + int point = (int)lua.CheckNumber(2); + if ((uint)point >= ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + return 0; + + if (lua.GetType(3) == LuaType.Angle) { + QAngle ang = LuaAngle.Get_Angle(3); + MathLib.AngleVectors(ang, out Vector3 forward, out Vector3 right, out Vector3 up); + effect.SetControlPointOrientation(point, forward, right, up); + return 0; + } + + Vector3 upVec = LuaVector.Get_Vector(5); + Vector3 rightVec = LuaVector.Get_Vector(4); + Vector3 forwardVec = LuaVector.Get_Vector(3); + effect.SetControlPointOrientation(point, forwardVec, rightVec, upVec); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetSortOrigin(ILuaInterface lua) { + Get_ValidEffect(lua)?.SetSortOrigin(LuaVector.Get_Vector(2)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__GetEffectName(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushString(effect.GetEffectName()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__GetOwner(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + LuaEntity.Push_Entity(effect.GetOwner()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__GetRenderBounds(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + effect.GetRenderBounds(out Vector3 mins, out Vector3 maxs); + LuaVector.Push_Vector(mins); + LuaVector.Push_Vector(maxs); + return 2; + } + + [LuaMethod] + static int CNewParticleEffect__GetHighestControlPoint(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushNumber(effect.GetHighestControlPoint()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__GetAutoUpdateBBox(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + lua.PushBool(effect.GetAutoUpdateBBox()); + return 1; + } + + [LuaMethod] + static int CNewParticleEffect__Render(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + using MatRenderContextPtr renderContext = new(materials); + effect.Render(renderContext.Context, effect.IsTwoPass(), null); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__StartEmission(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + bool infiniteOnly = lua.GetType(2) == LuaType.Bool && lua.GetBool(2); + effect.StartEmission(infiniteOnly); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__StopEmission(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + bool infiniteOnly = lua.GetType(2) == LuaType.Bool && lua.GetBool(2); + bool removeAllParticles = lua.GetType(3) == LuaType.Bool && lua.GetBool(3); + bool wakeOnStop = lua.GetType(4) == LuaType.Bool && lua.GetBool(4); + effect.StopEmission(infiniteOnly, removeAllParticles, wakeOnStop); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__Restart(ILuaInterface lua) { + Get_ValidEffect(lua)?.Restart(); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__SetShouldDraw(ILuaInterface lua) { + Get_ValidEffect(lua)?.SetShouldDraw(lua.GetBool(2)); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__AddControlPoint(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + C_BaseEntity? owner = effect?.GetOwner(); + if (effect == null || owner == null) + return 0; + + int point = (int)lua.CheckNumber(2); + if ((uint)point >= ParticleConstants.MAX_PARTICLE_CONTROL_POINTS) + return 0; + + int attachType = ClampAttachType(lua.CheckNumber(4)); + string? attachmentName = lua.GetType(5) == LuaType.Nil ? null : lua.CheckString(5); + Vector3 offset = lua.GetType(6) == LuaType.Nil ? Vector3.Zero : LuaVector.Get_Vector(6); + C_BaseEntity ent = LuaEntity.Get_Entity(3, false)!; + + owner.ParticleProp().AddControlPoint(effect, point, ent, (ParticleAttachment)attachType, attachmentName, offset); + return 0; + } + + [LuaMethod] + static int CNewParticleEffect__StopEmissionAndDestroyImmediately(ILuaInterface lua) { + CNewParticleEffect? effect = Get_ValidEffect(lua); + if (effect == null) + return 0; + + C_BaseEntity? owner = effect.GetOwner(); + if (owner != null) { + owner.ParticleProp().StopEmissionAndDestroyImmediately(effect); + return 0; + } + + effect.StopEmission(false, true, false); + return 0; + } +} + +public static partial class LuaEntity +{ + [LuaMethod] + static int Entity__CreateParticleEffect(ILuaInterface lua) { + C_BaseEntity ent = Get_Entity(1, false)!; + int attachType = 0; + if (lua.GetType(3) == LuaType.Number) + attachType = LuaParticleEffect.ClampAttachType(lua.CheckNumber(3)); + + ParticleProperty prop = ent.ParticleProp(); + CNewParticleEffect? effect = prop.Create(lua.CheckString(2), (ParticleAttachment)attachType, 0, Vector3.Zero); + if (effect == null) + return 0; + + LuaObject options = new(); + options.SetFromStack(3); + if (options.isTable()) { + for (int i = 1; i < ParticleConstants.MAX_PARTICLE_CONTROL_POINTS; i++) { + LuaObject entry = new(); + options.GetMember(i, entry); + if (!entry.isTable()) { + entry.UnReference(); + break; + } + + C_BaseEntity? pointEntity = null; + LuaObject entityObj = new(); + entry.GetMember("entity", entityObj); + if (entityObj.isEntity()) + pointEntity = entityObj.GetEntity() as C_BaseEntity; + entityObj.UnReference(); + + int pointAttachType = LuaParticleEffect.ClampAttachType(entry.GetMemberInt("attachtype", 0)); + prop.AddControlPoint(effect, i - 1, pointEntity, (ParticleAttachment)pointAttachType); + + LuaObject position = new(); + entry.GetMember("position", position); + if (position.isVector()) + effect.SetControlPoint(i - 1, position.GetVector()); + position.UnReference(); + + entry.UnReference(); + } + } + options.UnReference(); + + LuaParticleEffect.Push_NewParticleEffect(effect); + return 1; + } + + [LuaMethod] + static int Entity__StopParticleEmission(ILuaInterface lua) { + Get_Entity(1, false)!.ParticleProp().StopEmission(); + return 0; + } + + [LuaMethod] + static int Entity__StopParticlesNamed(ILuaInterface lua) { + C_BaseEntity ent = Get_Entity(1, false)!; + bool forceRemoveInstantly = lua.GetType(3) == LuaType.Bool && lua.GetBool(3); + ent.ParticleProp().StopParticlesNamed(lua.CheckString(2), forceRemoveInstantly); + return 0; + } + + [LuaMethod] + static int Entity__StopParticlesWithNameAndAttachment(ILuaInterface lua) { + C_BaseEntity ent = Get_Entity(1, false)!; + bool forceRemoveInstantly = lua.GetType(3) == LuaType.Bool && lua.GetBool(3); + int attachment = (int)lua.CheckNumber(3); + ent.ParticleProp().StopParticlesWithNameAndAttachment(lua.CheckString(2), attachment, forceRemoveInstantly); + return 0; + } + + [LuaMethod] + static int Entity__StopAndDestroyParticles(ILuaInterface lua) { + Get_Entity(1, false)!.ParticleProp().StopEmissionAndDestroyImmediately(); + return 0; + } +} diff --git a/Game.Client/HLClient.cs b/Game.Client/HLClient.cs index 089660cc..631920b6 100644 --- a/Game.Client/HLClient.cs +++ b/Game.Client/HLClient.cs @@ -57,6 +57,8 @@ public static void DLLInit(IServiceCollection services) { services.AddSingleton(); services.AddSingleton(x => x.GetRequiredService()); + RuntimeHelpers.RunClassConstructor(typeof(FX_Tracer).TypeHandle); + #if GMOD_DLL // Dumb hack, but whatever RuntimeHelpers.RunClassConstructor(typeof(GModWeaponParse).TypeHandle); @@ -79,7 +81,10 @@ public void LevelInitPreEntity(ReadOnlySpan mapname) { vieweffects.LevelInit(); + ParseParticleEffectsMap(mapname, true); + modemanager.LevelInit(mapname); + ParticleMgr.Instance.LevelInit(); ResetToneMapping(1.0f); IGameSystem.LevelInitPreEntityAllSystems(mapname); #if GMOD_DLL @@ -137,6 +142,10 @@ public bool Init() { get.IntroScreen()!.Update("Initializing Convars", true); get.IntroScreen()!.Update("Initializing Objects", true); get.IntroScreen()!.Update("Initializing Particles", true); +#endif + if (!ParticleMgr.Instance.Init(ParticleMgr.MAX_TOTAL_PARTICLES, materials)) + return false; +#if GMOD_DLL get.IntroScreen()!.Update("Initializing VGUI", true); get.IntroScreen()!.Update("Adding Game Systems", true); #endif @@ -204,6 +213,7 @@ public bool Init() { public void Shutdown() { ClientVoiceMgr_Shutdown(); + ParticleMgr.Instance.Term(); #if GMOD_DLL Game.Client.GarrysMod.GarrysMod.Lua.Kill(); get.MenuSystem()?.Shutdown(); @@ -237,6 +247,32 @@ public bool CanShowSpeakerLabels() { public static bool g_bLevelInitialized; public static INetworkStringTable? g_pStringTableClientSideChoreoScenes; public static INetworkStringTable? g_pStringTableMaterials; + public static INetworkStringTable? g_pStringTableEffectDispatch; + public static INetworkStringTable? g_pStringTableParticleEffectNames; + + public static void PrecacheParticleSystem(ReadOnlySpan particleSystemName) { + g_pStringTableParticleEffectNames!.AddString(false, particleSystemName); + g_pParticleSystemMgr.PrecacheParticleSystem(particleSystemName.ToString()); + } + + public static int GetParticleSystemIndex(ReadOnlySpan particleSystemName) { + if (!particleSystemName.IsEmpty) { + int index = g_pStringTableParticleEffectNames!.FindStringIndex(particleSystemName); + if (index != INetworkStringTable.INVALID_STRING_INDEX) + return index; + DevWarning($"Client: Missing precache for particle system \"{particleSystemName}\"!\n"); + } + return 0; + } + + public static ReadOnlySpan GetParticleSystemNameFromIndex(int index) { + if (index < g_pStringTableParticleEffectNames!.GetMaxStrings()) + return g_pStringTableParticleEffectNames.GetString(index); + return "error"; + } + + static void OnParticleSystemStringTableChanged(object? context, INetworkStringTable stringTable, int stringNumber, ReadOnlySpan newString, ReadOnlySpan newData) + => g_pParticleSystemMgr.PrecacheParticleSystem(newString.ToString()); public static int GetMaterialIndex(ReadOnlySpan materialName) { if (!materialName.IsEmpty) { @@ -298,12 +334,18 @@ public void InstallStringTableCallback(ReadOnlySpan tableName) { case "Materials": g_pStringTableMaterials = networkstringtable.FindTable(tableName); break; - case "EffectDispatch": Warning("FIXME: EffectDispatch string table not being processed yet\n"); break; + case "EffectDispatch": + g_pStringTableEffectDispatch = networkstringtable.FindTable(tableName); + break; // I don't think InfoPanel is a thing? case "Scenes": g_pStringTableClientSideChoreoScenes = networkstringtable.FindTable(tableName); break; - case "ParticleEffectNames": Warning("FIXME: ParticleEffectNames string table not being processed yet\n"); break; + case "ParticleEffectNames": + g_pStringTableParticleEffectNames = networkstringtable.FindTable(tableName); + networkstringtable.SetAllowClientSideAddString(g_pStringTableParticleEffectNames!, true); + g_pStringTableParticleEffectNames!.SetStringChangedCallback(null, OnParticleSystemStringTableChanged); + break; #if GMOD_DLL case Protocol.NETWORKSTRING_TABLENAME: Game.Client.GarrysMod.NetworkString.Install(); @@ -397,6 +439,8 @@ private void OnRenderStart() { beams.UpdateTempEntBeams(); } + ParticleMgr.Instance.Simulate((float)gpGlobals.FrameTime); + C_BaseEntity.CalcAimEntPositions(); C_BaseEntity.AddVisibleEntities(); @@ -544,12 +588,14 @@ public void LevelShutdown() { view.LevelShutdown(); beams.ClearBeams(); - // ParticleMgr().RemoveAllEffects(); + ParticleMgr.Instance.RemoveAllEffects(); // StopAllRumbleEffects(); gHUD.LevelShutdown(); + g_pParticleSystemMgr.UncacheAllParticleSystems(); + #if GMOD_DLL Game.Client.GarrysMod.GarrysMod.Lua.Kill(); #endif diff --git a/Game.Client/IClientMode.cs b/Game.Client/IClientMode.cs index 87064316..c65c2934 100644 --- a/Game.Client/IClientMode.cs +++ b/Game.Client/IClientMode.cs @@ -29,4 +29,5 @@ public interface IClientMode bool CreateMove(double frametime, ref UserCmd cmd); void OverrideView(ref ViewSetup setup); bool ShouldDrawDetailObjects(); + bool ShouldDrawParticles(); } diff --git a/Game.Client/NewParticleEffect.cs b/Game.Client/NewParticleEffect.cs new file mode 100644 index 00000000..900a7bd8 --- /dev/null +++ b/Game.Client/NewParticleEffect.cs @@ -0,0 +1,387 @@ +using Game.Shared; + +using Source; +using Source.Common; +using Source.Common.Engine; +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; +using Source.Particles; + +using System.Numerics; +using System.Runtime.CompilerServices; + +using static Source.Particles.ParticleConstants; + +namespace Game.Client; + +public class CNewParticleEffect : ParticleCollection, IClientUnknown, IClientRenderable +{ + public CNewParticleEffect? NextEffect; + public CNewParticleEffect? PrevEffect; + + protected string? DebugName; + + bool DontRemove; + bool RemoveFlag; + bool Drawn; + bool NeedsBBoxUpdate; + bool IsFirstFrame; + bool AutoUpdateBBox; + bool Allocated; + bool ShouldSimulate_; + bool ShouldPerformCullCheck_; + + Vector3 SortOrigin; + EHANDLE Owner = new(); + readonly StrongBox[] ControlPointOwners = new StrongBox[MAX_PARTICLE_CONTROL_POINTS]; + + Vector3 LastMin; + Vector3 LastMax; + + bool ViewModelEffect; + bool ShouldDraw_; + + int RefCount; + + ClientRenderHandle_t RenderHandle_ = INVALID_CLIENT_RENDER_HANDLE; + + public CNewParticleEffect(C_BaseEntity? owner, ParticleSystemDefinition? effect) { + for (int i = 0; i < MAX_PARTICLE_CONTROL_POINTS; i++) + ControlPointOwners[i] = new(new EHANDLE()); + Owner.Set(owner); + Init(g_pParticleSystemMgr, effect); + Construct(); + } + + public CNewParticleEffect(C_BaseEntity? owner, string? effectName) { + for (int i = 0; i < MAX_PARTICLE_CONTROL_POINTS; i++) + ControlPointOwners[i] = new(new EHANDLE()); + Owner.Set(owner); + Init(g_pParticleSystemMgr, effectName); + Construct(); + } + + void Construct() { + SortOrigin = Vector3.Zero; + + DontRemove = false; + RemoveFlag = false; + Drawn = false; + NeedsBBoxUpdate = false; + IsFirstFrame = true; + AutoUpdateBBox = false; + Allocated = true; + ShouldSimulate_ = true; + ShouldPerformCullCheck_ = false; + + RefCount = 0; + ParticleMgr.Instance.AddEffect(this); + LastMax = new(-1.0e6f, -1.0e6f, -1.0e6f); + LastMin = new(1.0e6f, 1.0e6f, 1.0e6f); + MinBounds = new(1.0e6f, 1.0e6f, 1.0e6f); + MaxBounds = new(-1.0e6f, -1.0e6f, -1.0e6f); + DebugName = null; + + ViewModelEffect = Def != null && Def.IsViewModelEffect(); + ShouldDraw_ = true; + } + + public static CNewParticleEffect Create(C_BaseEntity? owner, string? particleSystemName, string? debugName = null) { + CNewParticleEffect ret = new(owner, particleSystemName); + ret.DebugName = debugName ?? particleSystemName; + ret.SetDynamicallyAllocated(true); + return ret; + } + + public static CNewParticleEffect Create(C_BaseEntity? owner, ParticleSystemDefinition def, string? debugName = null) { + CNewParticleEffect ret = new(owner, def); + ret.DebugName = debugName ?? def.GetName(); + ret.SetDynamicallyAllocated(true); + return ret; + } + + public void AddRef() => ++RefCount; + + public void Release() { + Assert(RefCount > 0); + --RefCount; + + if (RefCount == 0 && Allocated && IsFinished()) + SetRemoveFlag(); + } + + public void NotifyRemove() { + if (!Allocated) + return; + + Allocated = false; + Owner.Get()?.ParticleProp().OnParticleSystemDeleted(this); + g_Lua?.ReleaseUserTypeObject(this); + Destroy(); + } + + public int IsReleased() => RefCount == 0 ? 1 : 0; + + public void SetSortOrigin(in Vector3 sortOrigin) => SortOrigin = sortOrigin; + public ref readonly Vector3 GetSortOrigin() => ref SortOrigin; + + public bool ShouldDraw() => true; + public void SetShouldDraw(bool shouldDraw) => ShouldDraw_ = shouldDraw; + public bool GetShouldDraw() => ShouldDraw_; + public bool IsTransparent() => IsTranslucent(); + public bool UsesPowerOfTwoFrameBufferTexture() => UsesPowerOfTwoFrameBufferTexture(true); + public bool UsesFullFrameBufferTexture() => UsesFullFrameBufferTexture(true); + + public ref readonly QAngle GetRenderAngles() => ref MathLibConsts.vec3_angle; + + static Matrix3x4 RenderableToWorldMat; + public ref readonly Matrix3x4 RenderableToWorldTransform() { + MathLib.SetIdentityMatrix(out RenderableToWorldMat); + MathLib.PositionMatrix(GetRenderOrigin(), ref RenderableToWorldMat); + return ref RenderableToWorldMat; + } + + public ref readonly Vector3 GetRenderOrigin() => ref SortOrigin; + + public string GetEffectName() => GetName(); + + public void SetDontRemove(bool set) => DontRemove = set; + public void SetDrawn(bool drawn) => Drawn = drawn; + public void SetFirstFrameFlag(bool first) => IsFirstFrame = first; + public void SetDynamicallyAllocated(bool dynamic = true) => Allocated = dynamic; + public void SetNeedsBBoxUpdate(bool needsUpdate) => NeedsBBoxUpdate = needsUpdate; + public void SetAutoUpdateBBox(bool needsUpdate) => AutoUpdateBBox = needsUpdate; + public void SetRemoveFlag() => RemoveFlag = true; + public bool GetRemoveFlag() => RemoveFlag; + public bool GetFirstFrameFlag() => IsFirstFrame; + public bool GetNeedsBBoxUpdate() => NeedsBBoxUpdate; + public bool GetAutoUpdateBBox() => AutoUpdateBBox; + public bool ShouldPerformCullCheck() => ShouldPerformCullCheck_; + public void MarkShouldPerformCullCheck(bool enable) => ShouldPerformCullCheck_ = enable; + public C_BaseEntity? GetOwner() => Owner.Get(); + public void SetOwner(C_BaseEntity? owner) => Owner.Set(owner); + public void SetIsViewModelEffect(bool isViewModelEffect) => ViewModelEffect = isViewModelEffect; + public bool GetIsViewModelEffect() => ViewModelEffect; + public bool ShouldSimulate() => ShouldSimulate_; + public void SetShouldSimulate(bool sim) => ShouldSimulate_ = sim; + + public ref readonly EHANDLE GetControlPointEntity(int whichPoint) => ref ControlPointOwners[whichPoint].Value; + + public void SetControlPointEntity(int whichPoint, C_BaseEntity? entity) { + if ((uint)whichPoint >= MAX_PARTICLE_CONTROL_POINTS) { + Warning($"CNewParticleEffect::SetControlPointEntity invalid control point {whichPoint}\n"); + return; + } + + if (entity != null) { + SetControlPointObject(whichPoint, ControlPointOwners[whichPoint]); + ControlPointOwners[whichPoint].Value.Set(entity); + } + else + SetControlPointObject(whichPoint, null); + } + + public void Update(float timeDelta) => Owner.Get()?.ParticleProp().OnParticleSystemUpdated(this, timeDelta); + + public CNewParticleEffect? ReplaceWith(string? particleSystemName) { + StopEmission(false, true, true); + if (string.IsNullOrEmpty(particleSystemName)) + return null; + + CNewParticleEffect newEffect = Create(GetOwner(), particleSystemName, particleSystemName); + if (!newEffect.IsValid()) + return newEffect; + + for (int i = 0; i < MAX_PARTICLE_CONTROL_POINTS; ++i) { + if (!ReadsControlPoint(i)) + continue; + + newEffect.SetControlPoint(i, GetControlPointAtCurrentTime(i)); + GetControlPointOrientationAtCurrentTime(i, out Vector3 forward, out Vector3 right, out Vector3 up); + newEffect.SetControlPointOrientation(i, forward, right, up); + newEffect.SetControlPointParent(i, GetControlPointParent(i)); + } + + C_BaseEntity? owner = Owner.Get(); + if (owner == null) + return newEffect; + + owner.ParticleProp().ReplaceParticleEffect(this, newEffect); + return newEffect; + } + + public void SetParticleCullRadius(float radius) { } + + public bool RecalculateBoundingBox() { + BloatBoundsUsingControlPoint(); + if (MaxBounds.X < MinBounds.X) { + MaxBounds = MinBounds = GetSortOrigin(); + return false; + } + return true; + } + + public void GetRenderBounds(out Vector3 mins, out Vector3 maxs) { + mins = MinBounds - GetRenderOrigin(); + maxs = MaxBounds - GetRenderOrigin(); + } + + public void DetectChanges() { + if (RenderHandle_ == INVALID_CLIENT_RENDER_HANDLE) + return; + + float buffer = ParticleMgr.cl_particleeffect_aabb_buffer.GetFloat(); + float extraBuffer = buffer * 1.3f; + + if (MinBounds.X < LastMin.X || + MinBounds.Y < LastMin.Y || + MinBounds.Z < LastMin.Z || + + MinBounds.X > (LastMin.X + extraBuffer) || + MinBounds.Y > (LastMin.Y + extraBuffer) || + MinBounds.Z > (LastMin.Z + extraBuffer) || + + MaxBounds.X > LastMax.X || + MaxBounds.Y > LastMax.Y || + MaxBounds.Z > LastMax.Z || + + MaxBounds.X < (LastMax.X - extraBuffer) || + MaxBounds.Y < (LastMax.Y - extraBuffer) || + MaxBounds.Z < (LastMax.Z - extraBuffer) + ) { + clientLeafSystem.RenderableChanged(RenderHandle_); + LastMin = MinBounds - new Vector3(buffer, buffer, buffer); + LastMax = MaxBounds + new Vector3(buffer, buffer, buffer); + } + } + + public int DrawModel(StudioFlags flags) { + if (!ParticleMgr.r_DrawParticles.GetBool()) + return 0; + + if (!clientMode.ShouldDrawParticles() || !ParticleMgr.Instance.ShouldRenderParticleSystems()) + return 0; + + if ((flags & (StudioFlags.ShadowDepthTexture | StudioFlags.SSAODepthTexture)) != 0) + return 0; + + if (Def == null || Def.Material.Get() == null || !Def.IsPrecached || !ShouldDraw_) + return 0; + + C_BaseEntity? owner = Owner.Get(); + if (owner != null && owner.IsDormant()) + return 0; + + using MatRenderContextPtr renderContext = new(materials); + + if (!Def.ViewModelEffect && !Def.ScreenSpaceEffect) { + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + if (MathLib.CalcSqrDistanceToAABB(MinBounds, MaxBounds, camera) > Def.MaxDrawDistance * Def.MaxDrawDistance) { + NextSleepTime = Math.Max(NextSleepTime, g_pParticleSystemMgr.GetLastSimulationTime() + Def.NoDrawTimeToGoToSleep); + return 0; + } + } + + if (Def.ViewModelEffect) { + C_BasePlayer? player = C_BasePlayer.GetLocalPlayer(); + if (player == null || !player.IsAlive() || player.GetRenderedWeaponModel()?.IsViewModel() != true) + return 0; + } + + if ((flags & StudioFlags.Transparency) != 0) { + C_BaseEntity? cameraObject = cl_entitylist.GetEnt(render.GetViewEntity()); + if (cameraObject != null && ShouldSkipRenderForCamera(cameraObject)) + return 0; + + renderContext.MatrixMode(MaterialMatrixMode.Model); + renderContext.PushMatrix(); + renderContext.LoadIdentity(); + Render(renderContext.Context, IsTwoPass(), cameraObject); + renderContext.MatrixMode(MaterialMatrixMode.Model); + renderContext.PopMatrix(); + } + else + g_pParticleSystemMgr.AddToRenderCache(this); + + return 1; + } + + bool ShouldSkipRenderForCamera(C_BaseEntity cameraObject) { + int skipControlPoint = Def!.SkipRenderControlPoint; + if (skipControlPoint == -1 || skipControlPoint > GetHighestControlPoint()) + return false; + + C_BaseEntity? entity = GetControlPointEntity(skipControlPoint).Get(); + if (entity == null || input.CAM_IsThirdPerson()) + return false; + + if (entity == cameraObject) + return true; + + C_BaseEntity? rootMoveParent = entity.GetRootMoveParent(); + if (rootMoveParent == cameraObject) + return true; + + C_BasePlayer? player = C_BasePlayer.GetLocalPlayer(); + if (player != cameraObject) + return false; + + BaseEntity? observerTarget = player!.GetObserverTarget(); + return player.GetObserverMode() == Shared.ObserverMode.InEye && (observerTarget == entity || rootMoveParent == observerTarget); + } + + public IClientUnknown GetIClientUnknown() => this; + public ICollideable? GetCollideable() => null; + public IClientNetworkable? GetClientNetworkable() => null; + public IClientRenderable? GetClientRenderable() => this; + public IClientEntity? GetIClientEntity() => null; + public IClientThinkable? GetClientThinkable() => null; + + public void SetRefEHandle(in BaseHandle handle) => Assert(false); + public ref readonly BaseHandle GetRefEHandle() { + Assert(false); + return ref Unsafe.NullRef(); + } + + public ClientShadowHandle_t GetShadowHandle() => ClientRenderableGlobals.CLIENTSHADOW_INVALID_HANDLE; + public ref ClientRenderHandle_t RenderHandle() => ref RenderHandle_; + public Model? GetModel() => null; + public int GetBody() => 0; + public int GetSkin() => 0; + public bool UsesFlexDelayedWeights() => false; + public void ComputeFxBlend() { } + public int GetFxBlend() => 255; + public void GetColorModulation(Span color) => color[..3].Fill(1.0f); + public bool LODTest() => true; + public bool SetupBones(Span boneToWorldOut, int maxBones, int boneMask, TimeUnit_t currentTime) => true; + public void SetupWeights(Span boneToWorld, Span flexWeights, Span flexDelayedWeights) { } + public void DoAnimationEvents() { } + public IPVSNotify? GetPVSNotifyInterface() => null; + public void GetRenderBoundsWorldspace(out Vector3 mins, out Vector3 maxs) => IClientLeafSystemEngine.DefaultRenderBoundsWorldspace(this, out mins, out maxs); + public void GetShadowRenderBounds(out Vector3 mins, out Vector3 maxs, ShadowType shadowType) => GetRenderBounds(out mins, out maxs); + public bool ShouldReceiveProjectedTextures(ShadowFlags flags) => false; + public bool GetShadowCastDistance(ref float dist, ShadowType shadowType) => false; + public bool GetShadowCastDirection(ref Vector3 direction, ShadowType shadowType) => false; + public bool IsShadowDirty() => false; + public void MarkShadowDirty(bool dirty) { } + public IClientRenderable? GetShadowParent() => null; + public IClientRenderable? FirstShadowChild() => null; + public IClientRenderable? NextShadowPeer() => null; + public ShadowType ShadowCastType() => ShadowType.None; + public void CreateModelInstance() { } + public ModelInstanceHandle_t GetModelInstance() => MODEL_INSTANCE_INVALID; + public int LookupAttachment(ReadOnlySpan attachmentName) => -1; + public bool GetAttachment(int number, out Vector3 origin, out QAngle angles) { + origin = default; + angles = default; + return false; + } + public bool GetAttachment(int number, out Matrix3x4 matrix) { + matrix = default; + return false; + } + public Span GetRenderClipPlane() => default; + public void OnThreadedDrawSetup() { } + public void RecordToolMessage() { } + public bool IgnoresZBuffer() => false; +} diff --git a/Game.Client/ParticleMgr.cs b/Game.Client/ParticleMgr.cs index a3406e57..af9bde41 100644 --- a/Game.Client/ParticleMgr.cs +++ b/Game.Client/ParticleMgr.cs @@ -1,8 +1,12 @@ -using Source.Common; -using System; -using System.Collections.Generic; +using Game.Shared; + +using Source; +using Source.Common; +using Source.Common.Commands; +using Source.Common.Engine; +using Source.Common.MaterialSystem; + using System.Numerics; -using System.Text; namespace Game.Client; @@ -15,3 +19,192 @@ public struct ParticleLightInfo [NetworkVar("m_flIntensity")] public float Intensity; } + +public struct ParticleSimListEntry +{ + public CNewParticleEffect NewParticleEffect; + public bool BoundingBoxOnly; +} + +public sealed class ParticleMgr +{ + public const int MAX_TOTAL_PARTICLES = 16384; + + public static readonly ParticleMgr Instance = new(); + + public static readonly ConVar r_DrawParticles = new("r_drawparticles", "1", FCvar.Cheat, "Enable/disable particle rendering"); + public static readonly ConVar cl_particleeffect_aabb_buffer = new("cl_particleeffect_aabb_buffer", "2", FCvar.Cheat, "Add this amount to a particle effect's bbox in the leaf system so if it's growing slowly, it won't have to be reinserted as often."); + static readonly ConVar r_particle_timescale = new("r_particle_timescale", "1.0", FCvar.Cheat | FCvar.DevelopmentOnly); + + CNewParticleEffect? NewEffectsHead; + IMaterialSystem? MaterialSystem; + bool UpdatingEffects; + bool RenderParticleSystems_ = true; + + static float ThreadedPSystemTimeStep; + + public bool Init(int count, IMaterialSystem materials) { + Term(); + + MaterialSystem = materials; + + g_pParticleSystemMgr.Init(ParticleSystemQuery.g_pParticleSystemQuery, filesystem); + g_pParticleSystemMgr.AddBuiltinSimulationOperators(); + g_pParticleSystemMgr.AddBuiltinRenderingOperators(); + + ParseParticleEffects(true, false); + + return true; + } + + public void Term() { + NewEffectsHead = null; + + g_pParticleSystemMgr.UncacheAllParticleSystems(); + MaterialSystem?.UncacheUnusedMaterials(); + MaterialSystem = null; + } + + public void LevelInit() => g_pParticleSystemMgr.SetLastSimulationTime(gpGlobals.CurTime); + + public void RenderParticleSystems(bool enable) => RenderParticleSystems_ = enable; + public bool ShouldRenderParticleSystems() => RenderParticleSystems_; + + public void AddEffect(CNewParticleEffect effect) { + effect.PrevEffect = null; + effect.NextEffect = NewEffectsHead; + if (NewEffectsHead != null) + NewEffectsHead.PrevEffect = effect; + NewEffectsHead = effect; + + clientLeafSystem.CreateRenderableHandle(effect); + if (effect.IsValid() && effect.Def!.IsViewModelEffect()) + clientLeafSystem.SetRenderGroup(effect.RenderHandle(), RenderGroup.ViewModelTranslucent); + } + + public void RemoveEffect(CNewParticleEffect effect) { + Assert(!UpdatingEffects); + + clientLeafSystem.RemoveRenderable(effect.RenderHandle()); + + if (effect.PrevEffect != null) + effect.PrevEffect.NextEffect = effect.NextEffect; + else if (NewEffectsHead == effect) + NewEffectsHead = effect.NextEffect; + if (effect.NextEffect != null) + effect.NextEffect.PrevEffect = effect.PrevEffect; + effect.NextEffect = null; + effect.PrevEffect = null; + + effect.NotifyRemove(); + } + + public void RemoveAllNewEffects() { + for (CNewParticleEffect? newEffect = NewEffectsHead; newEffect != null;) { + CNewParticleEffect? nextEffect = newEffect.NextEffect; + for (C_BaseEntity? ent = cl_entitylist.FirstBaseEntity(); ent != null; ent = cl_entitylist.NextBaseEntity(ent)) + ent.ParticleProp().OnParticleSystemDeleted(newEffect); + + RemoveEffect(newEffect); + newEffect = nextEffect; + } + } + + public void RemoveAllEffects() => RemoveAllNewEffects(); + + public void Simulate(float timeDelta) { + if (MaterialSystem == null) { + Assert(false); + return; + } + + UpdateAllEffects(timeDelta); + } + + static void ProcessPSystem(in ParticleSimListEntry entry) { + CNewParticleEffect newEffect = entry.NewParticleEffect; + bool updateBboxOnly = entry.BoundingBoxOnly; + + if (newEffect.GetNeedsBBoxUpdate()) { + if (!newEffect.GetAutoUpdateBBox() || newEffect.RecalculateBoundingBox()) + newEffect.SetNeedsBBoxUpdate(false); + } + + newEffect.SetDrawn(false); + + if (newEffect.GetFirstFrameFlag()) { + newEffect.Simulate(0.0f, updateBboxOnly); + newEffect.SetFirstFrameFlag(false); + } + else if (newEffect.ShouldSimulate()) + newEffect.Simulate(ThreadedPSystemTimeStep, updateBboxOnly); + + if (newEffect.IsFinished()) + newEffect.SetRemoveFlag(); + } + + void BuildParticleSimList(List list) { + double now = g_pParticleSystemMgr.GetLastSimulationTime(); + for (CNewParticleEffect? newEffect = NewEffectsHead; newEffect != null; newEffect = newEffect.NextEffect) { + bool skip = false; + bool needsBboxUpdate = false; + + if (now >= newEffect.NextSleepTime && newEffect.ActiveParticles > 0) + skip = true; + if (newEffect.GetRemoveFlag()) + skip = true; + + if (skip) { + needsBboxUpdate = newEffect.HasMoved(); + skip = !needsBboxUpdate; + } + + if (!skip) + list.Add(new() { NewParticleEffect = newEffect, BoundingBoxOnly = needsBboxUpdate }); + } + } + + readonly List ParticlesToSimulate = []; + + void UpdateNewEffects(float timeDelta) { + timeDelta *= r_particle_timescale.GetFloat(); + + g_pParticleSystemMgr.SetLastSimulationTime(gpGlobals.CurTime); + + ThreadedPSystemTimeStep = timeDelta; + + for (CNewParticleEffect? newEffect = NewEffectsHead; newEffect != null; newEffect = newEffect.NextEffect) + newEffect.Update(ThreadedPSystemTimeStep); + + ParticlesToSimulate.Clear(); + BuildParticleSimList(ParticlesToSimulate); + int count = ParticlesToSimulate.Count; + + if (count != 0) { + DirtySpatialPartitionEntityList.UpdateDirtySpatialPartitionEntities(); + for (int i = 0; i < count; i++) + ProcessPSystem(ParticlesToSimulate[i]); + } + + for (int i = 0; i < count; i++) + ParticlesToSimulate[i].NewParticleEffect.DetectChanges(); + } + + void UpdateAllEffects(float timeDelta) { + UpdatingEffects = true; + + if (timeDelta > 0.1f) + timeDelta = 0.1f; + + UpdateNewEffects(timeDelta); + + UpdatingEffects = false; + + for (CNewParticleEffect? newEffect = NewEffectsHead; newEffect != null;) { + CNewParticleEffect? nextEffect = newEffect.NextEffect; + if (newEffect.GetRemoveFlag()) + RemoveEffect(newEffect); + newEffect = nextEffect; + } + } +} diff --git a/Game.Client/ParticleProperty.cs b/Game.Client/ParticleProperty.cs new file mode 100644 index 00000000..23bb0097 --- /dev/null +++ b/Game.Client/ParticleProperty.cs @@ -0,0 +1,400 @@ +using Game.Shared; + +using Source; +using Source.Common; +using Source.Common.Commands; +using Source.Common.Mathematics; +using Source.Particles; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Game.Client; + +public sealed class ParticlePropertyControlPoint +{ + public int ControlPoint; + public ParticleAttachment AttachType = ParticleAttachment.AbsOriginFollow; + public int AttachmentPoint; + public Vector3 OriginOffset; + public EHANDLE Entity = new(); +} + +public sealed class ParticleEffectList +{ + public readonly List ControlPoints = []; + CNewParticleEffect? ParticleEffect_; + + public CNewParticleEffect? ParticleEffect { + get => ParticleEffect_; + set { + value?.AddRef(); + ParticleEffect_?.Release(); + ParticleEffect_ = value; + } + } + + public void MarkDeleted() => ParticleEffect_ = null; +} + +public sealed class ParticleProperty +{ + public const int INVALID_PARTICLE_ATTACHMENT = 0; + + public static readonly ConVar cl_particle_batch_mode = new("cl_particle_batch_mode", "1"); + + C_BaseEntity? Outer; + readonly List ParticleEffects = []; + long DormancyChangedAtFrame; + + public ParticleProperty() => Init(null); + + public void Init(C_BaseEntity? entity) => Outer = entity; + public C_BaseEntity? GetOuter() => Outer; + + void RemoveEffectAt(int index) { + ParticleEffectList entry = ParticleEffects[index]; + ParticleEffects.RemoveAt(index); + entry.ParticleEffect = null; + } + + static int GetParticleAttachment(C_BaseEntity? entity, ReadOnlySpan attachmentName, ReadOnlySpan particleName) { + C_BaseAnimating? animating = entity?.GetBaseAnimating(); + Assert(animating != null); + if (animating == null) + return INVALID_PARTICLE_ATTACHMENT; + + return animating.LookupAttachment(attachmentName); + } + + public CNewParticleEffect? Create(string particleName, ParticleAttachment attachType, ReadOnlySpan attachmentName) { + int attachment = GetParticleAttachment(GetOuter(), attachmentName, particleName); + if (attachment == INVALID_PARTICLE_ATTACHMENT) + return null; + + return Create(particleName, attachType, attachment); + } + + public CNewParticleEffect? Create(string particleName, ParticleAttachment attachType, int attachmentPoint = INVALID_PARTICLE_ATTACHMENT, Vector3 originOffset = default) { + if (GameRules.g_pGameRules != null) + particleName = GameRules.g_pGameRules.TranslateEffectForVisionFilter("particles", particleName).ToString(); + + int batchMode = cl_particle_batch_mode.GetInt(); + ParticleSystemDefinition? def = g_pParticleSystemMgr.FindParticleSystem(particleName); + bool requestedBatch = (batchMode == 2) || ((batchMode == 1) && def != null && def.ShouldBatch); + if (attachType == ParticleAttachment.CustomOrigin && requestedBatch) { + int index = FindEffect(particleName); + if (index >= 0) { + CNewParticleEffect effect = ParticleEffects[index].ParticleEffect!; + effect.Restart(); + return effect; + } + } + + if (def == null) { + Warning($"Attempting to create unknown particle system '{particleName}' \n"); + return null; + } + + ParticleEffectList newEffect = new(); + ParticleEffects.Add(newEffect); + int effectIndex = ParticleEffects.Count - 1; + newEffect.ParticleEffect = CNewParticleEffect.Create(Outer, def); + + if (!newEffect.ParticleEffect!.IsValid()) { + Warning($"Attempting to create particle system '{particleName}' with unprecached material!\n"); + ParticleMgr.Instance.RemoveEffect(newEffect.ParticleEffect); + return null; + } + + AddControlPoint(effectIndex, 0, GetOuter(), attachType, attachmentPoint, originOffset); + + Outer?.OnNewParticleEffect(particleName, newEffect.ParticleEffect); + + return newEffect.ParticleEffect; + } + + public void AddControlPoint(CNewParticleEffect effect, int point, C_BaseEntity? entity, ParticleAttachment attachType, string? attachmentName = null, Vector3 originOffset = default) { + int attachment = INVALID_PARTICLE_ATTACHMENT; + if (attachmentName != null) + attachment = GetParticleAttachment(entity, attachmentName, effect.GetEffectName()); + + for (int i = 0; i < ParticleEffects.Count; i++) { + if (ParticleEffects[i].ParticleEffect == effect) + AddControlPoint(i, point, entity, attachType, attachment, originOffset); + } + } + + public void AddControlPoint(int effectIndex, int point, C_BaseEntity? entity, ParticleAttachment attachType, int attachmentPoint = INVALID_PARTICLE_ATTACHMENT, Vector3 originOffset = default) { + Assert(effectIndex >= 0 && effectIndex < ParticleEffects.Count); + ParticleEffectList effect = ParticleEffects[effectIndex]; + Assert(effect.ControlPoints.Count < MAX_PARTICLE_CONTROL_POINTS); + + ParticlePropertyControlPoint? newPoint = null; + int index = point; + foreach (ParticlePropertyControlPoint existing in effect.ControlPoints) { + if (existing.ControlPoint == point) + newPoint = existing; + } + + if (newPoint == null) { + newPoint = new(); + effect.ControlPoints.Add(newPoint); + index = effect.ControlPoints.Count - 1; + } + + newPoint.ControlPoint = point; + newPoint.Entity.Set(entity); + newPoint.AttachType = attachType; + newPoint.AttachmentPoint = attachmentPoint; + newPoint.OriginOffset = originOffset; + + UpdateParticleEffect(effect, true, index); + } + + public void SetControlPointParent(CNewParticleEffect effect, int whichControlPoint, int parentIdx) => effect.SetControlPointParent(whichControlPoint, parentIdx); + public void SetControlPointParent(int effectIndex, int whichControlPoint, int parentIdx) { } + + public CNewParticleEffect? GetParticleEffectFromIdx(int idx) => ParticleEffects[idx].ParticleEffect; + + public void ReplaceParticleEffect(CNewParticleEffect oldEffect, CNewParticleEffect newEffect) { + for (int i = 0; i < ParticleEffects.Count; ++i) { + if (oldEffect != ParticleEffects[i].ParticleEffect) + continue; + + ParticleEffects[i].ParticleEffect = newEffect; + UpdateParticleEffect(ParticleEffects[i], true); + } + } + + public void StopEmission(CNewParticleEffect? effect = null, bool wakeOnStop = false, bool destroyAsleepSystems = false) { + bool removeInstantly = DormancyChangedAtFrame == gpGlobals.FrameCount; + + if (effect != null) { + if (FindEffect(effect) != -1) + effect.StopEmission(false, removeInstantly, wakeOnStop); + return; + } + + double now = g_pParticleSystemMgr.GetLastSimulationTime(); + for (int i = ParticleEffects.Count - 1; i >= 0; i--) { + CNewParticleEffect tmp = ParticleEffects[i].ParticleEffect!; + bool removeSystem = removeInstantly || (destroyAsleepSystems && now >= tmp.NextSleepTime); + if (removeSystem) { + RemoveEffectAt(i); + tmp.SetOwner(null); + } + tmp.StopEmission(false, removeSystem, !removeSystem && wakeOnStop); + } + } + + public void StopEmissionAndDestroyImmediately(CNewParticleEffect? effect = null) { + if (effect != null) { + int index = FindEffect(effect); + if (index != -1) { + RemoveEffectAt(index); + effect.SetOwner(null); + effect.StopEmission(false, true); + } + return; + } + + for (int i = ParticleEffects.Count - 1; i >= 0; i--) { + CNewParticleEffect tmp = ParticleEffects[i].ParticleEffect!; + RemoveEffectAt(i); + tmp.SetOwner(null); + tmp.StopEmission(false, true); + } + } + + public void StopParticlesInvolving(C_BaseEntity entity) { + Assert(entity != null); + + bool removeInstantly = DormancyChangedAtFrame == gpGlobals.FrameCount; + + foreach (ParticleEffectList part in ParticleEffects) { + for (int j = 0; j < part.ControlPoints.Count; ++j) { + if (part.ControlPoints[j].Entity.Get() == entity) { + part.ParticleEffect!.StopEmission(false, removeInstantly); + part.ControlPoints.RemoveAt(j); + break; + } + } + } + } + + public void StopParticlesNamed(string? effectName, bool forceRemoveInstantly = false, bool inverse = false) { + if (string.IsNullOrEmpty(effectName)) + return; + + ParticleSystemDefinition? def = g_pParticleSystemMgr.FindParticleSystem(effectName); + AssertMsg(def != null, $"Could not find particle definition {effectName}"); + if (def == null) + return; + + bool removeInstantly = DormancyChangedAtFrame == gpGlobals.FrameCount; + removeInstantly |= forceRemoveInstantly; + + foreach (ParticleEffectList part in ParticleEffects) { + CNewParticleEffect effect = part.ParticleEffect!; + bool matches = effect.Def == def; + if (matches == !inverse) + effect.StopEmission(false, removeInstantly); + } + } + + public void StopParticlesWithNameAndAttachment(string effectName, int attachmentPoint, bool forceRemoveInstantly = false) { + ParticleSystemDefinition? def = g_pParticleSystemMgr.FindParticleSystem(effectName); + AssertMsg(def != null, $"Could not find particle definition {effectName}"); + if (def == null) + return; + + bool removeInstantly = DormancyChangedAtFrame == gpGlobals.FrameCount; + removeInstantly |= forceRemoveInstantly; + + foreach (ParticleEffectList part in ParticleEffects) { + CNewParticleEffect effect = part.ParticleEffect!; + if (effect.Def != def) + continue; + + foreach (ParticlePropertyControlPoint point in part.ControlPoints) { + if (point.AttachmentPoint == attachmentPoint) { + effect.StopEmission(false, removeInstantly); + break; + } + } + } + } + + public void OnParticleSystemUpdated(CNewParticleEffect effect, float timeDelta) { + int index = FindEffect(effect); + Assert(index != -1); + if (index == -1) + return; + + UpdateParticleEffect(ParticleEffects[index]); + } + + public void OnParticleSystemDeleted(CNewParticleEffect effect) { + int index = FindEffect(effect); + if (index == -1) + return; + + ParticleEffects[index].MarkDeleted(); + ParticleEffects.RemoveAt(index); + } + + public void OwnerSetDormantTo(bool dormant) { + DormancyChangedAtFrame = gpGlobals.FrameCount; + + foreach (ParticleEffectList part in ParticleEffects) + part.ParticleEffect!.SetDormant(dormant); + } + + int FindEffect(CNewParticleEffect effect) { + for (int i = 0; i < ParticleEffects.Count; i++) { + if (ParticleEffects[i].ParticleEffect == effect) + return i; + } + return -1; + } + + public int FindEffect(ReadOnlySpan effectName, int start = 0) { + for (int i = start; i < ParticleEffects.Count; i++) { + if (effectName.Equals(ParticleEffects[i].ParticleEffect!.GetName(), StringComparison.OrdinalIgnoreCase)) + return i; + } + return -1; + } + + void UpdateParticleEffect(ParticleEffectList effect, bool initializing = false, int onlyThisControlPoint = -1) { + if (onlyThisControlPoint != -1) { + UpdateControlPoint(effect, onlyThisControlPoint, initializing); + return; + } + + for (int i = 0; i < effect.ControlPoints.Count; i++) + UpdateControlPoint(effect, i, initializing); + } + + void UpdateControlPoint(ParticleEffectList effectList, int pointIndex, bool initializing) { + ParticlePropertyControlPoint point = effectList.ControlPoints[pointIndex]; + CNewParticleEffect effect = effectList.ParticleEffect!; + + if (effect.Def != null && effect.Def.IsScreenSpaceEffect() && pointIndex == 0) { + effect.SetControlPointOrientation(point.ControlPoint, new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1)); + effect.SetControlPoint(point.ControlPoint, Vector3.Zero); + return; + } + + C_BaseEntity? entity = point.Entity.Get(); + if (entity == null) { + if (point.AttachType == ParticleAttachment.WorldOrigin && initializing) { + effect.SetControlPointOrientation(point.ControlPoint, new Vector3(1, 0, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1)); + effect.SetControlPoint(point.ControlPoint, point.OriginOffset); + effect.SetSortOrigin(point.OriginOffset); + } + + effect.SetControlPointEntity(point.ControlPoint, null); + return; + } + + if (!initializing && entity.GetMoveParent() == null && (point.AttachType == ParticleAttachment.AbsOrigin || point.AttachType == ParticleAttachment.Point)) + return; + + if (point.AttachType == ParticleAttachment.CustomOrigin) + return; + + Vector3 origin = default, forward = default, right = default, up = default; + + switch (point.AttachType) { + case ParticleAttachment.Point: + case ParticleAttachment.PointFollow: { + C_BaseAnimating? animating = entity.GetBaseAnimating(); + if (animating != null) { + if (!animating.GetAttachment(point.AttachmentPoint, out Matrix3x4 attachmentToWorld)) { + DevWarning($"Cannot update control point {point.AttachmentPoint} for effect '{effect.GetEffectName()}'.\n"); + attachmentToWorld = animating.RenderableToWorldTransform(); + } + + MathLib.MatrixVectors(attachmentToWorld, out forward, out right, out up); + MathLib.MatrixGetColumn(attachmentToWorld, 3, out origin); + + if (effect.Def != null && effect.Def.IsViewModelEffect()) + C_BaseViewModel.FormatViewModelAttachment(ref origin, true); + } + } + break; + + case ParticleAttachment.RootBoneFollow: { + C_BaseAnimating? animating = entity.GetBaseAnimating(); + if (animating != null && animating.GetRootBone(out Matrix3x4 rootBone)) { + MathLib.MatrixVectors(rootBone, out forward, out right, out up); + MathLib.MatrixGetColumn(rootBone, 3, out origin); + } + } + break; + + default: + origin = entity.GetAbsOrigin() + point.OriginOffset; + entity.GetVectors(out forward, out right, out up); + break; + } + + effect.SetControlPointOrientation(point.ControlPoint, forward, right, up); + effect.SetControlPointEntity(point.ControlPoint, entity); + effect.SetControlPoint(point.ControlPoint, origin); + effect.SetSortOrigin(origin); + } + + public void DebugPrintEffects() { + for (int i = 0; i < ParticleEffects.Count; ++i) { + CNewParticleEffect? effect = ParticleEffects[i].ParticleEffect; + if (effect == null) + continue; + + Msg($"({i}) EffectName \"{effect.GetEffectName()}\" Dormant? {(effect.Dormant ? "yes" : "no")} Emission Stopped? {(effect.EmissionStopped ? "yes" : "no")} \n"); + } + } +} diff --git a/Game.Client/ViewRender.cs b/Game.Client/ViewRender.cs index a6fc1939..ae374866 100644 --- a/Game.Client/ViewRender.cs +++ b/Game.Client/ViewRender.cs @@ -862,6 +862,8 @@ protected void DrawOpaqueRenderables(RenderDepthMode depthMode) { render.SetBlend(1); + g_pParticleSystemMgr.ResetRenderCache(); + DrawFlags drawFlags = GetDrawFlags(); #if GMOD_DLL if (depthMode == RenderDepthMode.Normal && gGM != null && gGM.CallWithArgs((int)LUA_POOLEDSTRING.PreDrawOpaqueRenderables)) { @@ -884,6 +886,8 @@ protected void DrawOpaqueRenderables(RenderDepthMode depthMode) { DrawOpaqueRenderables_DrawStaticProps(RenderGroup.OpaqueStaticHuge + 2 * bucket, depthMode); } + g_pParticleSystemMgr.DrawRenderCache(depthMode != RenderDepthMode.Normal); + #if GMOD_DLL if (depthMode == RenderDepthMode.Normal && gGM != null && gGM.CallWithArgs((int)LUA_POOLEDSTRING.PostDrawOpaqueRenderables)) { g_Lua!.PushBool(false); diff --git a/Game.Server/Game.Server.csproj b/Game.Server/Game.Server.csproj index 42019900..216c2794 100644 --- a/Game.Server/Game.Server.csproj +++ b/Game.Server/Game.Server.csproj @@ -7,6 +7,7 @@ + pMapName, ReadOnlyMemory pMapEnti // UpdateChapterRestrictions(pMapName); + ParseParticleEffects(false, false); + //Tony; parse custom manifest if exists! - // ParseParticleEffectsMap(pMapName, false); + ParseParticleEffectsMap(pMapName, false); // IGameSystem::LevelInitPreEntityAllSystems() is called when the world is precached // That happens either in LoadGameState() or in MapEntity_ParseAllEntities() diff --git a/Game.Server/World.cs b/Game.Server/World.cs index 23fc9027..7324e793 100644 --- a/Game.Server/World.cs +++ b/Game.Server/World.cs @@ -77,7 +77,7 @@ public override void Precache() { // InitBodyQue(); SENTENCEG_Init(); - // PrecacheStandardParticleSystems(); + PrecacheStandardParticleSystems(); BaseCombatWeapon.W_Precache(); GameServerClientMethods.ClientPrecache(); diff --git a/Game.Shared/EffectData.cs b/Game.Shared/EffectData.cs index 0fdba776..a6af0f6e 100644 --- a/Game.Shared/EffectData.cs +++ b/Game.Shared/EffectData.cs @@ -32,7 +32,7 @@ public partial class EffectData new(nameof(Material)) { Bits = 13, Flags = PropFlags.Unsigned }, new(nameof(DamageType)) { Bits = 32, Flags = PropFlags.Unsigned }, new(nameof(HitBox)) { Bits = 12, Flags = PropFlags.Unsigned }, - new(nameof(EntIndex)) { Bits = Constants.MAX_EDICT_BITS, Flags = PropFlags.Unsigned }, + new(nameof(EntIndex)) { Bits = Constants.MAX_EDICT_BITS, Flags = PropFlags.Unsigned, Proxy = typeof(EntIndexProxy) }, new(nameof(Color)) { Bits = 8, Flags = PropFlags.Unsigned }, new(nameof(Radius)) { Bits = 10, Flags = PropFlags.RoundDown, Low = 0.0f, High = 1023.0f }, nameof(HasCustomColors), @@ -51,6 +51,18 @@ public static class SurfacePropProxy #endif } + public static class EntIndexProxy + { +#if CLIENT_DLL + public static void Recv(ref readonly RecvProxyData data, object instance, IFieldAccessor field) { + EffectData effectData = (EffectData)instance; + int entIndex = data.Value.Int; + effectData.EntIndex = entIndex; + effectData.Entity = entIndex < 0 ? Game.Client.ClientEntityGlobals.INVALID_CLIENTENTITY_HANDLE : Game.Client.SourceDllMain.cl_entitylist.EntIndexToHandle(entIndex); + } +#endif + } + public const int SUBINCH_PRECISION = 3; public const int MAX_EFFECT_FLAG_BITS = 8; public const int CUSTOM_COLOR_CP1 = 9; @@ -71,7 +83,7 @@ public static class SurfacePropProxy [NetworkVar("m_flMagnitude")] public float Magnitude; [NetworkVar("m_flScale")] - public float Scale; + public float Scale = 1.0f; [NetworkVar("m_nAttachmentIndex")] public int AttachmentIndex; [NetworkVar("m_nSurfaceProp")] @@ -105,8 +117,12 @@ public static class SurfacePropProxy [NetworkVar("m_ControlPoint1")] public ParticleEffectsControlPoint ControlPoint1; [NetworkVar("m_bAllowOverride")] - public bool AllowOverride; + public bool AllowOverride = true; public EffectData Copy() => (EffectData)MemberwiseClone(); + + static bool SuppressParticleEffects_; + public static bool SuppressingParticleEffects() => SuppressParticleEffects_; + public static void SuppressParticleEffects(bool suppress) => SuppressParticleEffects_ = suppress; } #endif diff --git a/Game.Shared/EventList.cs b/Game.Shared/EventList.cs index b4890785..d0a7dcd7 100644 --- a/Game.Shared/EventList.cs +++ b/Game.Shared/EventList.cs @@ -62,6 +62,8 @@ public enum AnimEventId AE_SV_DUSTTRAIL, AE_CL_CREATE_PARTICLE_EFFECT, + AE_CL_STOP_PARTICLE_EFFECT, + AE_CL_ADD_PARTICLE_EFFECT_CP, AE_RAGDOLL, @@ -250,6 +252,8 @@ public static void RegisterSharedEvents() { REGISTER_SHARED_ANIMEVENT(AnimEventId.AE_SV_DUSTTRAIL, AnimEventType.Server); REGISTER_SHARED_ANIMEVENT(AnimEventId.AE_CL_CREATE_PARTICLE_EFFECT, AnimEventType.Client); + REGISTER_SHARED_ANIMEVENT(AnimEventId.AE_CL_STOP_PARTICLE_EFFECT, AnimEventType.Client); + REGISTER_SHARED_ANIMEVENT(AnimEventId.AE_CL_ADD_PARTICLE_EFFECT_CP, AnimEventType.Client); REGISTER_SHARED_ANIMEVENT(AnimEventId.AE_RAGDOLL, AnimEventType.Server); diff --git a/Game.Shared/Game.Shared.csproj b/Game.Shared/Game.Shared.csproj index 527eb547..607e3bb1 100644 --- a/Game.Shared/Game.Shared.csproj +++ b/Game.Shared/Game.Shared.csproj @@ -21,6 +21,7 @@ + diff --git a/Game.Shared/GarrysMod/GarrysMod.cs b/Game.Shared/GarrysMod/GarrysMod.cs index 8d64a9c7..7f369f7a 100644 --- a/Game.Shared/GarrysMod/GarrysMod.cs +++ b/Game.Shared/GarrysMod/GarrysMod.cs @@ -184,7 +184,7 @@ public void LevelInit(ReadOnlySpan mapName) { AddCustomFonts(); if (gpGlobals.MaxClients > 1) { - // todo: ParseParticleEffects(true, false); + ParseParticleEffects(true, false); } string status = (gpGlobals.MaxClients < 2 ? "Singleplayer - " : "Multiplayer - ") + mapName.ToString(); diff --git a/Game.Shared/GarrysMod/LuaEntity.cs b/Game.Shared/GarrysMod/LuaEntity.cs index 3609fe6b..9e0e7a68 100644 --- a/Game.Shared/GarrysMod/LuaEntity.cs +++ b/Game.Shared/GarrysMod/LuaEntity.cs @@ -84,6 +84,12 @@ public static void RemoveQueuedEntities() { ProcessingRemoveList = false; } + [LuaMethod] + static int Entity__StopParticles(ILuaInterface lua) { + StopParticleEffects(Get_Entity(1, false)); + return 0; + } + [LuaMethod] static int Entity__IsMarkedForDeletion(ILuaInterface lua) { BaseEntity ent = Get_Entity(1, false)!; diff --git a/Game.Shared/GarrysMod/LuaGame.cs b/Game.Shared/GarrysMod/LuaGame.cs index 5d6aedcb..72c68cb1 100644 --- a/Game.Shared/GarrysMod/LuaGame.cs +++ b/Game.Shared/GarrysMod/LuaGame.cs @@ -19,9 +19,8 @@ public static partial class LuaGame [LuaFunction] static int AddParticles(ILuaInterface lua) { string file = g_Lua!.CheckString(1); - if (LuaFileLibrary.IsFileAccessAllowed(file, "GAME", false, false)) { - // GMOD_LoadParticleConfigFile(file); // TODO! - } + if (LuaFileLibrary.IsFileAccessAllowed(file, "GAME", false, false)) + GMOD_LoadParticleConfigFile(file); return 0; } diff --git a/Game.Shared/GarrysMod/LuaGlobalFunctions.cs b/Game.Shared/GarrysMod/LuaGlobalFunctions.cs index 405ed4c5..1a926127 100644 --- a/Game.Shared/GarrysMod/LuaGlobalFunctions.cs +++ b/Game.Shared/GarrysMod/LuaGlobalFunctions.cs @@ -173,12 +173,33 @@ static int PrecacheParticleSystem(ILuaInterface lua) { string name = lua.CheckString(1); #if GAME_DLL GameInterface.PrecacheParticleSystem(name); -#else - // PrecacheParticleSystem(name); // TODO! +#elif CLIENT_DLL + HLClient.PrecacheParticleSystem(name); #endif return 0; } +#if CLIENT_DLL || GAME_DLL + [LuaGlobal] + static int ParticleEffect(ILuaInterface lua) { + QAngle angles = LuaAngle.Get_Angle(3); + Vector3 start = LuaVector.Get_Vector(2); + Vector3 origin = LuaVector.Get_Vector(2); + BaseEntity? entity = LuaEntity.Get_Entity(4, true); + DispatchParticleEffect(lua.CheckString(1), origin, start, angles, entity); + return 0; + } + + [LuaGlobal] + static int ParticleEffectAttach(ILuaInterface lua) { + int attachment = (int)lua.CheckNumber(4); + BaseEntity? entity = LuaEntity.Get_Entity(3, true); + int attachType = (int)lua.CheckNumber(2); + DispatchParticleEffect(lua.CheckString(1), (ParticleAttachment)attachType, entity, attachment, false); + return 0; + } +#endif + [LuaGlobal] static int CompileFile(ILuaInterface lua) { bool showErrors = true; diff --git a/Game.Shared/GarrysMod/LuaUtil.cs b/Game.Shared/GarrysMod/LuaUtil.cs index 1cb9936f..31472be1 100644 --- a/Game.Shared/GarrysMod/LuaUtil.cs +++ b/Game.Shared/GarrysMod/LuaUtil.cs @@ -204,6 +204,28 @@ static int PrecacheSound(ILuaInterface lua) { [LuaFunction] static int NetworkStringToID(string name) => NetworkString.Get(name); + [LuaFunction] + static int ParticleTracer(ILuaInterface lua) { + bool whiz = lua.GetBool(4); + Vector3 end = LuaVector.Get_Vector(3); + Vector3 start = LuaVector.Get_Vector(2); + string? name = lua.CheckString(1); + Game.Util.ParticleTracer(name, start, end, 0, 0, whiz); + return 0; + } + + [LuaFunction] + static int ParticleTracerEx(ILuaInterface lua) { + bool whiz = lua.GetBool(4); + int attachment = (int)lua.CheckNumber(6); + int entIndex = (int)lua.CheckNumber(5); + Vector3 end = LuaVector.Get_Vector(3); + Vector3 start = LuaVector.Get_Vector(2); + string? name = lua.CheckString(1); + Game.Util.ParticleTracer(name, start, end, entIndex, attachment, whiz); + return 0; + } + #endif [LuaFunction] diff --git a/Game.Shared/GarrysMod/WeaponSWEP.cs b/Game.Shared/GarrysMod/WeaponSWEP.cs index a437d7af..51cb60ba 100644 --- a/Game.Shared/GarrysMod/WeaponSWEP.cs +++ b/Game.Shared/GarrysMod/WeaponSWEP.cs @@ -376,6 +376,18 @@ public override void Drop(in Vector3 velocity) { public override ReadOnlySpan GetName() => ScriptedEntity.GetScriptName(); public void RenderScreen() => ScriptedEntity.CallFunction((int)LUA_POOLEDSTRING.RenderScreen, false); + + public override bool GetTracerOrigin(ref Vector3 origin) { + if (!ScriptedEntity.StartFunction((int)LUA_POOLEDSTRING.GetTracerOrigin) || !ScriptedEntity.Call(0, 1)) + return false; + + Source.Common.GarrysMod.Lua.ILuaObject ret = g_Lua!.GetReturn(0); + if (!ret.isVector()) + return false; + + origin = ret.GetVector(); + return true; + } #endif public override int GetSlot() { diff --git a/Game.Shared/ParticleParse.cs b/Game.Shared/ParticleParse.cs index a604c738..76a4f7e6 100644 --- a/Game.Shared/ParticleParse.cs +++ b/Game.Shared/ParticleParse.cs @@ -1,10 +1,17 @@ -using Source.Common; -using System; -using System.Collections.Generic; -using System.Linq; +global using static Game.Shared.ParticleParse; + +using Source.Common; +using Source.Common.Formats.Keyvalues; +using Source.Common.Mathematics; +using Source.Particles; + using System.Numerics; -using System.Text; -using System.Threading.Tasks; + +#if CLIENT_DLL +using Game.Client; +#elif GAME_DLL +using Game.Server; +#endif namespace Game.Shared; @@ -36,3 +43,209 @@ public struct ParticleEffectsControlPoint [NetworkVar("m_vecOffset")] public Vector3 Offset; } + +public static class ParticleParse +{ + public const string PARTICLES_MANIFEST_FILE = "particles/particles_manifest.txt"; + + public static readonly ParticleSystemMgr g_pParticleSystemMgr = new(); + + public static void GetParticleManifest(List list) { + KeyValues manifest = new(PARTICLES_MANIFEST_FILE); + if (manifest.LoadFromFile(filesystem, PARTICLES_MANIFEST_FILE, "GAME")) { + for (KeyValues? sub = manifest.GetFirstSubKey(); sub != null; sub = sub.GetNextKey()) { + if (sub.Name.Equals("file", StringComparison.OrdinalIgnoreCase)) { + list.Add(sub.GetString().ToString()); + continue; + } + + Warning($"CParticleMgr::Init: Manifest '{PARTICLES_MANIFEST_FILE}' with bogus file type '{sub.Name}', expecting 'file'\n"); + } + } + else + Warning($"PARTICLE SYSTEM: Unable to load manifest file '{PARTICLES_MANIFEST_FILE}'\n"); + } + + public static void ParseParticleEffects(bool loadSheets, bool precache) { + g_pParticleSystemMgr.ShouldLoadSheets(loadSheets); + + List files = []; + GetParticleManifest(files); + + foreach (string file in files) + g_pParticleSystemMgr.ReadParticleConfigFile(file, precache, false); + + g_pParticleSystemMgr.DecommitTempMemory(); + } + + public static void GMOD_LoadParticleConfigFile(string file) { + g_pParticleSystemMgr.ShouldLoadSheets(true); + g_pParticleSystemMgr.ReadParticleConfigFile(file, true, false); + g_pParticleSystemMgr.DecommitTempMemory(); + } + + public static void ParseParticleEffectsMap(ReadOnlySpan mapName, bool loadSheets) { + List files = []; + string mapManifestFilename = mapName.IsEmpty ? "" : $"maps/{mapName}_particles.txt"; + + KeyValues manifest = new(mapManifestFilename); + if (!manifest.LoadFromFile(filesystem, mapManifestFilename, "GAME")) + return; + + DevMsg($"Successfully loaded particle effects manifest '{mapManifestFilename}' for map '{mapName}'\n"); + for (KeyValues? sub = manifest.GetFirstSubKey(); sub != null; sub = sub.GetNextKey()) { + if (sub.Name.Equals("file", StringComparison.OrdinalIgnoreCase)) { + string file = sub.GetString().ToString(); + int lastSlash = file.LastIndexOfAny(['/', '\\']); + ReadOnlySpan path = lastSlash >= 0 ? file.AsSpan(0, lastSlash) : []; + if (path.StartsWith("!")) + path = path[1..]; + + if (path.Equals("particles", StringComparison.OrdinalIgnoreCase)) { + files.Add(file); + continue; + } + + Warning($"CParticleMgr::LevelInit: Manifest '{mapManifestFilename}' contains a particle file '{file}' that's not under the particles directory. Custom particles must be placed in the particles directory.\n"); + } + else + Warning($"CParticleMgr::LevelInit: Manifest '{mapManifestFilename}' with bogus file type '{sub.Name}', expecting 'file'\n"); + } + + if (files.Count == 0) + return; + + g_pParticleSystemMgr.ShouldLoadSheets(loadSheets); + + foreach (string file in files) + g_pParticleSystemMgr.ReadParticleConfigFile(file, true, true); + + g_pParticleSystemMgr.DecommitTempMemory(); + } + + static readonly string?[] AttachmentNames = [ + "start_at_origin", + "follow_origin", + "start_at_customorigin", + "start_at_attachment", + "follow_attachment", + "follow_rootbone", + null, + ]; + + public static int GetAttachTypeFromString(ReadOnlySpan str) { + if (str.IsEmpty) + return -1; + + for (int i = 0; i < (int)ParticleAttachment.Max; i++) { + if (AttachmentNames[i] != null && str.Equals(AttachmentNames[i], StringComparison.OrdinalIgnoreCase)) + return i; + } + + return -1; + } + + public const int PARTICLE_DISPATCH_FROM_ENTITY = 1 << 0; + public const int PARTICLE_DISPATCH_RESET_PARTICLES = 1 << 1; + + public static int ParticleSystemIndex(ReadOnlySpan particleName) { +#if CLIENT_DLL + return Game.Client.HLClient.GetParticleSystemIndex(particleName); +#else + return Game.Server.GameInterface.GetParticleSystemIndex(particleName); +#endif + } + + static void SetEffectEntity(EffectData data, BaseEntity? entity) { +#if CLIENT_DLL + data.Entity = entity != null ? entity.GetRefEHandle() : new BaseHandle(); +#else + data.EntIndex = entity != null ? entity.EntIndex() : 0; +#endif + } + + public static void DispatchParticleEffect(ReadOnlySpan particleName, ParticleAttachment attachType, BaseEntity? entity, ReadOnlySpan attachmentName, bool resetAllParticlesOnEntity = false) { + int attachment = -1; + BaseAnimating? animating = entity?.GetBaseAnimating(); + if (animating != null) { + attachment = animating.LookupAttachment(attachmentName); + if (attachment <= 0) + return; + } + + DispatchParticleEffect(particleName, attachType, entity, attachment, resetAllParticlesOnEntity); + } + + public static void DispatchParticleEffect(ReadOnlySpan particleName, ParticleAttachment attachType, BaseEntity? entity = null, int attachmentPoint = -1, bool resetAllParticlesOnEntity = false) { + EffectData data = new(); + + data.HitBox = ParticleSystemIndex(particleName); + if (entity != null) { + SetEffectEntity(data, entity); + data.Flags |= PARTICLE_DISPATCH_FROM_ENTITY; + data.Origin = entity.GetAbsOrigin(); + } + data.DamageType = (int)attachType; + data.AttachmentIndex = attachmentPoint; + + if (resetAllParticlesOnEntity) + data.Flags |= PARTICLE_DISPATCH_RESET_PARTICLES; + +#if GAME_DLL + if ((data.Flags & PARTICLE_DISPATCH_FROM_ENTITY) != 0 && (attachType == ParticleAttachment.AbsOriginFollow || attachType == ParticleAttachment.PointFollow || attachType == ParticleAttachment.RootBoneFollow)) { + ReliableBroadcastRecipientFilter filter = new(); + DispatchEffect("ParticleEffect", data, filter); + return; + } +#endif + DispatchEffect("ParticleEffect", data); + } + + public static void DispatchParticleEffect(int effectIndex, in Vector3 origin, in Vector3 start, in QAngle angles, BaseEntity? entity = null) { + EffectData data = new() { + HitBox = effectIndex, + Origin = origin, + Start = start, + Angles = angles + }; + + SetEffectEntity(data, entity); + if (entity != null) { + data.Flags |= PARTICLE_DISPATCH_FROM_ENTITY; + data.DamageType = (int)ParticleAttachment.CustomOrigin; + } + + DispatchEffect("ParticleEffect", data); + } + + public static void DispatchParticleEffect(ReadOnlySpan particleName, in Vector3 origin, in QAngle angles, BaseEntity? entity = null) + => DispatchParticleEffect(ParticleSystemIndex(particleName), origin, origin, angles, entity); + + public static void DispatchParticleEffect(ReadOnlySpan particleName, in Vector3 origin, in Vector3 start, in QAngle angles, BaseEntity? entity = null) + => DispatchParticleEffect(ParticleSystemIndex(particleName), origin, start, angles, entity); + + public static void StopParticleEffects(BaseEntity? entity) { + EffectData data = new(); + + if (entity != null) + SetEffectEntity(data, entity); + +#if GAME_DLL + ReliableBroadcastRecipientFilter filter = new(); + DispatchEffect("ParticleEffectStop", data, filter); +#else + DispatchEffect("ParticleEffectStop", data); +#endif + } + +#if GAME_DLL + public static void PrecacheStandardParticleSystems() { + for (int i = 0; i < g_pParticleSystemMgr.GetParticleSystemCount(); i++) { + string particleSystemName = g_pParticleSystemMgr.GetParticleSystemNameFromIndex(i); + ParticleSystemDefinition? particleSystem = g_pParticleSystemMgr.FindParticleSystem(particleSystemName); + if (particleSystem != null && particleSystem.ShouldAlwaysPrecache()) + Game.Server.GameInterface.PrecacheParticleSystem(particleSystemName); + } + } +#endif +} diff --git a/Game.Shared/ParticleSystemQuery.cs b/Game.Shared/ParticleSystemQuery.cs new file mode 100644 index 00000000..ba7a373b --- /dev/null +++ b/Game.Shared/ParticleSystemQuery.cs @@ -0,0 +1,560 @@ +using Source; +using Source.Common; +using Source.Common.Engine; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; +using Source.Particles; + +using System.Numerics; +using System.Runtime.CompilerServices; + +#if CLIENT_DLL +using Game.Client; +#elif GAME_DLL +using Game.Server; +#endif + +namespace Game.Shared; + +public sealed class ParticleSystemQuery : IParticleSystemQuery +{ + public static readonly ParticleSystemQuery g_pParticleSystemQuery = new(); + + static readonly object LightMutex = new(); + + public void GetLightingAtPoint(in Vector3 origin, out Color tint) { +#if CLIENT_DLL + if (engine.IsInGame()) { + Vector3 totalColor; + lock (LightMutex) + totalColor = engine.GetLightForPoint(origin, true); + + tint = default; + tint.SetColor((int)(totalColor.X * 255), (int)(totalColor.Y * 255), (int)(totalColor.Z * 255), 0); + return; + } +#endif + tint = new(255, 255, 255, 255); + } + + public void TraceLine(in Vector3 absStart, in Vector3 absEnd, Mask mask, IHandleEntity? ignore, int collisionGroup, ref GameTrace trace) { + bool doTrace = false; +#if CLIENT_DLL + doTrace = engine.IsInGame(); +#endif + if (doTrace) { + Util.TraceLine(absStart, absEnd, mask, ignore, (CollisionGroup)collisionGroup, out Trace tempTrace); + trace.StartPos = tempTrace.StartPos; + trace.EndPos = tempTrace.EndPos; + trace.Plane = tempTrace.Plane; + trace.Fraction = tempTrace.Fraction; + trace.Contents = tempTrace.Contents; + trace.DispFlags = tempTrace.DispFlags; + trace.AllSolid = tempTrace.AllSolid; + trace.StartSolid = tempTrace.StartSolid; + } + else { + trace.StartSolid = false; + trace.Fraction = 1.0f; + } + } + + public bool MovePointInsideControllingObject(ParticleCollection particles, object? obj, ref Vector3 pnt) { +#if CLIENT_DLL + if (obj is not C_BaseEntity entity) + return true; + + Ray ray = default; + ray.Init(pnt, pnt); + Trace tr = default; + enginetrace.ClipRayToEntity(in ray, Mask.All, entity, ref tr); + return tr.StartSolid; +#else + return true; +#endif + } + +#if CLIENT_DLL + static C_BaseEntity? GetControlPointMoveParent(ParticleCollection particles, int controlPointNumber) + => particles.ControlPoints[controlPointNumber].Object is StrongBox handle ? handle.Value.Get() : null; + + static bool IsPointInsideEntity(in Vector3 point, C_BaseEntity entity) { + Ray ray = default; + ray.Init(point, point); + Trace tr = default; + enginetrace.ClipRayToEntity(in ray, Mask.All, entity, ref tr); + return tr.StartSolid; + } + + static bool IsZero(in Vector3 v, float tolerance) + => v.X > -tolerance && v.X < tolerance && v.Y > -tolerance && v.Y < tolerance && v.Z > -tolerance && v.Z < tolerance; +#endif + +#if CLIENT_DLL + static MStudioHitboxSet ResolveHitboxSet(StudioHdr studioHdr, C_BaseAnimating animating, string? hitboxSetName) { + if (hitboxSetName != null) { + for (int s = 0; s < studioHdr.NumHitboxSets(); s++) { + MStudioHitboxSet candidate = studioHdr.HitboxSet(s); + if (candidate.Name().Equals(hitboxSetName, StringComparison.OrdinalIgnoreCase)) + return candidate; + } + } + return studioHdr.HitboxSet(animating.GetHitboxSet()); + } +#endif + + public void GetRandomPointsOnControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, int numPtsOut, float bboxScale, int numTrysToGetAPointInsideTheModel, + Span pntsOut, Vector3 directionBias, Span hitBoxRelativeCoordOut = default, Span hitBoxIndexOut = default, int desiredHitbox = -1, string? hitboxSetName = null) { +#if CLIENT_DLL + C_BaseEntity? moveParent = GetControlPointMoveParent(particles, controlPointNumber); + if (moveParent != null) { + float randMax = bboxScale; + float randMin = 1.0f - bboxScale; + particles.GetControlPointAtTime(controlPointNumber, particles.CurTime, out Vector3 basePos); + + int numIters = numTrysToGetAPointInsideTheModel; + if (!IsZero(directionBias, 0.0001f)) + numIters = Math.Max(numIters, 5); + + C_BaseAnimating? animating = moveParent.GetBaseAnimating(); + Span boneIndices = stackalloc int[Studio.MAXSTUDIOBONES]; + if (animating != null && animating.HitboxToWorldTransforms(out Span bones, boneIndices)) { + StudioHdr? studioHdr = animating.GetModelPtr(); + if (studioHdr != null) { + MStudioHitboxSet set = ResolveHitboxSet(studioHdr, animating, hitboxSetName); + float modelScale = animating.GetModelScale(); + int lastHitbox = set.NumHitboxes - 1; + int firstHitbox = 0; + if (desiredHitbox >= 0) { + firstHitbox = Math.Min(desiredHitbox, lastHitbox); + lastHitbox = firstHitbox; + } + + Vector3 worldPosition = Vector3.Zero; + float u = 0, v = 0, w = 0; + int hitbox = 0; + for (int i = 0; i < numPtsOut; i++) { + int tryCnt = numIters; + float bestPointGoodness = -1.0e20f; + do { + int tryHitbox = particles.RandomInt(firstHitbox, lastHitbox); + MStudioBBox box = set.Hitbox(tryHitbox); + if ((uint)box.Bone >= Studio.MAXSTUDIOBONES || box.Bone >= studioHdr.NumBones()) + continue; + + float tryU = particles.RandomFloat(randMin, randMax); + float tryV = particles.RandomFloat(randMin, randMax); + float tryW = particles.RandomFloat(randMin, randMax); + + Vector3 localPosition = new( + MathLib.Lerp(tryU, box.BBMin.X * modelScale, box.BBMax.X * modelScale), + MathLib.Lerp(tryV, box.BBMin.Y * modelScale, box.BBMax.Y * modelScale), + MathLib.Lerp(tryW, box.BBMin.Z * modelScale, box.BBMax.Z * modelScale)); + + MathLib.VectorTransform(in localPosition, in bones[boneIndices[box.Bone]], out Vector3 tryWorldPosition); + + float pointGoodness = particles.RandomFloat(0, 72) + Vector3.Dot(tryWorldPosition - basePos, directionBias); + if (numTrysToGetAPointInsideTheModel != 0 && IsPointInsideEntity(tryWorldPosition, moveParent)) + pointGoodness += 1000.0f; + + if (pointGoodness > bestPointGoodness) { + u = tryU; + v = tryV; + w = tryW; + worldPosition = tryWorldPosition; + hitbox = tryHitbox; + bestPointGoodness = pointGoodness; + } + } while (tryCnt-- != 0); + + pntsOut[i] = worldPosition; + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = new(u, v, w); + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = hitbox; + } + } + } + + if (moveParent.IsBrushModel()) { + moveParent.GetRenderBounds(out Vector3 min, out Vector3 max); + ref readonly Matrix3x4 orientation = ref moveParent.EntityToWorldTransform(); + + for (int i = 0; i < numPtsOut; i++) { + Vector3 worldPosition = Vector3.Zero; + float u = 0, v = 0, w = 0; + int tryCnt = numIters; + float bestPointGoodness = -1.0e20f; + do { + float tryU = particles.RandomFloat(randMin, randMax); + float tryV = particles.RandomFloat(randMin, randMax); + float tryW = particles.RandomFloat(randMin, randMax); + + Vector3 localPosition = new(MathLib.Lerp(tryU, min.X, max.X), MathLib.Lerp(tryV, min.Y, max.Y), MathLib.Lerp(tryW, min.Z, max.Z)); + MathLib.VectorTransform(in localPosition, in orientation, out Vector3 tryWorldPosition); + + float pointGoodness = particles.RandomFloat(0, 72) + Vector3.Dot(tryWorldPosition - basePos, directionBias); + if (numTrysToGetAPointInsideTheModel != 0 && IsPointInsideEntity(tryWorldPosition, moveParent)) + pointGoodness += 1000.0f; + + if (pointGoodness > bestPointGoodness) { + u = tryU; + v = tryV; + w = tryW; + worldPosition = tryWorldPosition; + bestPointGoodness = pointGoodness; + } + } while (tryCnt-- != 0); + + pntsOut[i] = worldPosition; + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = new(u, v, w); + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = 0; + } + } + return; + } +#endif + + for (int i = 0; i < numPtsOut; i++) { + pntsOut[i] = particles.ControlPoints[controlPointNumber].Position; + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = 0; + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = Vector3.Zero; + } + } + + public void GetClosestControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, int numPtsIn, float bboxScale, ReadOnlySpan pntsIn, + Span hitBoxRelativeCoordOut = default, Span hitBoxIndexOut = default, int desiredHitbox = -1, string? hitboxSetName = null) { +#if CLIENT_DLL + C_BaseEntity? moveParent = GetControlPointMoveParent(particles, controlPointNumber); + if (moveParent != null) { + float randMax = bboxScale; + float randMin = 1.0f - bboxScale; + + C_BaseAnimating? animating = moveParent.GetBaseAnimating(); + Span boneIndices = stackalloc int[Studio.MAXSTUDIOBONES]; + if (animating != null && animating.HitboxToWorldTransforms(out Span bones, boneIndices)) { + StudioHdr? studioHdr = animating.GetModelPtr(); + if (studioHdr != null) { + MStudioHitboxSet set = ResolveHitboxSet(studioHdr, animating, hitboxSetName); + int endHitbox = set.NumHitboxes - 1; + int startHitbox = 0; + if (desiredHitbox >= 0) { + startHitbox = Math.Min(desiredHitbox, endHitbox); + endHitbox = startHitbox; + } + + float u = 0, v = 0, w = 0; + int hitbox = 0; + for (int i = 0; i < numPtsIn; i++) { + float closest = float.MaxValue; + for (int tryHitbox = startHitbox; tryHitbox < endHitbox; tryHitbox++) { + MStudioBBox box = set.Hitbox(tryHitbox); + float tryU = particles.RandomFloat(randMin, randMax); + float tryV = particles.RandomFloat(randMin, randMax); + float tryW = particles.RandomFloat(randMin, randMax); + + Vector3 center = (box.BBMin + box.BBMax) * 0.5f; + MathLib.VectorTransform(in center, in bones[boneIndices[box.Bone]], out Vector3 worldCenter); + Vector3 delta = worldCenter - pntsIn[i]; + float distance = MathF.Sqrt(delta.Y * delta.Y + delta.X * delta.X + delta.Z * delta.Z); + if (distance < closest) { + closest = distance; + u = tryU; + v = tryV; + w = tryW; + hitbox = tryHitbox; + } + } + + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = new(u, v, w); + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = hitbox; + } + return; + } + } + } +#endif + + for (int i = 0; i < numPtsIn; i++) { + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = 0; + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = Vector3.Zero; + } + } + + public int GetControllingObjectHitBoxInfo(ParticleCollection particles, int controlPointNumber, Span hitBoxOutputBuffer, string? hitboxSetName = null) { + int ret = 0; +#if CLIENT_DLL + C_BaseEntity? moveParent = GetControlPointMoveParent(particles, controlPointNumber); + if (moveParent != null) { + C_BaseAnimating? animating = moveParent.GetBaseAnimating(); + Span boneIndices = stackalloc int[Studio.MAXSTUDIOBONES]; + if (animating != null && animating.HitboxToWorldTransforms(out Span bones, boneIndices)) { + StudioHdr? studioHdr = animating.GetModelPtr(); + if (studioHdr != null) { + MStudioHitboxSet set = ResolveHitboxSet(studioHdr, animating, hitboxSetName); + ret = Math.Min(hitBoxOutputBuffer.Length, set.NumHitboxes); + for (int i = 0; i < ret; i++) { + MStudioBBox box = set.Hitbox(i); + hitBoxOutputBuffer[i].BoxMins = box.BBMin; + hitBoxOutputBuffer[i].BoxMaxes = box.BBMax; + hitBoxOutputBuffer[i].Transform = bones[boneIndices[box.Bone]]; + } + } + } + if (moveParent.IsBrushModel()) { + moveParent.GetRenderBounds(out Vector3 min, out Vector3 max); + hitBoxOutputBuffer[0].BoxMins = min; + hitBoxOutputBuffer[0].BoxMaxes = max; + hitBoxOutputBuffer[0].Transform = moveParent.EntityToWorldTransform(); + ret = 1; + } + } +#endif + return ret; + } + + static readonly (string Name, CollisionGroup Group)[] NameMap = [ + ("NONE", CollisionGroup.None), + ("DEBRIS", CollisionGroup.Debris), + ("INTERACTIVE", CollisionGroup.Interactive), + ("NPC", CollisionGroup.NPC), + ("ACTOR", CollisionGroup.NPCActor), + ("PASSABLE", CollisionGroup.PassableDoor), + ]; + + public int GetCollisionGroupFromName(ReadOnlySpan collisionGroupName) { + foreach ((string name, CollisionGroup group) in NameMap) { + if (collisionGroupName.Equals(name, StringComparison.OrdinalIgnoreCase)) + return (int)group; + } + return (int)CollisionGroup.None; + } + + public Vector3 GetLocalPlayerPos() { +#if CLIENT_DLL + C_BasePlayer? player = C_BasePlayer.GetLocalPlayer(); +#elif GAME_DLL + BasePlayer? player = AI_UtilsGlobals.AI_GetSinglePlayer(); +#else + object? player = null; +#endif +#if CLIENT_DLL || GAME_DLL + if (player == null) + return Vector3.Zero; + return player.WorldSpaceCenter(); +#else + return Vector3.Zero; +#endif + } + + public void GetLocalPlayerEyeVectors(out Vector3 forward, out Vector3 right, out Vector3 up) { +#if CLIENT_DLL + C_BasePlayer? player = C_BasePlayer.GetLocalPlayer(); +#elif GAME_DLL + BasePlayer? player = AI_UtilsGlobals.AI_GetSinglePlayer(); +#endif +#if CLIENT_DLL || GAME_DLL + if (player != null) { + player.EyeVectors(out forward, out right, out up); + return; + } +#endif + forward = Vector3.Zero; + right = Vector3.Zero; + up = Vector3.Zero; + } + + public float GetPixelVisibility(ref int queryHandle, in Vector3 origin, float scale) => 0.0f; + + public void SetUpLightingEnvironment(in Vector3 pos) { +#if CLIENT_DLL + if (!engine.IsInGame()) + return; + + lock (LightMutex) + modelrender.SetupLighting(pos); +#endif + } + + public object? GetModel(ReadOnlySpan mdlName) { +#if CLIENT_DLL + return engine.LoadModel($"models/{mdlName}"); +#else + return null; +#endif + } + + public int GetActivityNumber(object? model, ReadOnlySpan activityName) { +#if CLIENT_DLL + if (model is not Model mdl) + return -1; + + StudioHeader? studioHeader = modelinfo.GetStudiomodel(mdl); + if (studioHeader == null) + return -1; + + StudioHdr studioHdr = new(); + studioHdr.Init(studioHeader, mdlcache); + Activity activity = Animation.LookupActivity(studioHdr, activityName); + return Animation.SelectWeightedSequence(studioHdr, activity, -1); +#else + return -1; +#endif + } + + public void DrawModel(object? model, in Matrix3x4 drawMatrix, ParticleCollection particles, int particleNumber, int bodyPart, int subModel, int skin, int animationSequence, float animationRate, float r, float g, float b, float a) { +#if CLIENT_DLL + if (model is not Model mdl) + return; + + MDLHandle_t handle = modelinfo.GetCacheHandle(mdl); + StudioHeader? studioHeader = mdlcache.GetStudioHdr(handle); + + ParticleModelDraw draw = new(); + draw.SetMDL(handle); + + if (studioHeader != null && bodyPart >= 0 && bodyPart < studioHeader.NumBodyParts) { + MStudioBodyParts bodyParts = studioHeader.BodyPart(bodyPart); + if (subModel < bodyParts.NumModels) + draw.Body += (subModel - draw.Body / bodyParts.Base % bodyParts.NumModels) * bodyParts.Base; + } + + draw.Time = particles.CurTime; + draw.R = unchecked((byte)(int)(r * 255.0f)); + draw.G = unchecked((byte)(int)(g * 255.0f)); + draw.B = unchecked((byte)(int)(b * 255.0f)); + draw.A = unchecked((byte)(int)(a * 255.0f)); + draw.Skin = skin; + draw.Sequence = animationSequence; + draw.PlaybackRate = animationRate; + + if (studioHeader != null) { + Span boneToWorld = new Matrix3x4[studioHeader.NumBones]; + draw.SetUpBones(drawMatrix, studioHeader.NumBones, boneToWorld); + draw.Draw(drawMatrix, boneToWorld, StudioRenderFlags.DrawNoShadows); + } + + draw.UnreferenceMDL(); +#endif + } +} + +#if CLIENT_DLL +struct ParticleModelDraw() +{ + public MDLHandle_t Handle = MDLHANDLE_INVALID; + public byte R = 255, G = 255, B = 255, A = 255; + public int Skin; + public int Body; + public int Sequence; + public int Lod; + public float PlaybackRate = 30.0f; + public float Time; + + static readonly float[] FlexControls = new float[Studio.MAXSTUDIOFLEXCTRL * 4]; + + public void SetMDL(MDLHandle_t handle) { + UnreferenceMDL(); + Handle = handle; + if (Handle == MDLHANDLE_INVALID) + return; + + mdlcache.AddRef(Handle); + StudioHeader? hdr = mdlcache.LockStudioHdr(Handle); + if (hdr == null) + return; + + for (int i = 0; i < hdr.NumFlexControllers; i++) { + MStudioFlexController controller = hdr.FlexController((LocalFlexController)i); + if (controller.LocalToGlobal == -1) + controller.LocalToGlobal = i; + } + } + + public void UnreferenceMDL() { + if (Handle == MDLHANDLE_INVALID) + return; + + mdlcache.UnlockStudioHdr(Handle); + mdlcache.Release(Handle); + Handle = MDLHANDLE_INVALID; + } + + public readonly void SetUpBones(in Matrix3x4 rootToWorld, int maxBoneCount, Span boneToWorld) { + StudioHdr studioHdr = new(); + studioHdr.Init(mdlcache.GetStudioHdr(Handle), mdlcache); + + Span poseParameter = stackalloc float[Studio.MAXSTUDIOPOSEPARAM]; + int poseCount = studioHdr.GetNumPoseParameters(); + for (int i = 0; i < Studio.MAXSTUDIOPOSEPARAM; i++) { + poseParameter[i] = 0.5f; + if (i < poseCount) { + MStudioPoseParamDesc pose = studioHdr.PoseParameter(i); + if (pose.Start < 0.0f && pose.End > 0.0f) + poseParameter[i] = -pose.Start / (pose.End - pose.Start); + } + } + + int frameCount = BoneSetup.Studio_MaxFrame(studioHdr, Sequence, poseParameter); + if (frameCount == 0) + frameCount = 1; + float cycle = Time * PlaybackRate / frameCount; + cycle -= (int)cycle; + + Span pos = stackalloc Vector3[Studio.MAXSTUDIOBONES]; + Span q = stackalloc Quaternion[Studio.MAXSTUDIOBONES]; + + BoneSetup boneSetup = new(studioHdr, Studio.BONE_USED_BY_ANYTHING_AT_LOD(Lod), poseParameter); + boneSetup.InitPose(pos, q); + boneSetup.AccumulatePose(pos, q, Sequence, cycle, 1.0f, Time, null); + + int numBones = Math.Min(maxBoneCount, studioHdr.NumBones()); + for (int i = 0; i < numBones; i++) { + MathLib.QuaternionMatrix(q[i], pos[i], out Matrix3x4 boneMatrix); + int parent = studioHdr.Bone(i).Parent; + if (parent == -1) + MathLib.ConcatTransforms(rootToWorld, boneMatrix, out boneToWorld[i]); + else + MathLib.ConcatTransforms(boneToWorld[parent], boneMatrix, out boneToWorld[i]); + } + } + + public readonly void Draw(in Matrix3x4 rootToWorld, Span boneToWorld, StudioRenderFlags flags) { + if (Handle == MDLHANDLE_INVALID) + return; + + studiorender.SetColorModulation(new(R / 255.0f, G / 255.0f, B / 255.0f)); + studiorender.SetAlphaModulation(A / 255.0f); + + DrawModelInfo info = default; + info.StudioHdr = mdlcache.GetStudioHdr(Handle)!; + info.HardwareData = mdlcache.GetHardwareData(Handle)!; + info.Skin = Skin; + info.Body = Body; + info.HitboxSet = 0; + info.Lod = Lod; + + Vector3 modelOrigin = new(rootToWorld.M03, rootToWorld.M13, rootToWorld.M23); + studiorender.SetEyeViewTarget(info.StudioHdr, info.Body, in modelOrigin); + + Span flexWeights = default; + if (info.StudioHdr.NumFlexDesc != 0) { + StudioHdr studioHdr = new(); + studioHdr.Init(info.StudioHdr, mdlcache); + studiorender.LockFlexWeights(info.StudioHdr.NumFlexDesc, out flexWeights); + studioHdr.RunFlexRules(FlexControls, flexWeights); + studiorender.UnlockFlexWeights(); + } + + studiorender.DrawModel(ref Unsafe.NullRef(), ref info, boneToWorld, flexWeights, default, in modelOrigin, flags); + } +} +#endif diff --git a/Game.Shared/UtilShared.cs b/Game.Shared/UtilShared.cs index d00f9292..fe3fa223 100644 --- a/Game.Shared/UtilShared.cs +++ b/Game.Shared/UtilShared.cs @@ -174,6 +174,16 @@ public static void UTIL_StringToIntArray(Span vec, int count, ReadOnlySpan< vec[j] = atoi(pString[start..pos]); } } + + public const int TRACER_FLAG_WHIZ = 0x0001; + public const int TRACER_FLAG_USEATTACHMENT = 0x0002; + public const int TRACER_DONT_USE_ATTACHMENT = -1; + + public const int TRACER_TYPE_DEFAULT = 0x00000001; + public const int TRACER_TYPE_GUNSHIP = 0x00000002; + public const int TRACER_TYPE_STRIDER = 0x00000004; + public const int TRACER_TYPE_GAUSS = 0x00000008; + public const int TRACER_TYPE_WATERBULLET = 0x00000010; } public static partial class Util @@ -184,6 +194,30 @@ public static partial class Util #endif static readonly ConVar developer = new("developer", "0", 0, "Set developer message level"); // developer mode + public static void ParticleTracer(ReadOnlySpan tracerEffectName, in Vector3 vecStart, in Vector3 vecEnd, int entIndex, int attachment, bool whiz) { + Game.Shared.EffectData data = new() { + Start = vecStart, + Origin = vecEnd, + Scale = 0, + HitBox = Game.Shared.ParticleParse.ParticleSystemIndex(tracerEffectName) + }; +#if CLIENT_DLL + data.Entity = cl_entitylist.EntIndexToHandle(entIndex); +#else + data.EntIndex = entIndex; +#endif + + if (whiz) + data.Flags |= TRACER_FLAG_WHIZ; + + if (attachment != TRACER_DONT_USE_ATTACHMENT) { + data.Flags |= TRACER_FLAG_USEATTACHMENT; + data.AttachmentIndex = attachment; + } + + DispatchEffect("ParticleTracer", data); + } + public static Contents PointContents(in Vector3 vec) => enginetrace.GetPointContents(vec, out _); // UTIL_StringToColor32: parses "r g b a" into a color. diff --git a/Source.Common/CollisionUtils.cs b/Source.Common/CollisionUtils.cs index 8aefd9b0..efa4f500 100644 --- a/Source.Common/CollisionUtils.cs +++ b/Source.Common/CollisionUtils.cs @@ -28,6 +28,37 @@ public static void Collision_ClearTrace(in Vector3 rayStart, in Vector3 rayDelta trace.Contents = 0; } + public static bool IntersectRayWithRay(in Ray ray0, in Ray ray1, out float t0, out float t1) { + Vector3 v0 = ray0.Delta; + Vector3 v1 = ray1.Delta; + MathLib.VectorNormalize(ref v0); + MathLib.VectorNormalize(ref v1); + + float cx = v1.Z * v0.Y - v1.Y * v0.Z; + float cy = v1.X * v0.Z - v0.X * v1.Z; + float cz = v0.X * v1.Y - v1.X * v0.Y; + float lenSq = cy * cy + cx * cx + cz * cz; + if (lenSq == 0.0f) { + t0 = 0.0f; + t1 = 0.0f; + return false; + } + + float inv = 1.0f / lenSq; + float dx = ray1.Start.X - ray0.Start.X; + float dy = ray1.Start.Y - ray0.Start.Y; + float dz = ray1.Start.Z - ray0.Start.Z; + float ax = dz * cy - dy * cz; + float ay = dx * cz - dz * cx; + float az = dy * cx - dx * cy; + t1 = (ay * v0.Y + ax * v0.X + az * v0.Z) * inv; + t0 = (ay * v1.Y + ax * v1.X + az * v1.Z) * inv; + + return v0.X * t0 + ray0.Start.X == v1.X * t1 + ray1.Start.X + && v0.Y * t0 + ray0.Start.Y == v1.Y * t1 + ray1.Start.Y + && v0.Z * t0 + ray0.Start.Z == v1.Z * t1 + ray1.Start.Z; + } + public static bool IntersectRayWithBox(in Vector3 rayStart, in Vector3 rayDelta, in Vector3 boxMins, in Vector3 boxMaxs, float tolerance, out BoxTraceInfo trace) { int i; float d1, d2; diff --git a/Source.Common/Mathematics/MathLib.cs b/Source.Common/Mathematics/MathLib.cs index 31438bfc..5643fa15 100644 --- a/Source.Common/Mathematics/MathLib.cs +++ b/Source.Common/Mathematics/MathLib.cs @@ -2359,6 +2359,12 @@ public static void MatrixGetColumn(in Matrix3x4 inMatrix, int column, out Vector outVec.Y = inMatrix[1][column]; outVec.Z = inMatrix[2][column]; } + public static void MatrixVectors(in Matrix3x4 matrix, out Vector3 forward, out Vector3 right, out Vector3 up) { + MatrixGetColumn(matrix, 0, out forward); + MatrixGetColumn(matrix, 1, out right); + MatrixGetColumn(matrix, 2, out up); + right *= -1.0f; + } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void PositionMatrix(in Vector3 position, ref Matrix3x4 mat) { MatrixSetColumn(in position, 3, ref mat); @@ -3537,6 +3543,21 @@ public static void CalcClosestPointOnLineSegment(in Vector3 P, in Vector3 vLineA VectorMA(vLineA, t, vDir, out vClosest); } + public static float CalcDistanceSqrToLineSegment(in Vector3 P, in Vector3 vLineA, in Vector3 vLineB) => CalcDistanceSqrToLineSegment(P, vLineA, vLineB, out _); + + public static float CalcDistanceSqrToLineSegment(in Vector3 P, in Vector3 vLineA, in Vector3 vLineB, out float outT) { + float t = CalcClosestPointToLineT(P, vLineA, vLineB, out Vector3 vDir); + if (t <= 0) + t = 0; + if (1 <= t) + t = 1; + outT = t; + float dx = P.X - (vDir.X * t + vLineA.X); + float dy = P.Y - (vDir.Y * t + vLineA.Y); + float dz = P.Z - (vDir.Z * t + vLineA.Z); + return dy * dy + dx * dx + dz * dz; + } + const int NUMVERTEXNORMALS = 162; public static readonly Vector3[] Anorms = [ new(-0.525731f, 0.000000f, 0.850651f), diff --git a/Source.NET.slnx b/Source.NET.slnx index a3f97c6c..505d8d7f 100644 --- a/Source.NET.slnx +++ b/Source.NET.slnx @@ -119,6 +119,9 @@ + + + diff --git a/Source.Particles/BuiltinParticleConstraints.cs b/Source.Particles/BuiltinParticleConstraints.cs new file mode 100644 index 00000000..7123158a --- /dev/null +++ b/Source.Particles/BuiltinParticleConstraints.cs @@ -0,0 +1,696 @@ +using Source.Common; +using Source.Common.Formats.BSP; + +using System.Numerics; +using System.Runtime.CompilerServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleConstraints +{ + public static void AddBuiltInParticleConstraints(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_ConstrainDistance.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_ConstrainDistanceToPath.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_PlanarConstraint.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_WorldCollideConstraint.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_WorldTraceConstraint.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Constraint, C_OP_BoxConstraint.Definition); + } +} + +public static class CollisionMode +{ + public const int PER_PARTICLE_TRACE = 0; + public const int PER_FRAME_PLANESET = 1; + public const int INITIAL_TRACE_DOWN = 2; + public const int USE_NEAREST_TRACE = 3; +} + +[InlineArray(WorldCollideContextData.MAX_PLANES)] +public struct WorldCollidePlaneVectors +{ + Vector3 element; +} + +[InlineArray(WorldCollideContextData.MAX_PLANES)] +public struct WorldCollidePlaneFlags +{ + bool element; +} + +public struct WorldCollideContextData +{ + public const int MAX_PLANES = 41; + + public WorldCollidePlaneVectors TraceStartPnt; + public WorldCollidePlaneVectors TraceEndPnt; + public WorldCollidePlaneVectors PointOnPlane; + public WorldCollidePlaneVectors PlaneNormal; + public int ActivePlanes; + public int NumFixedPlanes; + public float LastUpdateTime; + public Vector3 LastUpdateOrigin; + public WorldCollidePlaneFlags PlaneActive; + + public void SetBaseTrace(ParticleSystemMgr mgr, int index, in Vector3 rayStart, in Vector3 traceDir, int collisionGroup, bool keepMisses) { + GameTrace tr = default; + Vector3 rayEnd = rayStart + traceDir; + mgr.Query().TraceLine(rayStart, rayEnd, Mask.Solid, null, collisionGroup, ref tr); + if (tr.Fraction < 1.0f) { + PlaneActive[index] = true; + PointOnPlane[index] = rayStart + tr.Fraction * traceDir; + PlaneNormal[index] = tr.Plane.Normal; + TraceStartPnt[index] = rayStart; + TraceEndPnt[index] = rayEnd; + } + else if (keepMisses) { + PlaneNormal[index] = Vector3.Zero; + TraceStartPnt[index] = rayStart; + TraceEndPnt[index] = rayEnd; + PlaneActive[index] = true; + } + else + PlaneActive[index] = false; + } + + public void CalculatePlanes(ParticleCollection particles, int collisionMode, int collisionGroup, in Vector3 cpOffset, float distanceTolerance) { + if (ActivePlanes != 0 && collisionMode == CollisionMode.INITIAL_TRACE_DOWN) + return; + + Vector3 rayStart = particles.GetControlPointAtCurrentTime(0) + cpOffset; + if (LastUpdateTime > 0.0f && (rayStart - LastUpdateOrigin).LengthSquared() < distanceTolerance * distanceTolerance) + return; + + ParticleSystemMgr mgr = particles.Mgr!; + LastUpdateOrigin = rayStart; + ActivePlanes = 0; + + int indexOut = 0; + switch (collisionMode) { + case CollisionMode.INITIAL_TRACE_DOWN: + SetBaseTrace(mgr, 0, rayStart, new Vector3(0, 0, -1000.0f), collisionGroup, false); + ActivePlanes = 1; + NumFixedPlanes = 1; + return; + case CollisionMode.PER_FRAME_PLANESET: + case CollisionMode.USE_NEAREST_TRACE: + bool keepMisses = collisionMode == CollisionMode.USE_NEAREST_TRACE; + for (int i = -1; i <= 1; i++) + for (int j = -1; j <= 1; j++) + for (int k = -1; k <= 1; k++) { + if (i != 0 || j != 0 || k != 0) + SetBaseTrace(mgr, indexOut++, rayStart, new Vector3(i * 1000.0f, j * 1000.0f, k * 1000.0f), collisionGroup, keepMisses); + } + break; + default: + return; + } + + NumFixedPlanes = indexOut; + ActivePlanes = indexOut; + if (indexOut > MAX_PLANES) { + Warning($"C_OP_WorldCollideConstraint: Insane active plane count {indexOut}! Fixing..\n"); + ActivePlanes = 0; + } + } +} + +internal static class ParticleConstraintUtil +{ + public const float FLT_EPSILON = 1.1920929e-07f; + + public static Vector3 Load(Span memory, int index, int lane) => new(memory[index + lane], memory[index + 4 + lane], memory[index + 8 + lane]); + + public static void Store(Span memory, int index, int lane, in Vector3 value) { + memory[index + lane] = value.X; + memory[index + 4 + lane] = value.Y; + memory[index + 8 + lane] = value.Z; + } + + public static float RSqrt(float x) => 1.0f / MathF.Sqrt(x); + + public static float RSqrtSaturate(float x) => RSqrt(x == 0.0f ? FLT_EPSILON : x); + + public static float MaxPs(float a, float b) => a > b ? a : b; + public static float MinPs(float a, float b) => a < b ? a : b; + + public static float Blend(uint mask, float a, float b) + => BitConverter.UInt32BitsToSingle((BitConverter.SingleToUInt32Bits(a) & mask) | (BitConverter.SingleToUInt32Bits(b) & ~mask)); + + public static Vector3 Blend(uint mask, in Vector3 a, in Vector3 b) => new(Blend(mask, a.X, b.X), Blend(mask, a.Y, b.Y), Blend(mask, a.Z, b.Z)); + + public static float DistSqrToLineSegment(in Vector3 p, in Vector3 lineA, in Vector3 lineB) { + Vector3 aToB = lineB - lineA; + Vector3 aToP = p - lineA; + float t = Vector3.Dot(aToB, aToP) * (1.0f / Vector3.Dot(aToB, aToB)); + t = MaxPs(MinPs(t, 1.0f), 0.0f); + Vector3 closest = aToB * t - aToP; + return closest.LengthSquared(); + } +} + +public sealed class C_OP_ConstrainDistance : ParticleOperatorInstance +{ + public float MinDistance; + public float MaxDistance; + public int ControlPointNumber; + public Vector3 CenterOffset; + public bool GlobalCenter; + + public static readonly ParticleOperatorDefinition Definition = new("Constrain distance to control point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("minimum distance", "0", (o, v) => o.MinDistance = v) + .Float("maximum distance", "100", (o, v) => o.MaxDistance = v) + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Vector3("offset of center", "0 0 0", (o, v) => o.CenterOffset = v) + .Bool("global center point", "0", (o, v) => o.GlobalCenter = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + Vector3 center; + if (GlobalCenter) + center = CenterOffset; + else { + particles.GetControlPointAtTime(ControlPointNumber, particles.CurTime, out center); + center += particles.TransformAxis(CenterOffset, true, ControlPointNumber); + } + + float minDist2 = MinDistance * MinDistance; + float maxDist2 = MaxDistance * MaxDistance; + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int stride) + stride * startBlock; + bool changed = false; + for (int block = 0; block < numBlocks; block++, xyz += stride) { + for (int lane = 0; lane < 4; lane++) { + Vector3 pts = ParticleConstraintUtil.Load(memory, xyz, lane) - center; + float distSq = pts.LengthSquared(); + bool tooFar = distSq > maxDist2; + bool tooClose = distSq < minDist2; + if (!tooFar && !tooClose) + continue; + changed = true; + pts *= ParticleConstraintUtil.RSqrtSaturate(distSq); + ParticleConstraintUtil.Store(memory, xyz, lane, pts * (tooClose ? MinDistance : MaxDistance) + center); + } + } + return changed; + } +} + +public sealed class C_OP_ConstrainDistanceToPath : ParticleOperatorInstance +{ + public float MinDistance; + public float MaxDistance0; + public float MaxDistanceMid; + public float MaxDistance1; + public PathParameters PathParameters; + public float TravelTime; + + public static readonly ParticleOperatorDefinition Definition = new("Constrain distance to path between two control points", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("minimum distance", "0", (o, v) => o.MinDistance = v) + .Float("maximum distance", "100", (o, v) => o.MaxDistance0 = v) + .Float("maximum distance middle", "-1", (o, v) => o.MaxDistanceMid = v) + .Float("maximum distance end", "-1", (o, v) => o.MaxDistance1 = v) + .Float("travel time", "10", (o, v) => o.TravelTime = v) + .Float("random bulge", "0", (o, v) => o.PathParameters.Bulge = v) + .Int("start control point number", "0", (o, v) => o.PathParameters.StartControlPointNumber = v) + .Int("end control point number", "0", (o, v) => o.PathParameters.EndControlPointNumber = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParameters.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParameters.MidPoint = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => (1UL << PathParameters.StartControlPointNumber) | (1UL << PathParameters.EndControlPointNumber); + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + particles.CalculatePathValues(PathParameters, particles.CurTime, out Vector3 startPnt, out Vector3 midP, out Vector3 endPnt); + + float curTime = particles.CurTime; + float timeScale = 1.0f / MathF.Max(0.001f, TravelTime); + + bool constantRadius = true; + float rad0 = MaxDistance0; + float radm = rad0; + if (MaxDistanceMid >= 0.0f) { + constantRadius = MaxDistanceMid == MaxDistance0; + radm = MaxDistanceMid; + } + float rad1 = radm; + if (MaxDistance1 >= 0.0f) { + constantRadius &= MaxDistance1 == MaxDistance0; + rad1 = MaxDistance1; + } + + float radmMinusRad0 = radm - rad0; + float rad1MinusRadm = rad1 - radm; + float minDist2 = MinDistance * MinDistance; + float initialMaxDist = MathF.Max(rad0, MathF.Max(radm, rad1)); + float maxDist2 = initialMaxDist * initialMaxDist; + Vector4 maxDist = new(initialMaxDist); + + Vector3 delta0 = midP - startPnt; + Vector3 delta1 = endPnt - midP; + + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int xyzStride) + xyzStride * startBlock; + int creationTime = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_CREATION_TIME, out int ctStride) + ctStride * startBlock; + bool changed = false; + Span centers = stackalloc Vector3[4]; + Span pts = stackalloc Vector3[4]; + Span distSq = stackalloc float[4]; + Span tScale = stackalloc float[4]; + Span tooFar = stackalloc bool[4]; + for (int block = 0; block < numBlocks; block++, xyz += xyzStride, creationTime += ctStride) { + bool anyTooFar = false; + for (int lane = 0; lane < 4; lane++) { + float t = MathF.Min(1.0f, timeScale * (curTime - memory[creationTime + lane])); + Vector3 l0 = delta0 * t + startPnt; + Vector3 l1 = delta1 * t + midP; + Vector3 center = (l1 - l0) * t + l0; + tScale[lane] = t; + centers[lane] = center; + pts[lane] = ParticleConstraintUtil.Load(memory, xyz, lane) - center; + distSq[lane] = pts[lane].LengthSquared(); + tooFar[lane] = distSq[lane] > maxDist2; + anyTooFar |= tooFar[lane]; + } + + if (!constantRadius && !anyTooFar) { + for (int lane = 0; lane < 4; lane++) { + float t = tScale[lane]; + float r0 = rad0 + radmMinusRad0 * t; + float r1 = radm + rad1MinusRadm * t; + float radius = r0 + (r1 - r0) * t; + maxDist[lane] = radius; + tooFar[lane] = distSq[lane] > radius * radius; + } + } + + for (int lane = 0; lane < 4; lane++) { + bool tooClose = distSq[lane] < minDist2; + if (!tooFar[lane] && !tooClose) + continue; + changed = true; + Vector3 dir = pts[lane] * ParticleConstraintUtil.RSqrt(distSq[lane]); + ParticleConstraintUtil.Store(memory, xyz, lane, dir * (tooClose ? MinDistance : maxDist[lane]) + centers[lane]); + } + } + return changed; + } +} + +public sealed class C_OP_PlanarConstraint : ParticleOperatorInstance +{ + public Vector3 PointOnPlane; + public Vector3 PlaneNormal; + public int ControlPointNumber; + public bool GlobalOrigin; + public bool GlobalNormal; + + public static readonly ParticleOperatorDefinition Definition = new("Prevent passing through a plane", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Vector3("plane point", "0 0 0", (o, v) => o.PointOnPlane = v) + .Vector3("plane normal", "0 0 1", (o, v) => o.PlaneNormal = v) + .Bool("global origin", "0", (o, v) => o.GlobalOrigin = v) + .Bool("global normal", "0", (o, v) => o.GlobalNormal = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + Vector3 planeNormal = Vector3.Normalize(particles.TransformAxis(PlaneNormal, !GlobalNormal, ControlPointNumber)); + Vector3 planePoint; + if (GlobalOrigin) + planePoint = PointOnPlane; + else { + Vector3 ofs = particles.TransformAxis(PointOnPlane, true, ControlPointNumber); + particles.GetControlPointAtTime(ControlPointNumber, particles.CurTime, out Vector3 center); + planePoint = ofs + center; + } + + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int xyzStride) + xyzStride * startBlock; + int radius = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_RADIUS, out int radiusStride) + radiusStride * startBlock; + bool changed = false; + for (int block = 0; block < numBlocks; block++, xyz += xyzStride, radius += radiusStride) { + for (int lane = 0; lane < 4; lane++) { + Vector3 pos = ParticleConstraintUtil.Load(memory, xyz, lane); + float planeEq = Vector3.Dot(pos - planePoint, planeNormal) - memory[radius + lane]; + if (planeEq < 0.0f) { + changed = true; + ParticleConstraintUtil.Store(memory, xyz, lane, pos - planeNormal * planeEq); + } + } + } + return changed; + } +} + +public sealed class C_OP_WorldCollideConstraint : ParticleOperatorInstance +{ + public static readonly ParticleOperatorDefinition Definition = new("Prevent passing through static part of world", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin()); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override ulong GetReadControlPointMask() => 1UL; + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void SetupConstraintPerFrameData(ParticleCollection particles, Span context) + => ParticleOpUtil.Context(context).CalculatePlanes(particles, CollisionMode.PER_FRAME_PLANESET, 0, Vector3.Zero, 0.0f); + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + ref WorldCollideContextData ctx = ref ParticleOpUtil.Context(context); + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int xyzStride) + xyzStride * startBlock; + int radius = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_RADIUS, out int radiusStride) + radiusStride * startBlock; + bool changed = false; + for (int block = 0; block < numBlocks; block++, xyz += xyzStride, radius += radiusStride) { + for (int i = 0; i < ctx.ActivePlanes; i++) { + if (!ctx.PlaneActive[i]) + continue; + Vector3 point = ctx.PointOnPlane[i]; + Vector3 normal = ctx.PlaneNormal[i]; + for (int lane = 0; lane < 4; lane++) { + Vector3 pos = ParticleConstraintUtil.Load(memory, xyz, lane); + float planeEq = Vector3.Dot(pos - point, normal) - memory[radius + lane]; + if (planeEq < 0.0f) { + changed = true; + ParticleConstraintUtil.Store(memory, xyz, lane, pos - normal * planeEq); + } + } + } + } + return changed; + } +} + +public sealed class C_OP_WorldTraceConstraint : ParticleOperatorInstance +{ + public Vector3 CpOffset; + public int CollisionModeIndex; + public float BounceAmount; + public float SlideAmount; + public float RadiusScale; + public float CpMovementTolerance; + public float TraceTolerance; + public float MinSpeed; + public bool KillOnContact; + public bool ConfirmCollision; + public string CollisionGroupName = "NONE"; + public int CollisionGroupNumber; + public bool BrushOnly; + + public static readonly ParticleOperatorDefinition Definition = new("Collision via traces", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("collision mode", "0", (o, v) => o.CollisionModeIndex = v) + .Float("amount of bounce", "0", (o, v) => o.BounceAmount = v) + .Float("amount of slide", "0", (o, v) => o.SlideAmount = v) + .Float("radius scale", "1", (o, v) => o.RadiusScale = v) + .Bool("brush only", "0", (o, v) => o.BrushOnly = v) + .String("collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Vector3("control point offset for fast collisions", "0 0 0", (o, v) => o.CpOffset = v) + .Float("control point movement distance tolerance", "5", (o, v) => o.CpMovementTolerance = v) + .Bool("kill particle on collision", "0", (o, v) => o.KillOnContact = v) + .Float("minimum speed to kill on collision", "-1", (o, v) => o.MinSpeed = v) + .Bool("Confirm Collision", "0", (o, v) => o.ConfirmCollision = v) + .Float("trace accuracy tolerance", "24", (o, v) => o.TraceTolerance = v)); + + [InlineArray(4)] + struct LaneVectors + { + Vector3 element; + } + + struct ISectData + { + public Vector4 ISectT; + public Vector4 LeftOverT; + public LaneVectors Normals; + } + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override ulong GetReadControlPointMask() => 1UL; + public override bool IsFinalConstraint() => BounceAmount != 0.0f || SlideAmount != 0.0f; + + public override void InitParams(ParticleSystemDefinition def, Datamodel.Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + CollisionModeIndex = Math.Clamp(CollisionModeIndex, 0, 3); + } + + static void WorldIntersectTNew(ParticleSystemMgr mgr, ReadOnlySpan startPnt, ReadOnlySpan endPnt, int collisionGroup, Mask contentsMask, ref ISectData isect, + int collisionMode, ref WorldCollideContextData ctx, ReadOnlySpan particleValid, float tolerance) { + isect = default; + isect.ISectT = new Vector4(2.0f); + if (collisionMode == CollisionMode.USE_NEAREST_TRACE) { + Span pointOnPlane = stackalloc Vector3[4]; + Span planeNormal = stackalloc Vector3[4]; + Span closestDist = stackalloc float[4]; + closestDist.Fill(float.MaxValue); + for (int i = 0; i < ctx.ActivePlanes; i++) { + if (!ctx.PlaneActive[i]) + continue; + Vector3 traceStart = ctx.TraceStartPnt[i]; + Vector3 traceEnd = ctx.TraceEndPnt[i]; + for (int lane = 0; lane < 4; lane++) { + float trial = ParticleConstraintUtil.MaxPs( + ParticleConstraintUtil.DistSqrToLineSegment(startPnt[lane], traceStart, traceEnd), + ParticleConstraintUtil.DistSqrToLineSegment(endPnt[lane], traceStart, traceEnd)); + bool nearest = trial <= closestDist[lane]; + uint closestBits = BitConverter.SingleToUInt32Bits(closestDist[lane]); + uint nearestMask = nearest ? 0xFFFFFFFFu : 0u; + closestDist[lane] = BitConverter.UInt32BitsToSingle((BitConverter.SingleToUInt32Bits(trial) & closestBits) | (nearestMask & ~closestBits)); + if (nearest) { + pointOnPlane[lane] = ctx.PointOnPlane[i]; + planeNormal[lane] = ctx.PlaneNormal[i]; + } + } + } + + for (int lane = 0; lane < 4; lane++) { + if (!particleValid[lane] || !(closestDist[lane] > tolerance)) + continue; + Vector3 start = startPnt[lane]; + Vector3 delta = endPnt[lane] - start; + float traceScale = MathF.Max(5.0f, 300.0f / (delta.Length() + 0.01f)); + Vector3 end = start + delta * traceScale; + GameTrace tr = default; + mgr.Query().TraceLine(start, end, contentsMask, null, collisionGroup, ref tr); + if (tr.Fraction < 1.0f) { + pointOnPlane[lane] = start + tr.Fraction * (end - start); + planeNormal[lane] = tr.Plane.Normal; + } + else + planeNormal[lane] = Vector3.Zero; + } + + for (int lane = 0; lane < 4; lane++) { + float startDist = Vector3.Dot(startPnt[lane] - pointOnPlane[lane], planeNormal[lane]); + float endDist = Vector3.Dot(endPnt[lane] - pointOnPlane[lane], planeNormal[lane]); + if (!(startDist >= 0.0f && endDist < 0.0f && particleValid[lane])) + continue; + float t = startDist / (startDist - endDist); + if (t < isect.ISectT[lane]) { + isect.ISectT[lane] = t; + isect.Normals[lane] = planeNormal[lane]; + } + } + } + isect.LeftOverT = Vector4.Max(Vector4.Zero, Vector4.One - isect.ISectT); + } + + static void WorldIntersectT(ParticleSystemMgr mgr, ReadOnlySpan startPnt, ReadOnlySpan endPnt, int collisionGroup, Mask contentsMask, ref ISectData isect, + bool hasCtx, ref WorldCollideContextData ctx, ReadOnlySpan particleValid) { + isect = default; + if (hasCtx) { + isect.ISectT = new Vector4(2.0f); + for (int i = 0; i < ctx.ActivePlanes; i++) { + if (!ctx.PlaneActive[i]) + continue; + Vector3 point = ctx.PointOnPlane[i]; + Vector3 normal = ctx.PlaneNormal[i]; + for (int lane = 0; lane < 4; lane++) { + float startDist = Vector3.Dot(startPnt[lane] - point, normal); + float endDist = Vector3.Dot(endPnt[lane] - point, normal); + if (!(startDist >= 0.0f && endDist < 0.0f)) + continue; + float t = startDist / (startDist - endDist); + if (t < isect.ISectT[lane]) { + isect.ISectT[lane] = t; + isect.Normals[lane] = normal; + } + } + } + isect.LeftOverT = Vector4.Max(Vector4.Zero, Vector4.One - isect.ISectT); + return; + } + + for (int lane = 0; lane < 4; lane++) { + if (!particleValid[lane]) + continue; + GameTrace tr = default; + mgr.Query().TraceLine(startPnt[lane], endPnt[lane], contentsMask, null, collisionGroup, ref tr); + isect.ISectT[lane] = tr.Fraction; + isect.LeftOverT[lane] = tr.StartSolid ? 0.0f : 1.0f - tr.Fraction; + isect.Normals[lane] = tr.Plane.Normal; + } + } + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + ParticleSystemMgr mgr = particles.Mgr!; + bool cached = CollisionModeIndex == CollisionMode.USE_NEAREST_TRACE; + bool useLifetime = KillOnContact || MinSpeed > 0.0f; + float minSpeed = particles.Dt * MinSpeed; + bool bouncingOrSliding = BounceAmount != 0.0f || SlideAmount != 0.0f; + Mask contentsMask = BrushOnly ? Mask.SolidBrushOnly : Mask.Solid; + + StrongBox? ctxBox = null; + if (CollisionModeIndex >= CollisionMode.PER_FRAME_PLANESET) { + StrongBox?[] cache = (particles.Parent ?? particles).CollisionCacheData; + ctxBox = cache[CollisionModeIndex]; + if (ctxBox == null) { + ctxBox = new StrongBox(); + ctxBox.Value.ActivePlanes = 0; + ctxBox.Value.LastUpdateTime = -1.0f; + cache[CollisionModeIndex] = ctxBox; + } + if (ctxBox.Value.LastUpdateTime != particles.CurTime) { + ctxBox.Value.CalculatePlanes(particles, CollisionModeIndex, CollisionGroupNumber, CpOffset, CpMovementTolerance); + ctxBox.Value.LastUpdateTime = particles.CurTime; + } + } + ref WorldCollideContextData ctx = ref ctxBox != null ? ref ctxBox.Value : ref Unsafe.NullRef(); + + float tolerance = TraceTolerance * TraceTolerance; + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int xyzStride) + xyzStride * startBlock; + int prevXyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_PREV_XYZ, out int prevStride) + prevStride * startBlock; + int radius = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_RADIUS, out int radiusStride) + radiusStride * startBlock; + int lifetimeStride = 0; + int lifetime = useLifetime ? particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_LIFE_DURATION, out lifetimeStride) + lifetimeStride * startBlock : 0; + + Span prevPnt = stackalloc Vector3[4]; + Span endPnt = stackalloc Vector3[4]; + Span delta = stackalloc Vector3[4]; + Span deltaNormalized = stackalloc Vector3[4]; + Span len2 = stackalloc float[4]; + Span valid = stackalloc bool[4]; + Span didHit = stackalloc uint[4]; + ISectData isect = default; + bool changed = false; + + for (int remaining = numBlocks; remaining > 0; remaining--, xyz += xyzStride, prevXyz += prevStride, radius += radiusStride, lifetime += lifetimeStride) { + for (int lane = 0; lane < 4; lane++) { + Vector3 pos = ParticleConstraintUtil.Load(memory, xyz, lane); + prevPnt[lane] = ParticleConstraintUtil.Load(memory, prevXyz, lane); + delta[lane] = pos - prevPnt[lane]; + len2[lane] = delta[lane].LengthSquared(); + float rs = len2[lane] <= 0.0f ? 0.0f : ParticleConstraintUtil.RSqrt(len2[lane]); + deltaNormalized[lane] = delta[lane] * rs; + endPnt[lane] = pos + deltaNormalized[lane] * (memory[radius + lane] * RadiusScale); + } + + int particlesInChunk = remaining > 1 ? 4 : (activeParticles & 3); + if (particlesInChunk == 0) + particlesInChunk = 4; + for (int lane = 0; lane < 4; lane++) + valid[lane] = lane < particlesInChunk; + + if (cached) + WorldIntersectTNew(mgr, prevPnt, endPnt, CollisionGroupNumber, contentsMask, ref isect, CollisionModeIndex, ref ctx, valid, tolerance); + else + WorldIntersectT(mgr, prevPnt, endPnt, CollisionGroupNumber, contentsMask, ref isect, ctxBox != null, ref ctx, valid); + + bool anyHit = false; + for (int lane = 0; lane < 4; lane++) { + didHit[lane] = len2[lane] > 0.0f && isect.ISectT[lane] < 1.0f ? 0xFFFFFFFFu : 0u; + anyHit |= didHit[lane] != 0; + } + if (!anyHit) + continue; + + changed = true; + if (ConfirmCollision) { + for (int lane = 0; lane < 4; lane++) { + if (didHit[lane] == 0) + continue; + GameTrace tr = default; + mgr.Query().TraceLine(endPnt[lane], endPnt[lane], contentsMask, null, CollisionGroupNumber, ref tr); + didHit[lane] = tr.StartSolid ? 0xFFFFFFFFu : 1u; + } + } + + if (MinSpeed > 0.0f) { + for (int lane = 0; lane < 4; lane++) { + uint tooSlow = MathF.Sqrt(len2[lane]) < minSpeed ? didHit[lane] : 0u; + memory[lifetime + lane] = BitConverter.UInt32BitsToSingle(BitConverter.SingleToUInt32Bits(memory[lifetime + lane]) & ~tooSlow); + } + } + + if (KillOnContact) { + for (int lane = 0; lane < 4; lane++) + memory[lifetime + lane] = BitConverter.UInt32BitsToSingle(BitConverter.SingleToUInt32Bits(memory[lifetime + lane]) & ~didHit[lane]); + continue; + } + + for (int lane = 0; lane < 4; lane++) { + Vector3 newPnt = delta[lane] * isect.ISectT[lane] + prevPnt[lane]; + if (bouncingOrSliding) { + Vector3 normal = isect.Normals[lane]; + float leftOver = isect.LeftOverT[lane]; + Vector3 dn = deltaNormalized[lane]; + Vector3 bouncePart = (dn - normal * (2.0f * Vector3.Dot(dn, normal))) * BounceAmount; + Vector3 newVel = bouncePart; + newPnt += bouncePart * leftOver; + Vector3 slidePart = (delta[lane] - normal * Vector3.Dot(delta[lane], normal)) * SlideAmount; + newVel += slidePart; + newPnt += slidePart * leftOver; + ParticleConstraintUtil.Store(memory, prevXyz, lane, ParticleConstraintUtil.Blend(didHit[lane], newPnt - newVel, prevPnt[lane])); + } + ParticleConstraintUtil.Store(memory, xyz, lane, ParticleConstraintUtil.Blend(didHit[lane], newPnt, ParticleConstraintUtil.Load(memory, xyz, lane))); + } + } + return changed; + } +} + +public sealed class C_OP_BoxConstraint : ParticleOperatorInstance +{ + public Vector3 Min; + public Vector3 Max; + + public static readonly ParticleOperatorDefinition Definition = new("Constrain particles to a box", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("min coords", "0 0 0", (o, v) => o.Min = v) + .Vector3("max coords", "0 0 0", (o, v) => o.Max = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override bool EnforceConstraint(int startBlock, int numBlocks, ParticleCollection particles, Span context, int activeParticles) { + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int stride) + stride * startBlock; + bool changed = false; + for (int block = 0; block < numBlocks; block++, xyz += stride) { + for (int lane = 0; lane < 4; lane++) { + for (int axis = 0; axis < 3; axis++) { + ref float value = ref memory[xyz + axis * 4 + lane]; + float clamped = ParticleConstraintUtil.MinPs(ParticleConstraintUtil.MaxPs(value, Min[axis]), Max[axis]); + if (clamped != value) + changed = true; + value = clamped; + } + } + } + return changed; + } +} diff --git a/Source.Particles/BuiltinParticleEmitters.cs b/Source.Particles/BuiltinParticleEmitters.cs new file mode 100644 index 00000000..bc841a9a --- /dev/null +++ b/Source.Particles/BuiltinParticleEmitters.cs @@ -0,0 +1,582 @@ +using Source.Common; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleEmitters +{ + public static bool g_bDontMakeSkipToTimeTakeForever = false; + + public static void AddBuiltInParticleEmitters(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.Emitter, C_OP_InstantaneousEmitter.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Emitter, C_OP_ContinuousEmitter.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Emitter, C_OP_NoiseEmitter.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Emitter, C_OP_MaintainEmitter.Definition); + } + + internal static void StampNewParticles(ParticleCollection particles, int count, float startTime, float step, float endTime) { + int startParticle = particles.ActiveParticles; + particles.SetNActiveParticles(startParticle + count); + float timeStamp = startTime; + for (int i = startParticle; i < startParticle + count; i++) { + if (step != 0.0f) { + timeStamp += step; + if (timeStamp >= endTime) + timeStamp = endTime; + } + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_CREATION_TIME, i) = timeStamp; + } + } + + internal static int ClampScaleControlPoint(int controlPoint) => controlPoint < -1 ? -1 : Math.Min(controlPoint, MAX_PARTICLE_CONTROL_POINTS - 1); + + internal static float GetScaleAtStartTime(ParticleCollection particles, int controlPoint, int field, float startTime) { + Vector3 scale; + if (particles.CurTime < startTime || startTime < particles.CurTime - particles.PreviousDt) + particles.GetControlPointAtPrevTime(controlPoint, out scale); + else + particles.GetControlPointAtTime(controlPoint, startTime, out scale); + return scale[field]; + } + + internal static float GetPositiveScaleAtCurrentTime(ParticleCollection particles, int controlPoint, int field) { + particles.GetControlPointAtTime(controlPoint, particles.CurTime, out Vector3 value); + float scale = value[field]; + if (scale <= 0.0f) + scale = 0.0f; + return scale; + } + + internal static uint EmitBetween(ParticleCollection particles, ref float emissionCounter, ref int emittedSoFar, float rate, float startTime, float duration, bool requirePositive) { + float currDrawTime = particles.CurTime; + float prevDrawTime = currDrawTime - particles.Dt; + if (duration != 0.0f) { + if (prevDrawTime <= startTime) + prevDrawTime = startTime; + if (duration + startTime <= currDrawTime) + currDrawTime = duration + startTime; + } + + emissionCounter = (currDrawTime - prevDrawTime) * rate + emissionCounter; + int toEmit = (int)(Math.Floor((double)emissionCounter) - emittedSoFar); + emittedSoFar += toEmit; + if (toEmit == 0) + return 0; + + int actual = Math.Min(toEmit, particles.MaxAllowedParticles - particles.ActiveParticles); + if (requirePositive ? actual <= 0 : actual == 0) + return 0; + + StampNewParticles(particles, actual, prevDrawTime, (currDrawTime - prevDrawTime) / actual, currDrawTime); + return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + } +} + +public sealed class C_OP_InstantaneousEmitter : ParticleOperatorInstance +{ + struct Context + { + public int ActualParticlesToEmit; + public int ParticlesToEmit; + public bool Scaled; + public float TimeOffset; + public float StartTime; + public bool Active; + } + + public int ParticlesToEmit; + public int MinParticlesToEmit; + public float StartTime; + public float StartTimeMax; + public int PerFrameNum; + public int ScaleControlPoint; + public int ScaleControlPointField; + + public static readonly ParticleOperatorDefinition Definition = new("emit_instantaneously", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emission_start_time", "0", (o, v) => o.StartTime = v) + .Float("emission_start_time max", "-1", (o, v) => o.StartTimeMax = v) + .Int("num_to_emit_minimum", "-1", (o, v) => o.MinParticlesToEmit = v) + .Int("num_to_emit", "100", (o, v) => o.ParticlesToEmit = v) + .Int("maximum emission per frame", "-1", (o, v) => o.PerFrameNum = v) + .Int("emission count scale control point", "-1", (o, v) => o.ScaleControlPoint = v) + .Int("emission count scale control point field", "0", (o, v) => o.ScaleControlPointField = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ScaleControlPoint < 0 ? 0 : 1UL << (ScaleControlPoint & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Datamodel.Element element) { + if (MinParticlesToEmit >= 0 && ParticlesToEmit < MinParticlesToEmit) + (ParticlesToEmit, MinParticlesToEmit) = (MinParticlesToEmit, ParticlesToEmit); + if (PerFrameNum < 0) + PerFrameNum = Math.Min(5000, def.MaxParticles); + ScaleControlPointField = Math.Clamp(ScaleControlPointField, 0, 2); + ScaleControlPoint = BuiltinParticleEmitters.ClampScaleControlPoint(ScaleControlPoint); + } + + float RandomStartTime(ParticleCollection particles) { + if (StartTimeMax > 0.0f) + return (StartTimeMax - StartTime) * particles.RandomFloat(0.0f, 1.0f) + StartTime; + return StartTime; + } + + void UpdateParticlesToEmit(ParticleCollection particles, ref Context ctx) { + int count = ctx.ParticlesToEmit; + if (ScaleControlPoint >= 0) + count = (int)(ctx.ParticlesToEmit * BuiltinParticleEmitters.GetScaleAtStartTime(particles, ScaleControlPoint, ScaleControlPointField, StartTime + ctx.TimeOffset)); + ctx.Scaled = true; + ctx.ActualParticlesToEmit = Math.Max(0, count); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + int toEmit = ParticlesToEmit; + if (MinParticlesToEmit >= 0) + toEmit = (int)((ParticlesToEmit - MinParticlesToEmit + 1) * particles.RandomFloat(0.0f, 1.0f)) + MinParticlesToEmit; + ctx.ParticlesToEmit = toEmit; + ctx.ActualParticlesToEmit = toEmit; + ctx.Scaled = false; + ctx.TimeOffset = 0.0f; + ctx.Active = true; + ctx.StartTime = RandomStartTime(particles); + } + + public override void StopEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (!infiniteOnly) + Ctx(context).Active = false; + } + + public override void StartEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (infiniteOnly) + return; + ref Context ctx = ref Ctx(context); + UpdateParticlesToEmit(particles, ref ctx); + SkipToTime(particles.CurTime, particles, context); + ctx.Active = true; + } + + public override void Restart(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + UpdateParticlesToEmit(particles, ref ctx); + ctx.TimeOffset = particles.CurTime; + ctx.Active = true; + ctx.StartTime = RandomStartTime(particles); + } + + public override void SkipToTime(float time, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + if (StartTime + ctx.TimeOffset + 2.0f < time) + ctx.Active = false; + } + + public override bool MayCreateMoreParticles(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + return ctx.Active && ctx.ActualParticlesToEmit >= 1; + } + + public override uint Emit(ParticleCollection particles, float opCurStrength, Span context) { + ref Context ctx = ref Ctx(context); + if (!ctx.Active) + return 0; + + float startTime = ctx.StartTime + ctx.TimeOffset; + if (!(startTime <= particles.CurTime)) + return 0; + + if (!ctx.Scaled) + UpdateParticlesToEmit(particles, ref ctx); + + int remaining = ctx.ActualParticlesToEmit; + if (remaining <= 0) + return 0; + + int particlesThisFrame = Math.Min(remaining, PerFrameNum); + ctx.ActualParticlesToEmit = remaining - particlesThisFrame; + int actual = Math.Min(particlesThisFrame, particles.MaxAllowedParticles - particles.ActiveParticles); + if (actual == 0) + return 0; + + BuiltinParticleEmitters.StampNewParticles(particles, actual, startTime, 0.0f, startTime); + return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + } +} + +public sealed class C_OP_ContinuousEmitter : ParticleOperatorInstance +{ + struct Context + { + public float ParticleEmissionCounter; + public int ActualParticlesToEmit; + public float NextEmitTime; + public float TimeOffset; + public bool Active; + } + + public float EmissionDuration; + public float StartTime; + public float EmitRate; + public float EmissionScale; + public bool ScalePerParticle; + public int ScaleControlPoint; + public int ScaleControlPointField; + + public static readonly ParticleOperatorDefinition Definition = new("emit_continuously", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("emission_start_time", "0", (o, v) => o.StartTime = v) + .Float("emission_rate", "100", (o, v) => o.EmitRate = v) + .Float("emission_duration", "0", (o, v) => o.EmissionDuration = v) + .Float("scale emission to used control points", "0.0", (o, v) => o.EmissionScale = v) + .Bool("use parent particles for emission scaling", "0", (o, v) => o.ScalePerParticle = v) + .Int("emission count scale control point", "-1", (o, v) => o.ScaleControlPoint = v) + .Int("emission count scale control point field", "0", (o, v) => o.ScaleControlPointField = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ScaleControlPoint < 0 ? 0 : 1UL << (ScaleControlPoint & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Datamodel.Element element) { + float rate = EmitRate; + if (rate < 0.0f) + rate = 0.0f; + if (EmissionDuration < 0.0f) + EmissionDuration = 0.0f; + EmitRate = ParticleSystemMgr.g_nParticle_Multiplier * rate; + ScaleControlPointField = Math.Clamp(ScaleControlPointField, 0, 2); + ScaleControlPoint = BuiltinParticleEmitters.ClampScaleControlPoint(ScaleControlPoint); + } + + public override void StopEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (!infiniteOnly || EmissionDuration == 0.0f) + Ctx(context).Active = false; + } + + public override void StartEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (infiniteOnly && EmissionDuration != 0.0f) + return; + Ctx(context).Active = true; + SkipToTime(particles.CurTime, particles, context); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.ParticleEmissionCounter = 0.0f; + ctx.ActualParticlesToEmit = 0; + ctx.NextEmitTime = StartTime; + ctx.TimeOffset = 0.0f; + ctx.Active = true; + } + + public override void Restart(ParticleCollection particles, Span context) { + if (EmissionDuration == 0.0f) + return; + ref Context ctx = ref Ctx(context); + ctx.ParticleEmissionCounter = 0.0f; + ctx.ActualParticlesToEmit = 0; + ctx.NextEmitTime = StartTime + particles.CurTime; + ctx.TimeOffset = particles.CurTime; + } + + public override bool MayCreateMoreParticles(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + if (!ctx.Active || !(EmitRate > 0.0f)) + return false; + return EmissionDuration == 0.0f || particles.CurTime - particles.Dt <= StartTime + ctx.TimeOffset + EmissionDuration; + } + + public override void SkipToTime(float time, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + float startTime = StartTime + ctx.TimeOffset; + if (time <= startTime) + return; + + float emissionRate = EmitRate; + float controlPointScale = particles.GetHighestControlPoint() * EmissionScale; + if (particles.CheckIfOperatorShouldRun(this, out float strength)) + emissionRate *= strength; + if (ScaleControlPoint >= 0) + emissionRate *= BuiltinParticleEmitters.GetPositiveScaleAtCurrentTime(particles, ScaleControlPoint, ScaleControlPointField); + if (controlPointScale != 0.0f) + emissionRate *= controlPointScale; + + float currDrawTime = particles.CurTime; + float prevDrawTime = currDrawTime - time; + if (EmissionDuration != 0.0f && prevDrawTime <= startTime) + prevDrawTime = startTime; + + float deltaTime = currDrawTime - prevDrawTime; + if (deltaTime >= 4.0f) + deltaTime = 4.0f; + + ctx.ActualParticlesToEmit = 0; + float toEmit = deltaTime * emissionRate; + prevDrawTime = currDrawTime - deltaTime; + ctx.ParticleEmissionCounter = toEmit; + + int actual = (int)Math.Floor((double)toEmit); + int startParticle = particles.ActiveParticles; + if (actual + startParticle > particles.MaxAllowedParticles) + actual = particles.MaxAllowedParticles - startParticle; + + BuiltinParticleEmitters.StampNewParticles(particles, actual, prevDrawTime, deltaTime / actual, currDrawTime); + + if (BuiltinParticleEmitters.g_bDontMakeSkipToTimeTakeForever) + return; + + float t = Math.Max(currDrawTime - particles.Def!.NoDrawTimeToGoToSleep, prevDrawTime); + particles.CurTime = t; + for (; t < currDrawTime; t += 0.1f) + particles.Simulate(0.1f, false); + } + + public override uint Emit(ParticleCollection particles, float opCurStrength, Span context) { + ref Context ctx = ref Ctx(context); + float startTime = StartTime + ctx.TimeOffset; + if (particles.CurTime < startTime) + return 0; + + float emissionRate = opCurStrength * EmitRate; + float controlPointScale = particles.GetHighestControlPoint() * EmissionScale; + if (ScaleControlPoint >= 0) + emissionRate *= BuiltinParticleEmitters.GetPositiveScaleAtCurrentTime(particles, ScaleControlPoint, ScaleControlPointField); + + if (ScalePerParticle) { + controlPointScale = particles.Parent != null ? particles.Parent.ActiveParticles * EmissionScale : EmissionScale; + emissionRate *= controlPointScale; + } + else if (controlPointScale != 0.0f) + emissionRate *= controlPointScale; + + if (emissionRate == 0.0f || !ctx.Active || !(EmitRate > 0.0f)) + return 0; + if (EmissionDuration != 0.0f && !(particles.CurTime - particles.Dt <= startTime + EmissionDuration)) + return 0; + + return BuiltinParticleEmitters.EmitBetween(particles, ref ctx.ParticleEmissionCounter, ref ctx.ActualParticlesToEmit, emissionRate, startTime, EmissionDuration, false); + } +} + +public sealed class C_OP_NoiseEmitter : ParticleOperatorInstance +{ + struct Context + { + public float ParticleEmissionCounter; + public int ActualParticlesToEmit; + public float NextEmitTime; + public float TimeOffset; + public bool Active; + } + + public float EmissionDuration; + public float StartTime; + public float EmissionScale; + public bool AbsVal; + public bool AbsValInv; + public float TimeOffset; + public float OutputMin; + public float OutputMax; + public float NoiseScale; + public float WorldNoiseScale; + + public static readonly ParticleOperatorDefinition Definition = new("emit noise", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("emission_start_time", "0", (o, v) => o.StartTime = v) + .Float("emission_duration", "0", (o, v) => o.EmissionDuration = v) + .Float("scale emission to used control points", "0.0", (o, v) => o.EmissionScale = v) + .Float("time noise coordinate scale", "0.1", (o, v) => o.NoiseScale = v) + .Float("time coordinate offset", "0", (o, v) => o.TimeOffset = v) + .Bool("absolute value", "0", (o, v) => o.AbsVal = v) + .Bool("invert absolute value", "0", (o, v) => o.AbsValInv = v) + .Float("emission minimum", "0", (o, v) => o.OutputMin = v) + .Float("emission maximum", "100", (o, v) => o.OutputMax = v) + .Float("world time noise coordinate scale", "0", (o, v) => o.WorldNoiseScale = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Datamodel.Element element) { + if (EmissionDuration < 0.0f) + EmissionDuration = 0.0f; + } + + public override void StopEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (!infiniteOnly || EmissionDuration == 0.0f) + Ctx(context).Active = false; + } + + public override void StartEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { + if (infiniteOnly && EmissionDuration != 0.0f) + return; + Ctx(context).Active = true; + SkipToTime(particles.CurTime, particles, context); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.ParticleEmissionCounter = 1.0f; + ctx.ActualParticlesToEmit = 0; + ctx.NextEmitTime = StartTime; + ctx.TimeOffset = 0.0f; + ctx.Active = true; + } + + public override void Restart(ParticleCollection particles, Span context) { + if (EmissionDuration == 0.0f) + return; + ref Context ctx = ref Ctx(context); + ctx.ParticleEmissionCounter = 1.0f; + ctx.ActualParticlesToEmit = 0; + ctx.NextEmitTime = StartTime + particles.CurTime; + ctx.TimeOffset = particles.CurTime; + } + + public override bool MayCreateMoreParticles(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + if (!ctx.Active) + return false; + return EmissionDuration == 0.0f || particles.CurTime - particles.Dt <= StartTime + ctx.TimeOffset + EmissionDuration; + } + + public override void SkipToTime(float time, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + if (!(StartTime + ctx.TimeOffset < time)) + return; + particles.CheckIfOperatorShouldRun(this, out _); + ctx.ParticleEmissionCounter = 1.0f; + ctx.ActualParticlesToEmit = 0; + } + + public override uint Emit(ParticleCollection particles, float opCurStrength, Span context) { + ref Context ctx = ref Ctx(context); + float controlPointScale = particles.GetHighestControlPoint() * EmissionScale; + float absScale = AbsVal ? 1.0f : 0.5f; + + float coord = (float)(uint)Platform.MSTime * WorldNoiseScale + (TimeOffset + particles.CurTime) * NoiseScale; + float noise = NoiseSIMD.Noise(coord, coord, coord); + if (AbsVal) + noise = MathF.Abs(noise); + if (AbsValInv) + noise = 1.0f - noise; + + float range = OutputMax - OutputMin; + float emissionRate = range * absScale * noise + (1.0f - absScale) * range + OutputMin; + if (emissionRate <= 0.0f) + emissionRate = 0.0f; + if (2.1474836e+09f <= emissionRate) + emissionRate = 2.1474836e+09f; + emissionRate *= opCurStrength; + if (controlPointScale != 0.0f) + emissionRate *= controlPointScale; + + if (emissionRate == 0.0f || !ctx.Active) + return 0; + float startTime = StartTime + ctx.TimeOffset; + if (EmissionDuration != 0.0f && !(particles.CurTime - particles.Dt <= startTime + EmissionDuration)) + return 0; + if (!(startTime <= particles.CurTime)) + return 0; + + return BuiltinParticleEmitters.EmitBetween(particles, ref ctx.ParticleEmissionCounter, ref ctx.ActualParticlesToEmit, emissionRate, startTime, EmissionDuration, true); + } +} + +public sealed class C_OP_MaintainEmitter : ParticleOperatorInstance +{ + struct Context + { + public int ActualParticlesToMaintain; + public float TimeOffset; + public bool Active; + } + + public int ParticlesToMaintain; + public float StartTime; + public int ScaleControlPoint; + public int ScaleControlPointField; + + public static readonly ParticleOperatorDefinition Definition = new("emit to maintain count", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emission start time", "0", (o, v) => o.StartTime = v) + .Int("count to maintain", "100", (o, v) => o.ParticlesToMaintain = v) + .Int("maintain count scale control point", "-1", (o, v) => o.ScaleControlPoint = v) + .Int("maintain count scale control point field", "0", (o, v) => o.ScaleControlPointField = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ScaleControlPoint < 0 ? 0 : 1UL << (ScaleControlPoint & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Datamodel.Element element) { + ScaleControlPointField = Math.Clamp(ScaleControlPointField, 0, 2); + ScaleControlPoint = BuiltinParticleEmitters.ClampScaleControlPoint(ScaleControlPoint); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.ActualParticlesToMaintain = ParticlesToMaintain; + ctx.TimeOffset = 0.0f; + ctx.Active = true; + } + + public override void StopEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) => Ctx(context).Active = false; + public override void StartEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) => Ctx(context).Active = true; + + public override void Restart(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.TimeOffset = particles.CurTime; + ctx.Active = true; + } + + public override bool MayCreateMoreParticles(ParticleCollection particles, Span context) => Ctx(context).Active; + + public override uint Emit(ParticleCollection particles, float opCurStrength, Span context) { + ref Context ctx = ref Ctx(context); + if (!ctx.Active) + return 0; + + float startTime = ctx.TimeOffset + StartTime; + if (!(startTime <= particles.CurTime)) + return 0; + + int count = ParticlesToMaintain; + if (ScaleControlPoint >= 0) + count = (int)(ParticlesToMaintain * BuiltinParticleEmitters.GetScaleAtStartTime(particles, ScaleControlPoint, ScaleControlPointField, startTime)); + count = Math.Max(0, count); + ctx.ActualParticlesToMaintain = count; + + int startParticle = particles.ActiveParticles; + if (startParticle >= count || count <= 0) + return 0; + + int actual = Math.Min(particles.MaxAllowedParticles - startParticle, count - startParticle); + if (actual < 0) + return 0; + + particles.SetNActiveParticles(startParticle + actual); + float emitTime = Math.Max(particles.PrevSimTime, startTime); + float step = (particles.CurTime - emitTime) / actual; + for (int i = startParticle; i < startParticle + actual; i++) { + emitTime = Math.Min(emitTime, particles.CurTime); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_CREATION_TIME, i) = emitTime; + emitTime += step; + } + return PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + } +} diff --git a/Source.Particles/BuiltinParticleForces.cs b/Source.Particles/BuiltinParticleForces.cs new file mode 100644 index 00000000..5ce2197e --- /dev/null +++ b/Source.Particles/BuiltinParticleForces.cs @@ -0,0 +1,282 @@ +using Datamodel; + +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleForces +{ + public static void AddBuiltInParticleForceGenerators(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_RandomForce.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_TwistAroundAxis.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_ParentVortices.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_AttractToControlPoint.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_TimeVaryingForce.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_TurbulenceForce.Definition); + mgr.AddParticleOperator(ParticleFunctionType.ForceGenerator, C_OP_ForceBasedOnDistanceToPlane.Definition); + } +} + +internal static class ParticleForceUtil +{ + public const float FLT_EPSILON = 1.1920929e-07f; + + public static void Add(Span forces, int p, in Vector3 force) { + ref FourVectors block = ref forces[p >> 2]; + int lane = p & 3; + Unsafe.Add(ref block.x.X, lane) += force.X; + Unsafe.Add(ref block.y.X, lane) += force.Y; + Unsafe.Add(ref block.z.X, lane) += force.Z; + } + + public static Vector3 Position(ParticleCollection particles, int p) => particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + + public static Vector3 RSqrtNormalize(Vector3 v) => v * (1.0f / MathF.Sqrt(v.LengthSquared())); + + public static Vector3 TangentialForce(Vector3 ofs, in Vector3 axis, float scale) { + float distSq = ofs.LengthSquared(); + ofs = RSqrtNormalize(ofs); + ofs -= ofs * Vector3.Dot(ofs, axis); + if (!(distSq > FLT_EPSILON && ofs.LengthSquared() > FLT_EPSILON)) + return Vector3.Zero; + return Vector3.Cross(RSqrtNormalize(ofs), axis) * scale; + } + + public static float PowFixedPoint(float x, int exponent) => RandSIMD.PowFixedPointExponent(Vector128.Create(x), exponent)[0]; +} + +public sealed class C_OP_RandomForce : ParticleOperatorInstance +{ + public Vector3 MinForce; + public Vector3 MaxForce; + + public static readonly ParticleOperatorDefinition Definition = new("random force", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("min force", "0 0 0", (o, v) => o.MinForce = v) + .Vector3("max force", "0 0 0", (o, v) => o.MaxForce = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + Vector4 minX = new(MinForce.X * strength), minY = new(MinForce.Y * strength), minZ = new(MinForce.Z * strength); + Vector4 rangeX = new Vector4(MaxForce.X * strength) - minX, rangeY = new Vector4(MaxForce.Y * strength) - minY, rangeZ = new Vector4(MaxForce.Z * strength) - minZ; + int ctx = RandSIMD.GetContext(); + for (int i = 0; i < blocks; i++) { + ref FourVectors force = ref accumulatedForces[i]; + force.x += rangeX * RandSIMD.Next(ctx).AsVector4() + minX; + force.y += rangeY * RandSIMD.Next(ctx).AsVector4() + minY; + force.z += rangeZ * RandSIMD.Next(ctx).AsVector4() + minZ; + } + RandSIMD.ReleaseContext(ctx); + } +} + +public sealed class C_OP_TwistAroundAxis : ParticleOperatorInstance +{ + public float ForceAmount; + public Vector3 TwistAxis; + public bool LocalSpace; + + public static readonly ParticleOperatorDefinition Definition = new("twist around axis", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("amount of force", "0", (o, v) => o.ForceAmount = v) + .Vector3("twist axis", "0 0 1", (o, v) => o.TwistAxis = v) + .Bool("object local space axis 0/1", "0", (o, v) => o.LocalSpace = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + Vector3 axis = ParticleForceUtil.RSqrtNormalize(particles.TransformAxis(TwistAxis, LocalSpace)); + Vector3 center = particles.GetControlPointAtCurrentTime(0); + float scale = ForceAmount * strength; + for (int p = 0; p < blocks * 4; p++) + ParticleForceUtil.Add(accumulatedForces, p, ParticleForceUtil.TangentialForce(ParticleForceUtil.Position(particles, p) - center, axis, scale)); + } +} + +public sealed class C_OP_ParentVortices : ParticleOperatorInstance +{ + public float ForceScale; + public Vector3 TwistAxis; + public bool FlipBasedOnYaw; + + public static readonly ParticleOperatorDefinition Definition = new("Create vortices from parent particles", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("amount of force", "0", (o, v) => o.ForceScale = v) + .Vector3("twist axis", "0 0 1", (o, v) => o.TwistAxis = v) + .Bool("flip twist axis with yaw", "0", (o, v) => o.FlipBasedOnYaw = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + ParticleCollection? parent = particles.Parent; + if (parent == null || parent.ActiveParticles == 0) + return; + + Vector3 axis = ParticleForceUtil.RSqrtNormalize(TwistAxis); + int vortexCount = parent.ActiveParticles; + Span centers = vortexCount <= 256 ? stackalloc Vector3[vortexCount] : new Vector3[vortexCount]; + Span ooRadiusSq = vortexCount <= 256 ? stackalloc float[vortexCount] : new float[vortexCount]; + Span strengths = vortexCount <= 256 ? stackalloc float[vortexCount] : new float[vortexCount]; + for (int i = 0; i < vortexCount; i++) { + float ooRadius = 1.0f / (parent.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, i) + 1e-05f); + ooRadiusSq[i] = ooRadius * ooRadius; + strengths[i] = strength * ForceScale * parent.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, i); + centers[i] = parent.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, i); + if (FlipBasedOnYaw && parent.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_YAW, i) >= MathF.PI) + centers[i] *= -1.0f; + } + + for (int p = 0; p < blocks * 4; p++) { + Vector3 pos = ParticleForceUtil.Position(particles, p); + Vector3 sum = Vector3.Zero; + for (int v = 0; v < vortexCount; v++) { + Vector3 ofs = pos - centers[v]; + float falloff = MathF.Max(0.0f, 1.0f - ofs.LengthSquared() * ooRadiusSq[v]); + sum += ParticleForceUtil.TangentialForce(ofs, axis, strengths[v] * falloff); + } + ParticleForceUtil.Add(accumulatedForces, p, sum); + } + } +} + +public sealed class C_OP_AttractToControlPoint : ParticleOperatorInstance +{ + public float ForceAmount; + public float FalloffPower; + public int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Pull towards control point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("amount of force", "0", (o, v) => o.ForceAmount = v) + .Float("falloff power", "2", (o, v) => o.FalloffPower = v) + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 0x3f); + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + if ((uint)ControlPointNumber >= MAX_PARTICLE_CONTROL_POINTS) + return; + int powerFrac = (int)(FalloffPower * -4.0f); + float forceScale = -(ForceAmount * strength); + Vector3 center = particles.GetControlPointAtCurrentTime(ControlPointNumber); + for (int p = 0; p < blocks * 4; p++) { + Vector3 ofs = ParticleForceUtil.Position(particles, p) - center; + float len = ofs.Length(); + if (!(len > ParticleForceUtil.FLT_EPSILON)) + continue; + ofs *= forceScale / len; + ofs *= ParticleForceUtil.PowFixedPoint(len, powerFrac); + ParticleForceUtil.Add(accumulatedForces, p, ofs); + } + } +} + +public sealed class C_OP_TimeVaryingForce : ParticleOperatorInstance +{ + public float StartLerpTime; + public Vector3 StartingForce; + public float EndLerpTime; + public Vector3 EndingForce; + + public static readonly ParticleOperatorDefinition Definition = new("time varying force", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("time to start transition", "0", (o, v) => o.StartLerpTime = v) + .Vector3("starting force", "0 0 0", (o, v) => o.StartingForce = v) + .Float("time to end transition", "10", (o, v) => o.EndLerpTime = v) + .Vector3("ending force", "0 0 0", (o, v) => o.EndingForce = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + Vector3 start = StartingForce * strength; + Vector3 delta = EndingForce * strength - start; + float ooRange = 1.0f / (EndLerpTime - StartLerpTime); + for (int p = 0; p < blocks * 4; p++) { + float age = particles.CurTime - particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float t = MathF.Max(0.0f, MathF.Min(1.0f, (age - StartLerpTime) * ooRange)); + ParticleForceUtil.Add(accumulatedForces, p, delta * t + start); + } + } +} + +public sealed class C_OP_TurbulenceForce : ParticleOperatorInstance +{ + public readonly float[] NoiseCoordScale = new float[4]; + public readonly Vector3[] NoiseAmount = new Vector3[4]; + + public static readonly ParticleOperatorDefinition Definition = new("turbulent force", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Noise scale 0", "1", (o, v) => o.NoiseCoordScale[0] = v) + .Vector3("Noise amount 0", "1 1 1", (o, v) => o.NoiseAmount[0] = v) + .Float("Noise scale 1", "0", (o, v) => o.NoiseCoordScale[1] = v) + .Vector3("Noise amount 1", ".5 .5 .5", (o, v) => o.NoiseAmount[1] = v) + .Float("Noise scale 2", "0", (o, v) => o.NoiseCoordScale[2] = v) + .Vector3("Noise amount 2", ".25 .25 .25", (o, v) => o.NoiseAmount[2] = v) + .Float("Noise scale 3", "0", (o, v) => o.NoiseCoordScale[3] = v) + .Vector3("Noise amount 3", ".125 .125 .125", (o, v) => o.NoiseAmount[3] = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + for (int p = 0; p < blocks * 4; p++) { + Vector3 pos = ParticleForceUtil.Position(particles, p); + Vector3 sum = Vector3.Zero; + for (int i = 0; i < 4; i++) + sum += NoiseSIMD.DNoise(pos * NoiseCoordScale[i]) * NoiseAmount[i]; + ParticleForceUtil.Add(accumulatedForces, p, sum); + } + } +} + +public sealed class C_OP_ForceBasedOnDistanceToPlane : ParticleOperatorInstance +{ + public float MinDist; + public Vector3 ForceAtMinDist; + public float MaxDist; + public Vector3 ForceAtMaxDist; + public Vector3 PlaneNormal; + public int ControlPointNumber; + public float Exponent; + + public static readonly ParticleOperatorDefinition Definition = new("Force based on distance from plane", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Min distance from plane", "0", (o, v) => o.MinDist = v) + .Vector3("Force at Min distance", "0 0 0", (o, v) => o.ForceAtMinDist = v) + .Float("Max Distance from plane", "1", (o, v) => o.MaxDist = v) + .Vector3("Force at Max distance", "0 0 0", (o, v) => o.ForceAtMaxDist = v) + .Vector3("Plane Normal", "0 0 1", (o, v) => o.PlaneNormal = v) + .Int("Control point number", "0", (o, v) => o.ControlPointNumber = v) + .Float("Exponent", "1", (o, v) => o.Exponent = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 0x3f); + + public override void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { + float deltaDistances = MaxDist - MinDist; + float ooRange = deltaDistances != 0.0f ? 1.0f / deltaDistances : 0.0f; + int cp = (uint)ControlPointNumber >= MAX_PARTICLE_CONTROL_POINTS ? 0 : ControlPointNumber; + Vector3 pointOnPlane = particles.GetControlPointAtCurrentTime(cp); + Vector3 forceDelta = ForceAtMaxDist - ForceAtMinDist; + int powValue = (int)(Exponent * 4.0f); + for (int p = 0; p < blocks * 4; p++) { + float dist = (Vector3.Dot(ParticleForceUtil.Position(particles, p) - pointOnPlane, PlaneNormal) - MinDist) * ooRange; + dist = MathF.Max(0.0f, MathF.Min(1.0f, dist)); + ParticleForceUtil.Add(accumulatedForces, p, forceDelta * ParticleForceUtil.PowFixedPoint(dist, powValue) + ForceAtMinDist); + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Collision.cs b/Source.Particles/BuiltinParticleInitializers.Collision.cs new file mode 100644 index 00000000..54eba510 --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Collision.cs @@ -0,0 +1,281 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; + +using static Source.Particles.ParticleConstants; + +using QAngle = Source.Common.Mathematics.QAngle; + +namespace Source.Particles; + +internal static class ParticleCollisionCache +{ + public static ref WorldCollideContextData Get(ParticleCollection owner) { + owner.CollisionCache ??= new StrongBox(default); + return ref owner.CollisionCache.Value; + } + + public static bool IsInvalid(in Vector3 v) => v == ParticleInitUtil.Vec3Invalid; +} + +public sealed class C_INIT_LifespanFromVelocity : ParticleOperatorInstance +{ + public Vector3 ComponentScale; + public float TraceOffset; + public float MaxTraceLength; + public float TraceTolerance; + public int MaxPlanes; + public string CollisionGroupName = "NONE"; + public bool IncludeWater; + int CollisionGroupNumber; + int AllowedPlanes; + Mask CollisionMask; + + public static readonly ParticleOperatorDefinition Definition = new("Lifetime from Time to Impact", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .String("trace collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Float("maximum trace length", "1024", (o, v) => o.MaxTraceLength = v) + .Float("trace offset", "0", (o, v) => o.TraceOffset = v) + .Float("trace recycle tolerance", "64", (o, v) => o.TraceTolerance = v) + .Int("maximum points to cache", "16", (o, v) => o.MaxPlanes = v) + .Vector3("bias distance", "1 1 1", (o, v) => o.ComponentScale = v) + .Bool("collide with water", "1", (o, v) => o.IncludeWater = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override int GetRequiredContextBytes() => 0x1f10; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + AllowedPlanes = Math.Min(WorldCollideContextData.MAX_PLANES, MaxPlanes) - 1; + CollisionMask = (Mask)(IncludeWater ? 0x600403b : 0x600400b); + } + + Vector3 TraceAndCache(ParticleCollection particles, ref WorldCollideContextData cache, in Vector3 start, in Vector3 end, float totalTraceDist) { + GameTrace tr = default; + particles.Mgr!.Query().TraceLine(start, end, CollisionMask, null, CollisionGroupNumber, ref tr); + + Vector3 normal = tr.Plane.Normal; + Vector3 pointOnPlane = tr.EndPos; + if (tr.Fraction == 1.0f) + normal = ParticleInitUtil.Vec3Invalid; + if (tr.Fraction <= 1.0f - MaxTraceLength / (totalTraceDist + MathLibConsts.FLT_EPSILON) || tr.StartSolid || totalTraceDist == 0.0f || tr.AllSolid) { + pointOnPlane = ParticleInitUtil.Vec3Invalid; + normal = ParticleInitUtil.Vec3Invalid; + } + + int index = cache.NumFixedPlanes; + cache.PlaneActive[index] = true; + cache.PointOnPlane[index] = pointOnPlane; + cache.PlaneNormal[index] = normal; + cache.TraceStartPnt[index] = start; + cache.TraceEndPnt[index] = end; + + cache.NumFixedPlanes++; + if (cache.NumFixedPlanes > AllowedPlanes) + cache.NumFixedPlanes = 0; + cache.ActivePlanes = Math.Min(AllowedPlanes, cache.ActivePlanes + 1); + return pointOnPlane; + } + + static float DistSqr(in Vector3 a, in Vector3 b) { + Vector3 d = a - b; + return d.Z * d.Z + d.Y * d.Y + d.X * d.X; + } + + float TrialDistance(in WorldCollideContextData cache, int i, in Vector3 start, in Vector3 end) + => MathF.Max(DistSqr(cache.TraceStartPnt[i], start), DistSqr(cache.TraceEndPnt[i], end)); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref WorldCollideContextData cache = ref ParticleCollisionCache.Get(particles.Parent ?? particles); + float tolerance = TraceTolerance * TraceTolerance; + float totalTraceDist = MaxTraceLength - TraceOffset; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + ref float life = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + if (!(life >= 0.0f)) + continue; + + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + float invDt = 1.0f / particles.PreviousDt; + Vector3 delta = new((xyz.X - prev.X) * invDt, (xyz.Y - prev.Y) * invDt, (xyz.Z - prev.Z) * invDt); + float velocity = MathF.Sqrt(delta.Y * delta.Y + delta.X * delta.X + delta.Z * delta.Z); + MathLib.VectorNormalize(ref delta); + + Vector3 start = delta * TraceOffset + xyz; + Vector3 end = delta * totalTraceDist + start; + + float closest = float.MaxValue; + Vector3 pointOnPlane = Vector3.Zero; + for (int i = 0; i < cache.ActivePlanes; i++) { + if (!cache.PlaneActive[i]) + continue; + float trial = TrialDistance(cache, i, start, end); + if (trial <= closest) { + closest = trial; + pointOnPlane = cache.PointOnPlane[i]; + } + } + + if (!(closest <= tolerance)) + pointOnPlane = TraceAndCache(particles, ref cache, start, end, totalTraceDist); + + if (ParticleCollisionCache.IsInvalid(pointOnPlane)) { + life = -1.0f; + continue; + } + + Vector3 d = (start - pointOnPlane) * ComponentScale; + life = (MathF.Sqrt(d.Y * d.Y + d.X * d.X + d.Z * d.Z) + TraceOffset) / (velocity + MathLibConsts.FLT_EPSILON); + } + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) { + ref WorldCollideContextData cache = ref ParticleCollisionCache.Get(particles.Parent ?? particles); + float tolerance = TraceTolerance * TraceTolerance; + float totalTraceDist = MaxTraceLength - TraceOffset; + + float dt = particles.PreviousDt; + float rcp = MathF.ReciprocalEstimate(dt); + rcp = rcp + rcp - rcp * rcp * dt; + + Span start = stackalloc Vector3[4]; + Span end = stackalloc Vector3[4]; + Span velocity = stackalloc float[4]; + Span closest = stackalloc float[4]; + Span pointOnPlane = stackalloc Vector3[4]; + + for (int block = startBlock; block < startBlock + numBlocks; block++) { + int first = block * 4; + bool any = false; + for (int lane = 0; lane < 4; lane++) + any |= particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, first + lane) >= 0.0f; + if (!any) + continue; + + for (int lane = 0; lane < 4; lane++) { + int p = first + lane; + float life = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + closest[lane] = life < 0.0f ? 0.0f : float.MaxValue; + + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 delta = new((xyz.X - prev.X) * rcp, (xyz.Y - prev.Y) * rcp, (xyz.Z - prev.Z) * rcp); + float lenSq = delta.Y * delta.Y + delta.X * delta.X + delta.Z * delta.Z; + velocity[lane] = MathF.Sqrt(lenSq); + float rsqrt = MathF.ReciprocalSqrtEstimate(lenSq); + Vector3 dir = new(delta.X * rsqrt, delta.Y * rsqrt, delta.Z * rsqrt); + start[lane] = dir * TraceOffset + xyz; + end[lane] = dir * totalTraceDist + start[lane]; + } + + for (int i = 0; i < cache.ActivePlanes; i++) { + if (!cache.PlaneActive[i]) + continue; + for (int lane = 0; lane < 4; lane++) { + float trial = TrialDistance(cache, i, start[lane], end[lane]); + if (trial <= closest[lane]) { + closest[lane] = trial; + pointOnPlane[lane] = cache.PointOnPlane[i]; + } + } + } + + for (int lane = 0; lane < 4; lane++) { + if (tolerance < closest[lane]) + pointOnPlane[lane] = TraceAndCache(particles, ref cache, start[lane], end[lane], totalTraceDist); + } + + for (int lane = 0; lane < 4; lane++) { + int p = first + lane; + ref float life = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + if (!(life >= 0.0f)) + continue; + + Vector3 point = pointOnPlane[lane]; + Vector3 invalid = ParticleInitUtil.Vec3Invalid; + if (point.X == invalid.X || point.Y == invalid.Y || point.Z == invalid.Z) { + life = 0.0f; + continue; + } + + Vector3 d = (start[lane] - point) * ComponentScale; + life = (MathF.Sqrt(d.Y * d.Y + d.X * d.X + d.Z * d.Z) + TraceOffset) / (velocity[lane] + MathLibConsts.FLT_EPSILON); + } + } + } +} + +public sealed class C_INIT_CreateFromPlaneCache : ParticleOperatorInstance +{ + public Vector3 OffsetMin; + public Vector3 OffsetMax; + public bool UseNormal; + bool LocalOffset; + + public static readonly ParticleOperatorDefinition Definition = new("Position from Parent Cache", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Vector3("Local Offset Min", "0 0 0", (o, v) => o.OffsetMin = v) + .Vector3("Local Offset Max", "0 0 0", (o, v) => o.OffsetMax = v) + .Bool("Set Normal", "0", (o, v) => o.UseNormal = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_NORMAL_MASK; + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => 0x1f10; + + public override void InitParams(ParticleSystemDefinition def, Element element) => LocalOffset = true; + + static void SetOrigin(ParticleCollection particles, int firstParticle, int numParticles) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, Vector3.Zero); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, Vector3.Zero); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ParticleCollection? parent = particles.Parent; + if (parent == null) { + SetOrigin(particles, firstParticle, numParticles); + return; + } + + if (parent.CollisionCache == null) + ParticleCollisionCache.Get(parent).PointOnPlane[0] = Vector3.Zero; + ref WorldCollideContextData cache = ref ParticleCollisionCache.Get(parent); + + if (cache.ActivePlanes < 1) { + SetOrigin(particles, firstParticle, numParticles); + return; + } + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + int index = (int)particles.RandomFloat(0.0f, cache.ActivePlanes); + Vector3 normal = cache.PlaneNormal[index]; + Vector3 point = cache.PointOnPlane[index]; + if (ParticleCollisionCache.IsInvalid(normal) || ParticleCollisionCache.IsInvalid(point)) { + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = 0.0f; + continue; + } + + if (LocalOffset) { + particles.RandomVector(OffsetMin, OffsetMax, out Vector3 randPos); + MathLib.VectorAngles(normal, out QAngle angles); + MathLib.AngleMatrix(angles, out Matrix3x4 rotation); + MathLib.VectorRotate(new Vector3(randPos.Z, randPos.Y, randPos.X), rotation, out Vector3 offset); + point += offset; + } + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, point); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, point); + if (UseNormal) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_NORMAL, p, normal); + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.ControlPoint.cs b/Source.Particles/BuiltinParticleInitializers.ControlPoint.cs new file mode 100644 index 00000000..2d9c5efb --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.ControlPoint.cs @@ -0,0 +1,223 @@ +using Datamodel; + +using Source.Common.Mathematics; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_INIT_SequenceFromCP : ParticleOperatorInstance +{ + public int ControlPoint; + public Vector3 Offset; + public bool RadiusScale; + public bool KillUnused; + + public static readonly ParticleOperatorDefinition Definition = new("Sequence From Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point", "1", (o, v) => o.ControlPoint = v) + .Vector3("per particle spatial offset", "0 0 0", (o, v) => o.Offset = v) + .Bool("offset propotional to radius", "0", (o, v) => o.RadiusScale = v)); + + public override uint GetWrittenAttributes() { + int ret = Offset != Vector3.Zero ? PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK : PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK; + return (uint)(KillUnused ? ret | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK : ret); + } + + public override uint GetReadAttributes() => Offset != Vector3.Zero ? (uint)(PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK) : 0; + public override ulong GetReadControlPointMask() => 1UL << (ControlPoint & 63); + public override bool InitMultipleOverride() => true; + + static int Digits(float value) => Math.Max(0, (int)Math.Log10(value * 10.0f)); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + Vector3 cp = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(ControlPoint)); + int component = 2; + int desiredCount = Math.Min(Digits(cp.X) + Digits(cp.Y) + Digits(cp.Z), numParticles) - 1; + Vector3 offsetPos = (float)desiredCount * Offset * 0.5f; + bool hasOffset = Offset != Vector3.Zero; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + while (component >= 0 && cp[component] < 1.0f) + component--; + + if (component < 0 || cp[component] <= 0.0f) { + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = -1.0f; + continue; + } + + float value = cp[component]; + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p) = (float)(value % 10.0 + component * 10); + cp[component] = MathF.Floor(value * 0.1f); + + if (hasOffset) { + float radius = RadiusScale ? particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p) : 1.0f; + Vector3 delta = offsetPos * radius; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + delta); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + delta); + offsetPos -= Offset; + } + } + } +} + +public sealed class C_INIT_NormalAlignToCP : ParticleOperatorInstance +{ + public int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Normal Align to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_NORMAL_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int cp = ParticleInitUtil.CheckControlPoint(ControlPointNumber); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + particles.GetControlPointOrientationAtTime(cp, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 forward, out _, out _); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_NORMAL, p, forward); + } + } +} + +public sealed class C_INIT_NormalOffset : ParticleOperatorInstance +{ + public int ControlPointNumber; + public Vector3 OffsetMin; + public Vector3 OffsetMax; + public bool LocalCoords; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Normal Modify Offset Random", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Vector3("offset min", "0 0 0", (o, v) => o.OffsetMin = v) + .Vector3("offset max", "0 0 0", (o, v) => o.OffsetMax = v) + .Bool("offset in local space 0/1", "0", (o, v) => o.LocalCoords = v) + .Bool("normalize output 0/1", "0", (o, v) => o.Normalize = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_NORMAL_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_NORMAL_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + public override bool InitMultipleOverride() => true; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + particles.RandomVector(OffsetMin, OffsetMax, out Vector3 randPos); + if (LocalCoords) { + particles.GetControlPointTransformAtTime(ParticleInitUtil.CheckControlPoint(ControlPointNumber), particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Matrix3x4 mat); + MathLib.VectorRotate(randPos, mat, out randPos); + } + + Vector3 normal = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_NORMAL, p) + randPos; + if (Normalize) + MathLib.VectorNormalize(ref normal); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_NORMAL, p, normal); + } + } +} + +public sealed class C_INIT_RemapInitialCPDirectionToRotation : ParticleOperatorInstance +{ + public int ControlPoint; + public int FieldOutput; + public int Axis; + public float OffsetRot; + int Component1; + int Component2; + + public static readonly ParticleOperatorDefinition Definition = new("Remap CP Orientation to Rotation", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point", "0", (o, v) => o.ControlPoint = v) + .Int("rotation field", "0", (o, v) => o.FieldOutput = v) + .Int("axis", "0", (o, v) => o.Axis = v) + .Float("offset rotation", "0", (o, v) => o.OffsetRot = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = Math.Clamp(FieldOutput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + if (Axis < 0) + (Component1, Component2) = (1, 0); + else if (Axis == 0) + (Component1, Component2) = (1, 0); + else if (Axis == 1) + (Component1, Component2) = (2, 0); + else { + Axis = 2; + (Component1, Component2) = (2, 1); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + particles.GetControlPointOrientationAtCurrentTime(ParticleInitUtil.CheckControlPoint(ControlPoint), out Vector3 forward, out Vector3 right, out Vector3 up); + Vector3 row = Axis switch { + 1 => right, + 2 => up, + _ => forward + }; + + float rotation = (float)(Math.Atan2(row[Component1], row[Component2]) + Math.PI) + OffsetRot * 0.017453292f; + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = rotation; + } +} + +public sealed class C_INIT_VelocityFromCP : ParticleOperatorInstance +{ + public int ControlPoint; + public float VelocityScale; + public int ControlPointCompare; + public int ControlPointLocal; + public bool DirectionOnly; + + public static readonly ParticleOperatorDefinition Definition = new("Velocity Set from Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPoint = v) + .Float("velocity scale", "1", (o, v) => o.VelocityScale = v) + .Int("comparison control point number", "-1", (o, v) => o.ControlPointCompare = v) + .Int("local space control point number", "-1", (o, v) => o.ControlPointLocal = v) + .Bool("direction only", "0", (o, v) => o.DirectionOnly = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override bool InitMultipleOverride() => true; + + public override ulong GetReadControlPointMask() { + ulong mask = 1UL << (ControlPoint & 63); + if (ControlPointCompare != -1) + mask |= 1UL << (ControlPointCompare & 63); + if (ControlPointLocal != -1) + mask |= 1UL << (ControlPointLocal & 63); + return mask; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + Vector3 delta; + if (ControlPointCompare < 0) + delta = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(ControlPoint)); + else { + int compare = ParticleInitUtil.CheckControlPoint(ControlPointCompare); + delta = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(ControlPoint)) - particles.GetControlPointAtCurrentTime(compare); + } + + if (ControlPointLocal > -1) { + particles.GetControlPointTransformAtCurrentTime(ParticleInitUtil.CheckControlPoint(ControlPointLocal), out Matrix3x4 mat); + MathLib.VectorRotate(delta, mat, out delta); + } + + if (DirectionOnly) + MathLib.VectorNormalize(ref delta); + + float dt = particles.PreviousDt; + float scale = VelocityScale; + Vector3 step = new(dt * delta.X * scale, dt * delta.Y * scale, dt * delta.Z * scale); + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) - step); + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Hitbox.cs b/Source.Particles/BuiltinParticleInitializers.Hitbox.cs new file mode 100644 index 00000000..c5f00c0a --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Hitbox.cs @@ -0,0 +1,138 @@ +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_INIT_SetHitboxToClosest : ParticleOperatorInstance +{ + const int MAX_POINTS_PER_BATCH = 100; + + public int ControlPointNumber; + public int DesiredHitbox; + public float HitBoxScale; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Set Hitbox to Closest Hitbox", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("model hitbox scale", "1.0", (o, v) => o.HitBoxScale = v) + .Int("desired hitbox", "-1", (o, v) => o.DesiredHitbox = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int controlPoint = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + particles.UpdateHitBoxInfo(controlPoint, HitboxSetName); + + Span points = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span relativeCoords = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span hitboxIndices = stackalloc int[MAX_POINTS_PER_BATCH]; + int particle = firstParticle; + while (numParticles > 0) { + int count = Math.Min(numParticles, MAX_POINTS_PER_BATCH); + for (int i = 0; i < count; i++) + points[i] = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle + i); + + particles.Mgr!.Query().GetClosestControllingObjectHitBox(particles, controlPoint, count, HitBoxScale, points, relativeCoords, hitboxIndices, DesiredHitbox, HitboxSetName); + + for (int i = 0; i < count; i++, particle++) { + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, particle, relativeCoords[i]); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK) != 0) + particles.GetIntAttributeRefForWrite(PARTICLE_ATTRIBUTE_HITBOX_INDEX, particle) = hitboxIndices[i]; + } + numParticles -= count; + } + } +} + +public sealed class C_INIT_ModelCull : ParticleOperatorInstance +{ + public int ControlPointNumber; + public bool BoundBox; + public bool CullOutside; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Cull relative to model", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Bool("use only bounding box", "0", (o, v) => o.BoundBox = v) + .Bool("cull outside instead of inside", "0", (o, v) => o.CullOutside = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int controlPoint = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + particles.UpdateHitBoxInfo(controlPoint, HitboxSetName); + if (!particles.ControlPointHitBoxes[controlPoint].CurAndPrevValid()) + return; + + IParticleSystemQuery query = particles.Mgr!.Query(); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + bool inside = query.IsPointInControllingObjectHitBox(particles, controlPoint, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), BoundBox); + if (inside != CullOutside) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = -1.0f; + } + } +} + +public sealed class C_INIT_SetHitboxToModel : ParticleOperatorInstance +{ + const int MAX_POINTS_PER_BATCH = 100; + + public int ControlPointNumber; + public int ForceInModel; + public int DesiredHitbox; + public float HitBoxScale; + public Vector3 DirectionBias; + public bool MaintainHitbox; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Set Hitbox Position on Model", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Int("force to be inside model", "0", (o, v) => o.ForceInModel = v) + .Float("model hitbox scale", "1.0", (o, v) => o.HitBoxScale = v) + .Vector3("direction bias", "0 0 0", (o, v) => o.DirectionBias = v) + .Int("desired hitbox", "-1", (o, v) => o.DesiredHitbox = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v) + .Bool("maintain existing hitbox", "0", (o, v) => o.MaintainHitbox = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int controlPoint = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + particles.UpdateHitBoxInfo(controlPoint, HitboxSetName); + + Span points = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span relativeCoords = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span hitboxIndices = stackalloc int[MAX_POINTS_PER_BATCH]; + int particle = firstParticle; + while (numParticles > 0) { + int count = Math.Min(numParticles, MAX_POINTS_PER_BATCH); + int desiredHitbox = MaintainHitbox ? particles.GetIntAttributeValue(PARTICLE_ATTRIBUTE_HITBOX_INDEX, particle) : DesiredHitbox; + points[..count].Clear(); + relativeCoords[..count].Clear(); + hitboxIndices[..count].Clear(); + + particles.Mgr!.Query().GetRandomPointsOnControllingObjectHitBox(particles, controlPoint, count, HitBoxScale, ForceInModel, points, DirectionBias, relativeCoords, hitboxIndices, desiredHitbox, HitboxSetName); + + for (int i = 0; i < count; i++, particle++) { + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, particle, relativeCoords[i]); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK) != 0) + particles.GetIntAttributeRefForWrite(PARTICLE_ATTRIBUTE_HITBOX_INDEX, particle) = hitboxIndices[i]; + } + numParticles -= count; + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Parent.cs b/Source.Particles/BuiltinParticleInitializers.Parent.cs new file mode 100644 index 00000000..248924e6 --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Parent.cs @@ -0,0 +1,132 @@ +using Datamodel; + +using System.Numerics; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +internal static class ParentParticleUtil +{ + public const uint VECTOR_ATTRIBUTES_MASK = 0x228045; + + public static ref int Current(Span context) => ref MemoryMarshal.AsRef(context); + + public static int NextParent(ParticleCollection particles, ref int current, int maxIndex, bool random) { + if (random) + current = (int)(uint)((maxIndex + 1) * particles.RandomFloat(0.0f, 1.0f)); + else if (maxIndex < current || current < 0) + current = 0; + return current; + } +} + +public sealed class C_INIT_CreateFromParentParticles : ParticleOperatorInstance +{ + public float VelocityScale; + public bool RandomDistribution; + public int Increment; + + public static readonly ParticleOperatorDefinition Definition = new("Position From Parent Particles", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("Inherited Velocity Scale", "0", (o, v) => o.VelocityScale = v) + .Bool("Random Parent Particle Distribution", "0", (o, v) => o.RandomDistribution = v) + .Int("Particle Increment Amount", "1", (o, v) => o.Increment = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override int GetRequiredContextBytes() => sizeof(int); + + public override void InitializeContextData(ParticleCollection particles, Span context) => ParentParticleUtil.Current(context) = 0; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ParticleCollection? parent = particles.Parent; + if (parent == null) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, Vector3.Zero); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, Vector3.Zero); + } + return; + } + + if (parent.ActiveParticles == 0) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = 0.0f; + return; + } + + ref int current = ref ParentParticleUtil.Current(context); + int maxIndex = Math.Max(0, parent.ActiveParticles - 1); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + int index = ParentParticleUtil.NextParent(particles, ref current, maxIndex, RandomDistribution); + + float curTime = particles.CurTime; + float prevTime = curTime - particles.Dt; + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float t; + if (prevTime == curTime) + t = creationTime < curTime ? 0.0f : 1.0f; + else + t = Math.Clamp((creationTime - prevTime) / particles.Dt, 0.0f, 1.0f); + + Vector3 parentPrev = parent.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, index); + Vector3 parentXYZ = parent.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, index); + Vector3 pos = (parentXYZ - parentPrev) * t + parentPrev; + Vector3 prev = (parentPrev - pos) * VelocityScale + pos; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, pos); + current += Increment; + } + } +} + +public sealed class C_INIT_InheritFromParentParticles : ParticleOperatorInstance +{ + public float Scale; + public int FieldOutput; + public int Increment; + public bool RandomDistribution; + + public static readonly ParticleOperatorDefinition Definition = new("Inherit Initial Value From Parent Particle", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Int("Inherited Field", "3", (o, v) => o.FieldOutput = v) + .Float("Scale", "1", (o, v) => o.Scale = v) + .Bool("Random Parent Particle Distribution", "0", (o, v) => o.RandomDistribution = v) + .Int("Particle Increment Amount", "1", (o, v) => o.Increment = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => sizeof(int); + public override bool InitMultipleOverride() => true; + + public override void InitializeContextData(ParticleCollection particles, Span context) => ParentParticleUtil.Current(context) = 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ParticleCollection? parent = particles.Parent; + if (parent == null || parent.ActiveParticles == 0) + return; + + ref int current = ref ParentParticleUtil.Current(context); + int maxIndex = Math.Max(0, parent.ActiveParticles - 1); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + int index = ParentParticleUtil.NextParent(particles, ref current, maxIndex, RandomDistribution); + if (ParticleInitUtil.CheckField(FieldOutput)) { + uint mask = 1u << FieldOutput; + if ((mask & ParentParticleUtil.VECTOR_ATTRIBUTES_MASK) == 0) { + float value = parent.GetFloatAttributeValue(FieldOutput, index) * Scale; + if ((mask & ParticleInitUtil.ALPHA_ATTRIBUTES_MASK) != 0) + value = Math.Clamp(value, 0.0f, 1.0f); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + else + particles.SetVectorAttribute(FieldOutput, p, parent.GetVectorAttributeValue(FieldOutput, index) * Scale); + } + current += Increment; + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Position.cs b/Source.Particles/BuiltinParticleInitializers.Position.cs new file mode 100644 index 00000000..72a43126 --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Position.cs @@ -0,0 +1,443 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +using QAngle = Source.Common.Mathematics.QAngle; + +namespace Source.Particles; + +public sealed class C_INIT_RingWave : ParticleOperatorInstance +{ + public int ControlPointNumber; + public int OverrideCP; + public int OverrideCP2; + public float ParticlesPerOrbit; + public float InitialRadius; + public float Thickness; + public float InitialSpeedMin; + public float InitialSpeedMax; + public float Roll; + public float Pitch; + public float Yaw; + public bool EvenDistribution; + public bool XYVelocityOnly; + + public static readonly ParticleOperatorDefinition Definition = new("Position Along Ring", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Float("initial radius", "0", (o, v) => o.InitialRadius = v) + .Float("thickness", "0", (o, v) => o.Thickness = v) + .Float("min initial speed", "0", (o, v) => o.InitialSpeedMin = v) + .Float("max initial speed", "0", (o, v) => o.InitialSpeedMax = v) + .Float("yaw", "0", (o, v) => o.Yaw = v) + .Float("roll", "0", (o, v) => o.Roll = v) + .Float("pitch", "0", (o, v) => o.Pitch = v) + .Bool("even distribution", "0", (o, v) => o.EvenDistribution = v) + .Float("even distribution count", "-1", (o, v) => o.ParticlesPerOrbit = v) + .Bool("XY velocity only", "1", (o, v) => o.XYVelocityOnly = v) + .Int("Override CP (X/Y/Z *= Radius/Thickness/Speed)", "-1", (o, v) => o.OverrideCP = v) + .Int("Override CP 2 (X/Y/Z *= Pitch/Yaw/Roll)", "-1", (o, v) => o.OverrideCP2 = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override int GetRequiredContextBytes() => sizeof(uint); + + public override ulong GetReadControlPointMask() { + ulong mask = 1UL << (ControlPointNumber & 63); + if (OverrideCP != -1) + mask |= 1UL << (OverrideCP & 63); + if (OverrideCP2 != -1) + mask |= 1UL << (OverrideCP2 & 63); + return mask; + } + + static ref uint Count(Span context) => ref MemoryMarshal.AsRef(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) => Count(context) = 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + OverrideCP = Math.Clamp(OverrideCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + OverrideCP2 = Math.Clamp(OverrideCP2, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + InitialSpeedMax = Math.Max(InitialSpeedMin, InitialSpeedMax); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref uint count = ref Count(context); + if (count >= ~(uint)numParticles) + count = 0; + + float radius = InitialRadius; + float thickness = Thickness; + float speedMin = InitialSpeedMin; + float speedMax = InitialSpeedMax; + QAngle angles = new(Pitch, Yaw, Roll); + + if (OverrideCP != -1) { + Vector3 scale = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(OverrideCP)); + radius *= scale.X; + thickness *= scale.Y; + speedMin *= scale.Z; + speedMax *= scale.Z; + } + + if (OverrideCP2 != -1) { + Vector3 scale = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(OverrideCP2)); + angles.X *= scale.X; + angles.Y *= scale.Y; + angles.Z *= scale.Z; + } + + MathLib.AngleMatrix(angles, out Matrix3x4 rotation); + float theta = (float)(2.0 * Math.PI / (EvenDistribution && ParticlesPerOrbit != -1.0f ? ParticlesPerOrbit : (float)numParticles)); + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + count++; + particles.RandomVectorInUnitSphere(out Vector3 randPos); + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Matrix3x4 mat); + MathLib.MatrixGetColumn(mat, 3, out Vector3 controlPoint); + + float angle = EvenDistribution ? theta : particles.RandomFloat(0.0f, 6.2831855f); + (float sin, float cos) = MathF.SinCos(count * angle); + MathLib.VectorRotate(new Vector3(cos * radius, sin * radius, 0.0f), rotation, out Vector3 pointOnCircle); + + float speed = particles.RandomFloat(speedMin, speedMax); + randPos = randPos * thickness + pointOnCircle; + MathLib.VectorTransform(randPos, mat, out Vector3 world); + + Vector3 dir = world - controlPoint; + MathLib.VectorNormalize(ref dir); + float step = speed * particles.PreviousDt; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, world); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) != 0) { + Vector3 prev = world - dir * step; + if (XYVelocityOnly) + prev.Z = world.Z; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev); + } + } + } +} + +public sealed class C_INIT_CreateInEpitrochoid : ParticleOperatorInstance +{ + public int Component1; + public int Component2; + public int ControlPointNumber; + public int ScaleCP; + public float ParticleDensity; + public float Offset; + public float Radius1; + public float Radius2; + public bool UseCount; + public bool UseLocalCoords; + public bool OffsetExistingPos; + + public static readonly ParticleOperatorDefinition Definition = new("Position Along Epitrochoid", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Int("first dimension 0-2 (-1 disables)", "0", (o, v) => o.Component1 = v) + .Int("second dimension 0-2 (-1 disables)", "1", (o, v) => o.Component2 = v) + .Float("radius 1", "40", (o, v) => o.Radius1 = v) + .Float("radius 2", "24", (o, v) => o.Radius2 = v) + .Float("point offset", "4", (o, v) => o.Offset = v) + .Float("particle density", "10", (o, v) => o.ParticleDensity = v) + .Bool("use particle count instead of creation time", "0", (o, v) => o.UseCount = v) + .Bool("local space", "0", (o, v) => o.UseLocalCoords = v) + .Bool("offset from existing position", "0", (o, v) => o.OffsetExistingPos = v) + .Int("scale from conrol point (radius 1/radius 2/offset)", "-1", (o, v) => o.ScaleCP = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => (1UL << (ScaleCP & 63)) | (1UL << (ControlPointNumber & 63)); + public override int GetRequiredContextBytes() => sizeof(uint); + public override bool InitMultipleOverride() => OffsetExistingPos; + + static ref uint Count(Span context) => ref MemoryMarshal.AsRef(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) => Count(context) = 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + ScaleCP = Math.Clamp(ScaleCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + ParticleDensity = Math.Max(MathLibConsts.FLT_EPSILON, Math.Min(float.MaxValue, ParticleDensity)); + Component1 = Math.Clamp(Component1, -1, 2); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref uint count = ref Count(context); + int cp = ParticleInitUtil.CheckControlPoint(ControlPointNumber); + Vector3 cpPos = particles.GetControlPointAtCurrentTime(cp); + particles.GetControlPointTransformAtCurrentTime(cp, out Matrix3x4 mat); + + float radiiAdd, offset, radius2; + if (ScaleCP < 0) { + offset = Offset; + radiiAdd = Radius2 + Radius1; + radius2 = Radius2 + MathLibConsts.FLT_EPSILON; + } + else { + Vector3 scale = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(ScaleCP)); + offset = scale.Z * Offset; + radius2 = scale.Y * Radius2 + MathLibConsts.FLT_EPSILON; + radiiAdd = scale.X * Radius1 + radius2; + } + + if (radiiAdd == 0.0f || radius2 == 0.0f) + return; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float time; + if (UseCount) { + time = count * ParticleDensity; + count++; + } + else + time = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p) * ParticleDensity; + + Vector3 xyz = cpPos; + Vector3 prev = cpPos; + if (OffsetExistingPos) { + xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + } + + Vector3 epitrochoid = Vector3.Zero; + double multiplier = 1.0f / radius2 * time * radiiAdd; + if (Component1 != -1) + epitrochoid[Component1] = (float)(Math.Cos(time) * radiiAdd + Math.Cos(multiplier) * offset); + if (Component2 != -1) + epitrochoid[Component2] = (float)(Math.Sin(time) * radiiAdd + Math.Sin(multiplier) * offset); + + if (UseLocalCoords) + MathLib.VectorRotate(epitrochoid, mat, out epitrochoid); + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz + epitrochoid); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev + epitrochoid); + } + } +} + +public sealed class C_INIT_ChaoticAttractor : ParticleOperatorInstance +{ + public float AParm; + public float BParm; + public float CParm; + public float DParm; + public float Scale; + public float SpeedMin; + public float SpeedMax; + public int BaseCP; + public bool UniformSpeed; + + public static readonly ParticleOperatorDefinition Definition = new("Position From Chaotic Attractor", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Pickover A Parameter", "-0.9629629", (o, v) => o.AParm = v) + .Float("Pickover B Parameter", "2.791139", (o, v) => o.BParm = v) + .Float("Pickover C Parameter", "1.85185185", (o, v) => o.CParm = v) + .Float("Pickover D Parameter", "1.5", (o, v) => o.DParm = v) + .Float("Speed Min", "0", (o, v) => o.SpeedMin = v) + .Float("Speed Max", "0", (o, v) => o.SpeedMax = v) + .Bool("Uniform speed", "0", (o, v) => o.UniformSpeed = v) + .Int("Relative Control point number", "0", (o, v) => o.BaseCP = v) + .Float("Scale", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (BaseCP & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + static ref Vector3 LastPosition(Span context) => ref MemoryMarshal.AsRef(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) => LastPosition(context) = Vector3.Zero; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref Vector3 last = ref LastPosition(context); + int cp = ParticleInitUtil.CheckControlPoint(BaseCP); + Vector3 cpPos = particles.GetControlPointAtCurrentTime(cp); + particles.GetControlPointOrientationAtCurrentTime(cp, out Vector3 fwd, out Vector3 right, out Vector3 up); + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 s = last * Scale; + Vector3 pos = new( + right.X * s.X + cpPos.X + fwd.X * s.Y + up.X * s.Z, + right.Y * s.X + cpPos.Y + fwd.Y * s.Y + up.Y * s.Z, + right.Z * s.X + cpPos.Z + fwd.Z * s.Y + up.Z * s.Z); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, pos); + + Vector3 next = new( + (float)(Math.Sin(last.Y * AParm) - Math.Cos(last.X * BParm) * last.Z), + (float)(Math.Sin(last.X * CParm) * last.Z - Math.Cos(last.Y * DParm)), + MathF.Sin(last.X)); + + if (MathF.Abs(SpeedMax) <= 0.0f) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, pos); + else { + Vector3 dx = next - last; + if (!UniformSpeed) { + float len = MathF.Sqrt(dx.Y * dx.Y + dx.X * dx.X + dx.Z * dx.Z); + if (MathF.Abs(len) > 0.0f) + dx *= 1.0f / len; + } + + int min = (int)SpeedMin; + float range = (int)SpeedMax - min + 1; + float speed = (int)(range * particles.RandomFloat(0.0f, 1.0f)) + min; + float dt = particles.PreviousDt; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, new Vector3( + dx.X * speed * dt + pos.X, + dx.Y * speed * dt + pos.Y, + dx.Z * speed * dt + pos.Z)); + } + + last = next; + } + } +} + +public sealed class C_INIT_PositionPlaceOnGround : ParticleOperatorInstance +{ + public float Offset; + public float MaxTraceLength; + public string CollisionGroupName = "NONE"; + public bool KillOnNoCollision; + public bool IncludeWater; + public bool SetNormal; + int CollisionGroupNumber; + Mask CollisionMask; + + public static readonly ParticleOperatorDefinition Definition = new("Position Modify Place On Ground", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("offset", "0", (o, v) => o.Offset = v) + .Bool("kill on no collision", "0", (o, v) => o.KillOnNoCollision = v) + .Bool("include water", "0", (o, v) => o.IncludeWater = v) + .Bool("set normal", "0", (o, v) => o.SetNormal = v) + .Float("max trace length", "128", (o, v) => o.MaxTraceLength = v) + .String("collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v)); + + public override uint GetWrittenAttributes() => SetNormal ? 0x200007u : 7u; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + CollisionMask = (Mask)(IncludeWater ? 0x600403b : 0x600400b); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + IParticleSystemQuery query = particles.Mgr!.Query(); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 start = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 end = new(start.X, start.Y, start.Z - MaxTraceLength); + GameTrace tr = default; + query.TraceLine(start, end, CollisionMask, null, CollisionGroupNumber, ref tr); + + if (tr.Fraction == 1.0f && KillOnNoCollision) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = -1.0f; + else { + float drop = tr.Fraction * MaxTraceLength - Offset; + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz with { Z = xyz.Z - drop }); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev with { Z = prev.Z - drop }); + } + + if (SetNormal) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_NORMAL, p, tr.Plane.Normal); + } + } +} + +public sealed class C_INIT_MoveBetweenPoints : ParticleOperatorInstance +{ + public float SpeedMin; + public float SpeedMax; + public float EndSpread; + public float StartOffset; + public float EndOffset; + public int EndControlPointNumber; + public bool TrailBias; + + public static readonly ParticleOperatorDefinition Definition = new("Move Particles Between 2 Control Points", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("minimum speed", "1", (o, v) => o.SpeedMin = v) + .Float("maximum speed", "1", (o, v) => o.SpeedMax = v) + .Float("end spread", "0", (o, v) => o.EndSpread = v) + .Float("start offset", "0", (o, v) => o.StartOffset = v) + .Float("end offset", "0", (o, v) => o.EndOffset = v) + .Bool("bias lifetime by trail length", "0", (o, v) => o.TrailBias = v) + .Int("end control point", "1", (o, v) => o.EndControlPointNumber = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK; + public override ulong GetReadControlPointMask() => 1UL << (EndControlPointNumber & 63); + public override bool InitMultipleOverride() => TrailBias; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => EndControlPointNumber = Math.Min(EndControlPointNumber, MAX_PARTICLE_CONTROL_POINTS - 1); + + static float Length(in Vector3 d) => MathF.Sqrt(d.Y * d.Y + d.X * d.X + d.Z * d.Z); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + bool moveStartPoint = StartOffset != 0.0f; + bool moveEndPoint = EndOffset != 0.0f; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 start = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + particles.GetControlPointAtTime(ParticleInitUtil.CheckControlPoint(EndControlPointNumber), particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 end); + + Vector3 randPos = Vector3.Zero; + if (EndSpread > 0.0f) { + particles.RandomVectorInUnitSphere(out randPos); + randPos *= EndSpread; + } + + end += randPos; + Vector3 delta = end - start; + float len = Length(delta); + + if (moveEndPoint) { + end += EndOffset / (len + MathLibConsts.FLT_EPSILON) * delta; + delta = end - start; + len = Length(delta); + } + + if (moveStartPoint) { + start += StartOffset / (len + MathLibConsts.FLT_EPSILON) * delta; + delta = end - start; + len = Length(delta); + } + + float vel = particles.RandomFloat(SpeedMin, SpeedMax); + float life = len / (vel + MathLibConsts.FLT_EPSILON); + if (TrailBias) + life += particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, p); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = life; + + float scale = vel / (len + MathLibConsts.FLT_EPSILON); + float dt = particles.PreviousDt; + + if (moveStartPoint) { + ref float xyz = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_XYZ, p); + xyz = start.X; + Unsafe.Add(ref xyz, 1) = start.Y; + Unsafe.Add(ref xyz, 2) = start.Z; + } + + Vector3 pos = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, new Vector3( + pos.X - scale * delta.X * dt, + pos.Y - delta.Y * scale * dt, + pos.Z - delta.Z * scale * dt)); + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Random.cs b/Source.Particles/BuiltinParticleInitializers.Random.cs new file mode 100644 index 00000000..ba5351d7 --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Random.cs @@ -0,0 +1,149 @@ +using Datamodel; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_INIT_VelocityRandom : ParticleOperatorInstance +{ + public int ControlPointNumber; + public float SpeedMin; + public float SpeedMax; + public Vector3 LocalCoordinateSystemSpeedMin; + public Vector3 LocalCoordinateSystemSpeedMax; + bool HasLocalSpeed; + + public static readonly ParticleOperatorDefinition Definition = new("Velocity Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("random_speed_min", "0", (o, v) => o.SpeedMin = v) + .Float("random_speed_max", "0", (o, v) => o.SpeedMax = v) + .Vector3("speed_in_local_coordinate_system_min", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMin = v) + .Vector3("speed_in_local_coordinate_system_max", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMax = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + HasLocalSpeed = LocalCoordinateSystemSpeedMin != Vector3.Zero || LocalCoordinateSystemSpeedMax != Vector3.Zero; + if (SpeedMax < SpeedMin) + (SpeedMin, SpeedMax) = (SpeedMax, SpeedMin); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 velocity = Vector3.Zero; + if (HasLocalSpeed) { + particles.RandomVector(LocalCoordinateSystemSpeedMin, LocalCoordinateSystemSpeedMax, out Vector3 local); + particles.GetControlPointOrientationAtTime(ControlPointNumber, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 forward, out Vector3 right, out Vector3 up); + velocity = local.X * forward - local.Y * right + local.Z * up; + } + + if (SpeedMax > 0.0f) { + particles.RandomVector(SpeedMin, SpeedMax, out Vector3 random); + velocity += random; + } + + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev - velocity * particles.PreviousDt); + } + } +} + +public sealed class C_INIT_RandomScalar : ParticleOperatorInstance +{ + public float Min; + public float Max; + public float Exponent; + public int FieldOutput; + + public static readonly ParticleOperatorDefinition Definition = new("Scalar Random", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("min", "0", (o, v) => o.Min = v) + .Float("max", "0", (o, v) => o.Max = v) + .Float("exponent", "1", (o, v) => o.Exponent = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + if (ParticleInitUtil.CheckField(FieldOutput)) + InitScalarAttributeRandomRangeScalar(FieldOutput, Min, Max, Exponent, particles, firstParticle, numParticles); + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) { + if (ParticleInitUtil.CheckField(FieldOutput)) + InitScalarAttributeRandomRangeBlock(FieldOutput, Min, Max, Exponent, particles, startBlock, numBlocks, false); + } +} + +public sealed class C_INIT_RandomVector : ParticleOperatorInstance +{ + public Vector3 Min; + public Vector3 Max; + public int FieldOutput; + + public static readonly ParticleOperatorDefinition Definition = new("Vector Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("min", "0 0 0", (o, v) => o.Min = v) + .Vector3("max", "0 0 0", (o, v) => o.Max = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + bool valid = ParticleInitUtil.CheckField(FieldOutput); + particles.RandomVector(Min, Max, out Vector3 output); + if (valid) + particles.SetVectorAttribute(FieldOutput, p, output); + } + } +} + +public sealed class C_INIT_RandomVectorComponent : ParticleOperatorInstance +{ + public float Min; + public float Max; + public int FieldOutput; + public int Component; + + public static readonly ParticleOperatorDefinition Definition = new("Vector Component Random", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Float("min", "0", (o, v) => o.Min = v) + .Float("max", "0", (o, v) => o.Max = v) + .Int("component 0/1/2 X/Y/Z", "0", (o, v) => o.Component = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 1u << (FieldOutput & 31); + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Component = Math.Clamp(Component, 0, 2); + FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + bool valid = ParticleInitUtil.CheckField(FieldOutput); + Vector3 value = valid ? particles.GetVectorAttributeValue(FieldOutput, p) : Vector3.Zero; + value[Component] = particles.RandomFloat(Min, Max); + if (valid) + particles.SetVectorAttribute(FieldOutput, p, value); + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.Remap.cs b/Source.Particles/BuiltinParticleInitializers.Remap.cs new file mode 100644 index 00000000..6981536f --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.Remap.cs @@ -0,0 +1,543 @@ +using Datamodel; + +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_INIT_RemapParticleCountToScalar : ParticleOperatorInstance +{ + public int InputMin; + public int InputMax; + public int FieldOutput; + public float OutputMin; + public float OutputMax; + public bool ScaleInitialRange; + public bool ActiveRange; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Particle Count to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("input minimum", "0", (o, v) => o.InputMin = v) + .Int("input maximum", "10", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("only active within specified input range", "0", (o, v) => o.ActiveRange = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => sizeof(int); + public override bool InitMultipleOverride() => true; + + static ref int Count(Span context) => ref MemoryMarshal.AsRef(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) => Count(context) = 0; + public override void Restart(ParticleCollection particles, Span context) => Count(context) = 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << (FieldOutput & 31))) != 0) { + OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f); + OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref int count = ref Count(context); + if (ActiveRange && count > InputMax) + return; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + if (ActiveRange && (count < InputMin || count > InputMax)) { + count++; + continue; + } + + bool valid = ParticleInitUtil.CheckField(FieldOutput); + float output = ParticleInitUtil.RemapClamped(count, InputMin, InputMax, OutputMin, OutputMax); + if (valid) { + ref float attr = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= attr; + if ((ParticleInitUtil.INT_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) + output = (int)output; + attr = output; + } + count++; + } + } +} + +public sealed class C_INIT_OffsetVectorToVector : ParticleOperatorInstance +{ + public int FieldInput; + public int FieldOutput; + public Vector3 OutputMin; + public Vector3 OutputMax; + int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Offset Vector to Vector", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.Begin() + .Int("input field", "0", (o, v) => o.FieldInput = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("output offset minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output offset maximum", "1 1 1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => 1u << (FieldInput & 31); + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = Math.Clamp(FieldOutput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + FieldInput = Math.Clamp(FieldInput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + ControlPointNumber = Math.Min(ControlPointNumber, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 input = particles.GetVectorAttributeValue(FieldInput, p); + particles.RandomVector(OutputMin, OutputMax, out Vector3 offset); + particles.SetVectorAttribute(FieldOutput, p, offset + input); + } + } +} + +public sealed class C_INIT_DistanceToCPInit : ParticleOperatorInstance +{ + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public int StartCP; + public bool LOS; + public string CollisionGroupName = "NONE"; + public float MaxTraceLength; + public float LOSScale; + public bool ScaleInitialRange; + public bool ActiveRange; + int CollisionGroupNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Initial Distance to Control Point to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("distance minimum", "0", (o, v) => o.InputMin = v) + .Float("distance maximum", "128", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Int("control point", "0", (o, v) => o.StartCP = v) + .Bool("ensure line of sight", "0", (o, v) => o.LOS = v) + .String("LOS collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Float("Maximum Trace Length", "-1", (o, v) => o.MaxTraceLength = v) + .Float("LOS Failure Scalar", "0", (o, v) => o.LOSScale = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("only active within specified distance", "0", (o, v) => o.ActiveRange = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << (StartCP & 63); + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = Math.Clamp(FieldOutput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + StartCP = Math.Clamp(StartCP, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) { + OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f); + OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + Vector3 cp = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(StartCP)); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 d = cp - xyz; + float distance = MathF.Sqrt(d.Y * d.Y + d.X * d.X + d.Z * d.Z); + if (ActiveRange && (distance < InputMin || distance > InputMax)) + continue; + + if (LOS) + distance = ParticleCPUtil.LOSDistance(particles, cp, xyz, distance, MaxTraceLength, CollisionGroupNumber, LOSScale); + + float output = ParticleInitUtil.RemapClamped(distance, InputMin, InputMax, OutputMin, OutputMax); + ref float attr = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= attr; + attr = output; + } + } +} + +public sealed class C_INIT_RemapInitialDirectionToCPToVector : ParticleOperatorInstance +{ + public int CP; + public int FieldOutput; + public float Scale; + public float OffsetRot; + public Vector3 OffsetAxis; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Initial Direction to CP to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point", "0", (o, v) => o.CP = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Bool("normalize", "0", (o, v) => o.Normalize = v) + .Vector3("offset axis", "0 0 0", (o, v) => o.OffsetAxis = v) + .Float("offset rotation", "0", (o, v) => o.OffsetRot = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << (CP & 63); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CP = Math.Clamp(CP, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + } + + static Vector3 Rotate(in Matrix4x4 m, in Vector3 v) => new( + m.M12 * v.Y + m.M11 * v.X + m.M13 * v.Z, + m.M22 * v.Y + m.M21 * v.X + m.M23 * v.Z, + m.M32 * v.Y + m.M31 * v.X + m.M33 * v.Z); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + MathLib.MatrixBuildRotationAboutAxis(out Matrix4x4 rot, OffsetAxis, OffsetRot); + Vector3 cp = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(CP)); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + bool valid = ParticleInitUtil.CheckField(FieldOutput); + Vector3 output = Rotate(rot, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp); + if (Normalize) + MathLib.VectorNormalize(ref output); + output *= Scale; + if (valid) + particles.SetVectorAttribute(FieldOutput, p, output); + } + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) { + if (!ParticleInitUtil.CheckField(FieldOutput)) + return; + + MathLib.MatrixBuildRotationAboutAxis(out Matrix4x4 rot, OffsetAxis, OffsetRot); + Vector3 cp = particles.GetControlPointAtCurrentTime(ParticleInitUtil.CheckControlPoint(CP)); + int count = particles.PaddedActiveParticles * 4; + + if (Normalize) { + for (int p = 0; p < count; p++) { + Vector3 r = Rotate(rot, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp); + float lenSq = r.Y * r.Y + r.X * r.X + r.Z * r.Z; + float inv = MathF.ReciprocalSqrtEstimate(lenSq); + inv = (3.0f - inv * inv * lenSq) * inv * 0.5f; + particles.SetVectorAttribute(FieldOutput, p, new Vector3(r.X * inv * Scale, r.Y * inv * Scale, r.Z * inv * Scale)); + } + return; + } + + float scale = Scale / Math.Max(particles.PreviousDt, 1e-20f); + for (int p = 0; p < count; p++) { + int lane = p & 3; + Vector3 garbageOffset = new(rot[0, lane], rot[1, lane], rot[2, lane]); + Vector3 r = Rotate(rot, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp + garbageOffset); + particles.SetVectorAttribute(FieldOutput, p, r * scale); + } + } +} + +public sealed class C_INIT_RemapScalarToVector : ParticleOperatorInstance +{ + public float StartTime; + public float EndTime; + public int FieldInput; + public float InputMin; + public float InputMax; + public int FieldOutput; + public Vector3 OutputMin; + public Vector3 OutputMax; + public bool ScaleInitialRange; + public bool LocalCoords; + public int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Scalar to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input field", "8", (o, v) => o.FieldInput = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("use local system", "1", (o, v) => o.LocalCoords = v) + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | (1u << (FieldOutput & 31)); + public override uint GetReadAttributes() => 1u << (FieldInput & 31); + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = Math.Clamp(FieldOutput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + FieldInput = Math.Clamp(FieldInput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + ControlPointNumber = Math.Min(ControlPointNumber, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + if ((creationTime < StartTime || creationTime >= EndTime) && StartTime != -1.0f && EndTime != -1.0f) + continue; + + float input = particles.GetFloatAttributeValue(FieldInput, p); + Vector3 output = new( + ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin.X, OutputMax.X), + ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin.Y, OutputMax.Y), + ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin.Z, OutputMax.Z)); + + if (FieldOutput != PARTICLE_ATTRIBUTE_XYZ) { + if (ScaleInitialRange) + output *= particles.GetVectorAttributeValue(FieldOutput, p); + particles.SetVectorAttribute(FieldOutput, p, output); + continue; + } + + if (!LocalCoords) { + particles.GetControlPointAtTime(ParticleInitUtil.CheckControlPoint(ControlPointNumber), creationTime, out Vector3 cp); + output += cp; + Vector3 outputPrev = output; + if (ScaleInitialRange) { + output *= particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + outputPrev *= particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + } + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, output); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, outputPrev); + } + else { + particles.GetControlPointTransformAtTime(ParticleInitUtil.CheckControlPoint(ControlPointNumber), creationTime, out Matrix3x4 mat); + MathLib.VectorTransform(output, mat, out output); + if (ScaleInitialRange) + output *= particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, output); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, output); + } + } + } +} + +public sealed class C_INIT_RemapCPtoVector : ParticleOperatorInstance +{ + public float StartTime; + public float EndTime; + public int CPInput; + public Vector3 InputMin; + public Vector3 InputMax; + public int FieldOutput; + public Vector3 OutputMin; + public Vector3 OutputMax; + public bool ScaleInitialRange; + public bool Offset; + public bool Accelerate; + public int LocalSpaceCP; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Control Point to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input control point number", "0", (o, v) => o.CPInput = v) + .Vector3("input minimum", "0 0 0", (o, v) => o.InputMin = v) + .Vector3("input maximum", "0 0 0", (o, v) => o.InputMax = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "0 0 0", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("offset position", "0", (o, v) => o.Offset = v) + .Bool("accelerate position", "0", (o, v) => o.Accelerate = v) + .Int("local space CP", "-1", (o, v) => o.LocalSpaceCP = v)); + + public override uint GetWrittenAttributes() => (1u << (FieldOutput & 31)) | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override ulong GetReadControlPointMask() { + ulong mask = 1UL << (CPInput & 63); + if (LocalSpaceCP != -1) + mask |= 1UL << (LocalSpaceCP & 63); + return mask; + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + LocalSpaceCP = Math.Clamp(LocalSpaceCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + CPInput = Math.Clamp(CPInput, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + FieldOutput = ParticleInitUtil.ClampFieldUpper(FieldOutput); + } + + static Vector3 Rotate(in Vector3 v, in Matrix3x4 m) => new( + m[0, 1] * v.Y + v.X * m[0, 0] + m[0, 2] * v.Z, + m[1, 1] * v.Y + m[1, 0] * v.X + m[1, 2] * v.Z, + m[2, 1] * v.Y + m[2, 0] * v.X + m[2, 2] * v.Z); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + particles.GetControlPointAtTime(CPInput, particles.CurTime, out Vector3 input); + Vector3 outMin = OutputMin; + Vector3 outMax = OutputMax; + if (LocalSpaceCP != -1) { + particles.GetControlPointTransformAtTime(LocalSpaceCP, particles.CurTime, out Matrix3x4 mat); + outMin = Rotate(OutputMin, mat); + outMax = Rotate(OutputMax, mat); + } + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + if ((creationTime < StartTime || creationTime >= EndTime) && StartTime != -1.0f && EndTime != -1.0f) + continue; + + bool valid = ParticleInitUtil.CheckField(FieldOutput); + Vector3 value = new( + ParticleInitUtil.RemapClamped(input.X, InputMin.X, InputMax.X, outMin.X, outMax.X), + ParticleInitUtil.RemapClamped(input.Y, InputMin.Y, InputMax.Y, outMin.Y, outMax.Y), + ParticleInitUtil.RemapClamped(input.Z, InputMin.Z, InputMax.Z, outMin.Z, outMax.Z)); + + if (ScaleInitialRange) + value *= valid ? particles.GetVectorAttributeValue(FieldOutput, p) : Vector3.Zero; + + if (!Accelerate) { + if (Offset) { + value += valid ? particles.GetVectorAttributeValue(FieldOutput, p) : Vector3.Zero; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + value); + } + } + else { + float dt = particles.Dt; + if (Offset) { + Vector3 sum = (valid ? particles.GetVectorAttributeValue(FieldOutput, p) : Vector3.Zero) + value; + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + if (valid) + particles.SetVectorAttribute(FieldOutput, p, sum * dt + sum); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, sum + prev); + value.X = dt; + } + value *= dt; + } + + if (valid) + particles.SetVectorAttribute(FieldOutput, p, value); + } + } +} + +public sealed class C_INIT_RemapSpeedToScalar : ParticleOperatorInstance +{ + public float StartTime; + public float EndTime; + public int ControlPointNumber; + public bool PerParticle; + public float InputMin; + public float InputMax; + public int FieldOutput; + public float OutputMin; + public float OutputMax; + public bool ScaleInitialRange; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Speed to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("control point number (ignored if per particle)", "0", (o, v) => o.ControlPointNumber = v) + .Bool("per particle", "0", (o, v) => o.PerParticle = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v)); + + public override uint GetWrittenAttributes() => 1u << (FieldOutput & 31); + public override uint GetReadAttributes() => (1u << (FieldOutput & 31)) | PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + FieldOutput = Math.Clamp(FieldOutput, 0, ParticleInitUtil.GMOD_ATTRIBUTE_COUNT - 1); + InputMin = InputMin <= 0.001f ? 0.001f : InputMin; + InputMax = InputMax <= 0.001f ? 0.001f : InputMax; + if (((1 << FieldOutput) & ParticleInitUtil.ALPHA_ATTRIBUTES_MASK) != 0) { + OutputMin = OutputMin <= 0.0f ? 0.0f : OutputMin; + OutputMin = 1.0f <= OutputMin ? 1.0f : OutputMin; + OutputMax = OutputMax <= 0.0f ? 0.0f : OutputMax; + OutputMax = 1.0f <= OutputMax ? 1.0f : OutputMax; + } + } + + bool InTimeRange(float time) => (StartTime <= time && time < EndTime) || StartTime == -1.0f || EndTime == -1.0f; + + static float Speed(in Vector3 delta, float dt) => MathF.Sqrt(delta.Y * delta.Y + delta.X * delta.X + delta.Z * delta.Z) / dt; + + float ControlPointSpeed(ParticleCollection particles) { + particles.GetControlPointAtPrevTime(ControlPointNumber, out Vector3 prev); + Vector3 cur = particles.ControlPoints[ParticleInitUtil.CheckControlPoint(ControlPointNumber)].Position; + return Speed(cur - prev, particles.PreviousDt); + } + + float ParticleSpeed(ParticleCollection particles, int p) + => Speed(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p), particles.PreviousDt); + + float RemapBlock(float speed) { + float t = (speed - InputMin) / (InputMax == InputMin ? 1.0f : InputMax - InputMin); + t = 1.0f < t ? 1.0f : t; + t = 0.0f > t ? 0.0f : t; + return t * (OutputMax - OutputMin) + OutputMin; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + if (!InTimeRange(particles.CurTime)) + return; + + if (!PerParticle) { + float value = ParticleInitUtil.RemapClamped(ControlPointSpeed(particles), InputMin, InputMax, OutputMin, OutputMax); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + if (ScaleInitialRange) + value *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + return; + } + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float value = ParticleInitUtil.RemapClamped(ParticleSpeed(particles, p), InputMin, InputMax, OutputMin, OutputMax); + if (ScaleInitialRange) + value *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) { + if (!InTimeRange(particles.CurTime)) + return; + + int first = startBlock * 4; + int end = first + numBlocks * 4; + + if (!PerParticle) { + float value = RemapBlock(ControlPointSpeed(particles)); + Span lanes = [value, value, value, value]; + for (int p = first; p < end; p++) { + if (ScaleInitialRange) + lanes[p & 3] *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = lanes[p & 3]; + } + return; + } + + for (int p = first; p < end; p++) { + float value = RemapBlock(ParticleSpeed(particles, p)); + if (ScaleInitialRange) + value *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + } +} diff --git a/Source.Particles/BuiltinParticleInitializers.cs b/Source.Particles/BuiltinParticleInitializers.cs new file mode 100644 index 00000000..14dcedd1 --- /dev/null +++ b/Source.Particles/BuiltinParticleInitializers.cs @@ -0,0 +1,1750 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleInitializers +{ + public static void AddBuiltInParticleInitializers(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateWithinSphere.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateWithinBox.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateOnModel.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_PositionOffset.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_PositionWarp.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateSequentialPath.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateAlongPath.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateInHierarchy.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InitialRepulsionVelocity.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InitialVelocityNoise.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InheritVelocity.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomLifeTime.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomRadius.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomAlpha.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomRotation.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomRotationSpeed.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomYaw.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomColor.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_ColorLitPerParticle.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomTrailLength.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomSequence.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreationNoise.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapCPtoScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_AgeNoise.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_SequenceLifeTime.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomYawFlip.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomSecondSequence.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RtEnvCull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_VelocityRandom.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomVectorComponent.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_SequenceFromCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_VelocityFromCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapParticleCountToScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapScalarToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RingWave.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateInEpitrochoid.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_MoveBetweenPoints.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_NormalAlignToCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_OffsetVectorToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_DistanceToCPInit.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_NormalOffset.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapInitialDirectionToCPToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapInitialCPDirectionToRotation.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_LifespanFromVelocity.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateFromPlaneCache.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateFromParentParticles.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InheritFromParentParticles.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_ChaoticAttractor.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_PositionPlaceOnGround.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_SetHitboxToClosest.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_SetHitboxToModel.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_ModelCull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapCPtoVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapSpeedToScalar.Definition); + } +} + +internal static class ParticleInitUtil +{ + public const int ROTATION_ATTRIBUTES_MASK = 0x101010; + public const int ALPHA_ATTRIBUTES_MASK = 0x10080; + public const int INT_ATTRIBUTES_MASK = 0x4800; + public const float DEG2RAD = 0.017453292f; + public const float INV_255 = 0.003921569f; + public static readonly Vector3 Vec3Invalid = new(float.MaxValue, float.MaxValue, float.MaxValue); + + public const int GMOD_ATTRIBUTE_COUNT = 22; + + public static int ClampFieldUpper(int field) => field > GMOD_ATTRIBUTE_COUNT - 1 ? GMOD_ATTRIBUTE_COUNT - 1 : field; + + public static bool CheckField(int field) { + if ((uint)field < GMOD_ATTRIBUTE_COUNT) + return true; + Warning($"GetFloatAttributePtrForWrite invalid attribute {field}\n"); + return false; + } + + public static int CheckControlPoint(int controlPoint) { + if ((uint)controlPoint < MAX_PARTICLE_CONTROL_POINTS) + return controlPoint; + Warning($"GetControlPointAtCurrentTime invalid control point {controlPoint}\n"); + return 0; + } + + public static float ReadScalar(ParticleCollection particles, int attribute, int particle) + => (INT_ATTRIBUTES_MASK & (1 << attribute)) != 0 ? particles.GetIntAttributeValue(attribute, particle) : particles.GetFloatAttributeValue(attribute, particle); + + public static void WriteScalar(ParticleCollection particles, int attribute, int particle, float value) { + if ((INT_ATTRIBUTES_MASK & (1 << attribute)) != 0) + particles.GetIntAttributeRefForWrite(attribute, particle) = (int)value; + else + particles.GetFloatAttributeRefForWrite(attribute, particle) = value; + } + + public static float RemapClamped(float value, float inMin, float inMax, float outMin, float outMax) { + if (inMin == inMax) + return value < inMax ? outMin : outMax; + float t = Math.Clamp((value - inMin) / (inMax - inMin), 0.0f, 1.0f); + return t * (outMax - outMin) + outMin; + } + + public static Vector3 ClampedTint(Color tint, Color tintMin, Color tintMax, float amplification) { + float scale = amplification * INV_255; + return new(Math.Max(tintMin.R, Math.Min(tint.R, tintMax.R)) * scale, + Math.Max(tintMin.G, Math.Min(tint.G, tintMax.G)) * scale, + Math.Max(tintMin.B, Math.Min(tint.B, tintMax.B)) * scale); + } + + static float Overlay(float color, float tint) => tint >= 0.5f ? 1.0f - (1.0f - color + (1.0f - color)) * (1.0f - tint) : (color + color) * tint; + + public static Vector3 BlendTint(in Vector3 colorMin, in Vector3 colorMax, float rand, in Vector3 tint, float tintPerc, int blendMode) { + Vector3 color = (colorMax - colorMin) * rand + colorMin; + Vector3 target = blendMode switch { + 0 => tint, + 1 => new(Overlay(color.X, tint.X), Overlay(color.Y, tint.Y), Overlay(color.Z, tint.Z)), + 2 => Vector3.Min(color, tint), + 3 => Vector3.Max(color, tint), + 4 => color * tint, + _ => Vector3.Zero + }; + color = (target - color) * tintPerc + color; + return new(Math.Min(color.X, 1.0f), Math.Min(color.Y, 1.0f), Math.Min(color.Z, 1.0f)); + } + + public static Vector3 Abs(Vector3 v, in Vector3 absMask) { + if (absMask.X != 0.0f) + v.X = MathF.Abs(v.X); + if (absMask.Y != 0.0f) + v.Y = MathF.Abs(v.Y); + if (absMask.Z != 0.0f) + v.Z = MathF.Abs(v.Z); + return v; + } +} + +public sealed class C_INIT_RandomLifeTime : ParticleOperatorInstance +{ + public float LifetimeMin; + public float LifetimeMax; + public float LifetimeRandExponent; + + public static readonly ParticleOperatorDefinition Definition = new("Lifetime Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("lifetime_min", "0", (o, v) => o.LifetimeMin = v) + .Float("lifetime_max", "0", (o, v) => o.LifetimeMax = v) + .Float("lifetime_random_exponent", "1", (o, v) => o.LifetimeRandExponent = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => 0; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_LIFE_DURATION, LifetimeMin, LifetimeMax, LifetimeRandExponent, particles, firstParticle, numParticles); + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_LIFE_DURATION, LifetimeMin, LifetimeMax, LifetimeRandExponent, particles, startBlock, numBlocks, false); +} + +public sealed class C_INIT_RandomRadius : ParticleOperatorInstance +{ + public float RadiusMin; + public float RadiusMax; + public float RadiusRandExponent; + + public static readonly ParticleOperatorDefinition Definition = new("Radius Random", ParticleOperatorId.PiRadius, false, + ParticleOperatorUnpack.Begin() + .Float("radius_min", "1", (o, v) => o.RadiusMin = v) + .Float("radius_max", "1", (o, v) => o.RadiusMax = v) + .Float("radius_random_exponent", "1", (o, v) => o.RadiusRandExponent = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override uint GetReadAttributes() => 0; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_RADIUS, RadiusMin, RadiusMax, RadiusRandExponent, particles, firstParticle, numParticles); + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_RADIUS, RadiusMin, RadiusMax, RadiusRandExponent, particles, startBlock, numBlocks, false); +} + +public sealed class C_INIT_RandomAlpha : ParticleOperatorInstance +{ + public int AlphaMin; + public int AlphaMax; + public float AlphaRandExponent; + float AlphaMinNorm; + float AlphaMaxNorm; + + public static readonly ParticleOperatorDefinition Definition = new("Alpha Random", ParticleOperatorId.PiAlpha, false, + ParticleOperatorUnpack.Begin() + .Int("alpha_min", "255", (o, v) => o.AlphaMin = v) + .Int("alpha_max", "255", (o, v) => o.AlphaMax = v) + .Float("alpha_random_exponent", "1", (o, v) => o.AlphaRandExponent = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + AlphaMinNorm = AlphaMin * ParticleInitUtil.INV_255; + AlphaMaxNorm = AlphaMax * ParticleInitUtil.INV_255; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_ALPHA, AlphaMinNorm, AlphaMaxNorm, AlphaRandExponent, particles, firstParticle, numParticles); + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_ALPHA, AlphaMinNorm, AlphaMaxNorm, AlphaRandExponent, particles, startBlock, numBlocks, false); +} + +public sealed class C_INIT_RandomTrailLength : ParticleOperatorInstance +{ + public float MinLength; + public float MaxLength; + public float LengthRandExponent; + + public static readonly ParticleOperatorDefinition Definition = new("Trail Length Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("length_min", "0.1", (o, v) => o.MinLength = v) + .Float("length_max", "0.1", (o, v) => o.MaxLength = v) + .Float("length_random_exponent", "1", (o, v) => o.LengthRandExponent = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK; + public override uint GetReadAttributes() => 0; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, MinLength, MaxLength, LengthRandExponent, particles, firstParticle, numParticles); + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, MinLength, MaxLength, LengthRandExponent, particles, startBlock, numBlocks, false); +} + +public abstract class GeneralRandomRotation : ParticleOperatorInstance +{ + public float Degrees; + public float DegreesMin; + public float DegreesMax; + public float RotationRandExponent; + public bool RandomlyFlipDirection; + protected float Radians; + protected float RadiansMin; + protected float RadiansMax; + + protected static DmxElementUnpackStructure Unpack(string initial, string min, string max, string exponent, bool flip) where T : GeneralRandomRotation { + DmxElementUnpackStructure unpack = ParticleOperatorUnpack.Begin() + .Float(initial, "0", (o, v) => o.Degrees = v) + .Float(min, "0", (o, v) => o.DegreesMin = v) + .Float(max, "360", (o, v) => o.DegreesMax = v) + .Float(exponent, "1", (o, v) => o.RotationRandExponent = v); + return flip ? unpack.Bool("randomly_flip_direction", "0", (o, v) => o.RandomlyFlipDirection = v) : unpack; + } + + protected abstract int GetAttributeToInit(); + + public override uint GetWrittenAttributes() => 1u << GetAttributeToInit(); + public override uint GetReadAttributes() => 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Radians = Degrees * ParticleInitUtil.DEG2RAD; + RadiansMin = DegreesMin * ParticleInitUtil.DEG2RAD; + RadiansMax = DegreesMax * ParticleInitUtil.DEG2RAD; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int attribute = GetAttributeToInit(); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float value = particles.RandomFloatExp(RadiansMin, RadiansMax, RotationRandExponent) + Radians; + if (RandomlyFlipDirection) { + float rand = particles.RandomFloat(0.0f, 1.0f); + if (rand + rand < 1.0f) + value = -value; + } + particles.GetFloatAttributeRefForWrite(attribute, p) = value; + } + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitScalarAttributeRandomRangeBlock(GetAttributeToInit(), RadiansMin, RadiansMax, RotationRandExponent, particles, startBlock, numBlocks, RandomlyFlipDirection); +} + +public sealed class C_INIT_RandomRotation : GeneralRandomRotation +{ + public static readonly ParticleOperatorDefinition Definition = new("Rotation Random", ParticleOperatorId.PiRotation, false, + Unpack("rotation_initial", "rotation_offset_min", "rotation_offset_max", "rotation_random_exponent", true)); + + protected override int GetAttributeToInit() => PARTICLE_ATTRIBUTE_ROTATION; +} + +public sealed class C_INIT_RandomRotationSpeed : GeneralRandomRotation +{ + public static readonly ParticleOperatorDefinition Definition = new("Rotation Speed Random", ParticleOperatorId.Generic, false, + Unpack("rotation_speed_constant", "rotation_speed_random_min", "rotation_speed_random_max", "rotation_speed_random_exponent", true)); + + protected override int GetAttributeToInit() => PARTICLE_ATTRIBUTE_ROTATION_SPEED; +} + +public sealed class C_INIT_RandomYaw : GeneralRandomRotation +{ + public static readonly ParticleOperatorDefinition Definition = new("Rotation Yaw Random", ParticleOperatorId.PiYaw, false, + Unpack("yaw_initial", "yaw_offset_min", "yaw_offset_max", "yaw_random_exponent", false)); + + protected override int GetAttributeToInit() => PARTICLE_ATTRIBUTE_YAW; +} + +public sealed class C_INIT_RandomYawFlip : ParticleOperatorInstance +{ + public float Percent; + + public static readonly ParticleOperatorDefinition Definition = new("Rotation Yaw Flip Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Flip Percentage", ".5", (o, v) => o.Percent = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_YAW_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_YAW_MASK; + public override bool InitMultipleOverride() => true; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + if (particles.RandomFloat(0.0f, 1.0f) < Percent) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_YAW, p) += 3.1415927f; + } + } +} + +public sealed class C_INIT_RandomColor : ParticleOperatorInstance +{ + public Color ColorMin; + public Color ColorMax; + public Color TintMin; + public Color TintMax; + public float TintPerc; + public float UpdateThreshold; + public int TintCP; + public int FieldOutput; + public int TintBlendMode; + public float LightAmplification; + Vector3 NormColorMin; + Vector3 NormColorMax; + + public static readonly ParticleOperatorDefinition Definition = new("Color Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Color("color1", "255 255 255 255", (o, v) => o.ColorMin = v) + .Color("color2", "255 255 255 255", (o, v) => o.ColorMax = v) + .Float("tint_perc", "0.0", (o, v) => o.TintPerc = v) + .Int("tint control point", "0", (o, v) => o.TintCP = v) + .Color("tint clamp min", "0 0 0 0", (o, v) => o.TintMin = v) + .Color("tint clamp max", "255 255 255 255", (o, v) => o.TintMax = v) + .Float("tint update movement threshold", "32", (o, v) => o.UpdateThreshold = v) + .Int("tint blend mode", "0", (o, v) => o.TintBlendMode = v) + .Float("light amplification amount", "1", (o, v) => o.LightAmplification = v) + .Int("output field", "6", (o, v) => o.FieldOutput = v)); + + static ref Vector3 LastPosition(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << (TintCP & 63); + public override int GetRequiredContextBytes() => 12; + + public override void InitializeContextData(ParticleCollection particles, Span context) => LastPosition(context) = Vector3.Zero; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + NormColorMin = new Vector3(ColorMin.R, ColorMin.G, ColorMin.B) * ParticleInitUtil.INV_255; + NormColorMax = new Vector3(ColorMax.R, ColorMax.G, ColorMax.B) * ParticleInitUtil.INV_255; + FieldOutput = Math.Clamp(FieldOutput, 0, MAX_PARTICLE_ATTRIBUTES_GMOD - 1); + } + + const int MAX_PARTICLE_ATTRIBUTES_GMOD = 22; + + Vector3 ComputeTint(ParticleCollection particles, Span context) { + Color tint; + ParticleCollection? parent = particles.Parent; + if (parent != null && parent.LocalLightingCP == TintCP) + tint = parent.LocalLighting; + else { + ref Vector3 lastPosition = ref LastPosition(context); + particles.GetControlPointAtTime(TintCP, particles.CurTime, out Vector3 origin); + if (Vector3.Distance(lastPosition, origin) >= UpdateThreshold || particles.LocalLightingCP == -1) { + particles.Mgr!.Query().GetLightingAtPoint(origin, out tint); + particles.LocalLighting = tint; + particles.LocalLightingCP = TintCP; + lastPosition = origin; + } + else + tint = particles.LocalLighting; + } + return ParticleInitUtil.ClampedTint(tint, TintMin, TintMax, LightAmplification); + } + + Vector3 ColorFor(float rand, bool doTint, in Vector3 tint) + => doTint ? ParticleInitUtil.BlendTint(NormColorMin, NormColorMax, rand, tint, TintPerc, TintBlendMode) : (NormColorMax - NormColorMin) * rand + NormColorMin; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + bool doTint = TintPerc != 0.0f; + Vector3 tint = doTint ? ComputeTint(particles, context) : default; + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.SetVectorAttribute(FieldOutput, p, ColorFor(particles.RandomFloat(0.0f, 1.0f), doTint, tint)); + } + + public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) { + bool doTint = TintPerc != 0.0f; + Vector3 tint = doTint ? ComputeTint(particles, context) : default; + int randContext = RandSIMD.GetContext(); + for (int b = 0; b < numBlocks; b++) { + Vector128 rand = RandSIMD.Next(randContext); + for (int lane = 0; lane < 4; lane++) + particles.SetVectorAttribute(FieldOutput, (startBlock + b) * 4 + lane, ColorFor(rand[lane], doTint, tint)); + } + RandSIMD.ReleaseContext(randContext); + } +} + +public sealed class C_INIT_ColorLitPerParticle : ParticleOperatorInstance +{ + public Color ColorMin; + public Color ColorMax; + public Color TintMin; + public Color TintMax; + public float TintPerc; + public int TintBlendMode; + public float LightAmplification; + Vector3 NormColorMin; + Vector3 NormColorMax; + + public static readonly ParticleOperatorDefinition Definition = new("Color Lit Per Particle", ParticleOperatorId.PiTintRGB, false, + ParticleOperatorUnpack.Begin() + .Color("color1", "255 255 255 255", (o, v) => o.ColorMin = v) + .Color("color2", "255 255 255 255", (o, v) => o.ColorMax = v) + .Float("light bias", "0.0", (o, v) => o.TintPerc = v) + .Color("tint clamp min", "0 0 0 0", (o, v) => o.TintMin = v) + .Color("tint clamp max", "255 255 255 255", (o, v) => o.TintMax = v) + .Int("tint blend mode", "0", (o, v) => o.TintBlendMode = v) + .Float("light amplification amount", "1", (o, v) => o.LightAmplification = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_TINT_RGB_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + NormColorMin = new Vector3(ColorMin.R, ColorMin.G, ColorMin.B) * ParticleInitUtil.INV_255; + NormColorMax = new Vector3(ColorMax.R, ColorMax.G, ColorMax.B) * ParticleInitUtil.INV_255; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + particles.Mgr!.Query().GetLightingAtPoint(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), out Color light); + Vector3 tint = ParticleInitUtil.ClampedTint(light, TintMin, TintMax, LightAmplification); + float rand = particles.RandomFloat(0.0f, 1.0f); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_TINT_RGB, p, ParticleInitUtil.BlendTint(NormColorMin, NormColorMax, rand, tint, TintPerc, TintBlendMode)); + } + } +} + +public sealed class C_INIT_RandomSequence : ParticleOperatorInstance +{ + const int MAX_SEQUENCE_TABLE = 64; + + public int SequenceMin; + public int SequenceMax; + public bool Shuffle; + public bool Linear; + + public static readonly ParticleOperatorDefinition Definition = new("Sequence Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("sequence_min", "0", (o, v) => o.SequenceMin = v) + .Int("sequence_max", "0", (o, v) => o.SequenceMax = v) + .Bool("shuffle", "0", (o, v) => o.Shuffle = v) + .Bool("linear", "0", (o, v) => o.Linear = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK; + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => (MAX_SEQUENCE_TABLE + 1) * sizeof(int); + + static int GetEntry(Span table, int index) => (uint)index < MAX_SEQUENCE_TABLE ? table[index + 1] : index; + + static void SetEntry(Span table, int index, int value) { + if ((uint)index < MAX_SEQUENCE_TABLE) + table[index + 1] = value; + } + + void ShuffleTable(ParticleCollection particles, Span table) { + for (int j = SequenceMax; SequenceMin < j; j--) { + int swap = (int)((j - SequenceMin + 1) * particles.RandomFloat(0.0f, 1.0f)) + SequenceMin; + int value = GetEntry(table, j); + SetEntry(table, j, GetEntry(table, swap)); + SetEntry(table, swap, value); + } + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + if (!Shuffle && !Linear) + return; + + Span table = MemoryMarshal.Cast(context); + table[0] = SequenceMin; + for (int i = SequenceMin; i <= SequenceMax; i++) + SetEntry(table, i, i); + if (Shuffle && SequenceMin < SequenceMax) + ShuffleTable(particles, table); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + if (!Shuffle && !Linear) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p) = particles.RandomInt(SequenceMin, SequenceMax); + return; + } + + Span table = MemoryMarshal.Cast(context); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + if (SequenceMax < table[0]) { + if (Shuffle && SequenceMin < SequenceMax) + ShuffleTable(particles, table); + table[0] = SequenceMin; + } + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p) = GetEntry(table, table[0]); + table[0]++; + } + } +} + +public sealed class C_INIT_RandomSecondSequence : ParticleOperatorInstance +{ + public int SequenceMin; + public int SequenceMax; + + public static readonly ParticleOperatorDefinition Definition = new("Sequence Two Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("sequence_min", "0", (o, v) => o.SequenceMin = v) + .Int("sequence_max", "0", (o, v) => o.SequenceMax = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1_MASK; + public override uint GetReadAttributes() => 0; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1, p) = particles.RandomInt(SequenceMin, SequenceMax); + } +} + +public sealed class C_INIT_SequenceLifeTime : ParticleOperatorInstance +{ + public float FramesPerSecond; + + public static readonly ParticleOperatorDefinition Definition = new("Lifetime From Sequence", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Frames Per Second", "30", (o, v) => o.FramesPerSecond = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK; + public override bool InitMultipleOverride() => true; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + Sheet? sheet = particles.Sheet; + if (FramesPerSecond == 0.0f || sheet == null) + return; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + int sequence = (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p); + float frameSpan = (uint)sequence < Sheet.MAX_SEQUENCES ? sheet.FrameSpan[sequence] : 0.0f; + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = frameSpan == 0.0f ? 1.0f : frameSpan / FramesPerSecond; + } + } +} + +public sealed class C_INIT_CreateWithinSphere : ParticleOperatorInstance +{ + public float RadiusMin; + public float RadiusMax; + public Vector3 DistanceBias; + public Vector3 DistanceBiasAbs; + public int ControlPointNumber; + public int ScaleCP; + public float SpeedMin; + public float SpeedMax; + public float SpeedRandExp; + public bool LocalCoords; + public bool UseHighestEndCP; + public float EndCPGrowthTime; + public Vector3 LocalCoordinateSystemSpeedMin; + public Vector3 LocalCoordinateSystemSpeedMax; + public int CreateInModel; + bool HasDistanceBias; + bool HasDistanceBiasAbs; + + public static readonly ParticleOperatorDefinition Definition = new("Position Within Sphere Random", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Float("distance_min", "0", (o, v) => o.RadiusMin = v) + .Float("distance_max", "0", (o, v) => o.RadiusMax = v) + .Vector3("distance_bias", "1 1 1", (o, v) => o.DistanceBias = v) + .Vector3("distance_bias_absolute_value", "0 0 0", (o, v) => o.DistanceBiasAbs = v) + .Bool("bias in local system", "0", (o, v) => o.LocalCoords = v) + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("speed_min", "0", (o, v) => o.SpeedMin = v) + .Float("speed_max", "0", (o, v) => o.SpeedMax = v) + .Float("speed_random_exponent", "1", (o, v) => o.SpeedRandExp = v) + .Vector3("speed_in_local_coordinate_system_min", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMin = v) + .Vector3("speed_in_local_coordinate_system_max", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMax = v) + .Int("create in model", "0", (o, v) => o.CreateInModel = v) + .Bool("randomly distribute to highest supplied Control Point", "0", (o, v) => o.UseHighestEndCP = v) + .Float("randomly distribution growth time", "0", (o, v) => o.EndCPGrowthTime = v) + .Int("scale cp (distance/speed/local speed)", "-1", (o, v) => o.ScaleCP = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override ulong GetReadControlPointMask() { + ulong mask = 1UL << (ControlPointNumber & 63); + if (UseHighestEndCP) + return ~(mask - 1); + if (ScaleCP != -1) + mask |= 1UL << (ScaleCP & 63); + return mask; + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + ScaleCP = Math.Clamp(ScaleCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + HasDistanceBias = DistanceBias.X != 1.0f || DistanceBias.Y != 1.0f || DistanceBias.Z != 1.0f; + HasDistanceBiasAbs = DistanceBiasAbs.X != 0.0f || DistanceBiasAbs.Y != 0.0f || DistanceBiasAbs.Z != 0.0f; + } + + int PickControlPoint(ParticleCollection particles, List? validCPs) { + if (validCPs == null || validCPs.Count == 0) + return ControlPointNumber; + + float growth = 1.0f; + if (EndCPGrowthTime != 0.0f) + growth = Math.Min(particles.CurTime, EndCPGrowthTime) / EndCPGrowthTime; + + if (growth >= 1.0f) + return validCPs[(int)(validCPs.Count * particles.RandomFloat(0.0f, 1.0f))]; + + int highest = particles.GetHighestControlPoint(); + int low = ControlPointNumber; + int high = highest < ControlPointNumber ? ControlPointNumber : highest; + int query = particles.RandomQueryCount++; + growth = Math.Clamp(growth, 0.0f, 1.0f); + int currentHigh = (int)MathF.Floor(growth * (high - low) + low); + int target = (int)((currentHigh - low + 1) * particles.RandomFloat(query, 0.0f, 1.0f)) + low; + int found = validCPs.IndexOf(target); + if (found >= 0) + return validCPs[found]; + + particles.RandomQueryCount = query + 2; + return validCPs[(int)(validCPs.Count * particles.RandomFloat(query + 1, 0.0f, 1.0f))]; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + Vector3 scale = Vector3.One; + if (ScaleCP >= 0) + scale = particles.ControlPoints[ScaleCP].Position; + + List? validCPs = null; + if (UseHighestEndCP) { + validCPs = []; + for (int i = ControlPointNumber; i <= particles.GetHighestControlPoint(); i++) { + if (particles.ControlPoints[i].Position != ParticleInitUtil.Vec3Invalid) + validCPs.Add(i); + } + } + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float time = Math.Max(particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), particles.CurTime - particles.Dt); + int currentControlPoint = UseHighestEndCP ? PickControlPoint(particles, validCPs) : ControlPointNumber; + + Vector3 randomPosition; + Vector3 randomDirection; + int tries = 0; + while (true) { + float length = particles.RandomVectorInUnitSphere(particles.RandomQueryCount, out randomDirection); + particles.RandomQueryCount += 3; + + if (HasDistanceBiasAbs) + randomDirection = ParticleInitUtil.Abs(randomDirection, DistanceBiasAbs); + randomDirection *= DistanceBias; + MathLib.VectorNormalize(ref randomDirection); + + randomPosition = randomDirection * (((RadiusMax - RadiusMin) * length + RadiusMin) * scale.X); + + if (!HasDistanceBias || !LocalCoords) { + particles.GetControlPointAtTime(currentControlPoint, time, out Vector3 controlPoint); + randomPosition += controlPoint; + } + else { + particles.GetControlPointTransformAtTime(currentControlPoint, time, out Matrix3x4 transform); + MathLib.VectorTransform(in randomPosition, in transform, out randomPosition); + } + + if (CreateInModel == 0) + break; + if (particles.Mgr!.Query().MovePointInsideControllingObject(particles, particles.ControlPoints[currentControlPoint].Object, ref randomPosition)) + break; + if (++tries >= 10) + break; + } + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, randomPosition); + + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) == 0) + continue; + + Vector3 offset = Vector3.Zero; + if (SpeedMax > 0.0f) + offset = -randomDirection * (particles.RandomFloatExp(SpeedMin, SpeedMax, SpeedRandExp) * scale.Y); + + float localX = particles.RandomFloat(LocalCoordinateSystemSpeedMin.X, LocalCoordinateSystemSpeedMax.X); + float localY = particles.RandomFloat(LocalCoordinateSystemSpeedMin.Y, LocalCoordinateSystemSpeedMax.Y); + float localZ = particles.RandomFloat(LocalCoordinateSystemSpeedMin.Z, LocalCoordinateSystemSpeedMax.Z); + + ref readonly ParticleControlPoint cp = ref particles.ControlPoint(currentControlPoint); + offset -= cp.ForwardVector * (localX * scale.Z); + offset -= cp.RightVector * (localY * scale.Z); + offset -= cp.UpVector * (localZ * scale.Z); + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, randomPosition + offset * particles.PreviousDt); + } + } +} + +public sealed class C_INIT_CreateWithinBox : ParticleOperatorInstance +{ + public Vector3 Min; + public Vector3 Max; + public int ControlPointNumber; + public bool LocalSpace; + + public static readonly ParticleOperatorDefinition Definition = new("Position Within Box Random", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Vector3("min", "0 0 0", (o, v) => o.Min = v) + .Vector3("max", "0 0 0", (o, v) => o.Max = v) + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Bool("use local space", "0", (o, v) => o.LocalSpace = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int controlPoint = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + particles.RandomVector(Min, Max, out Vector3 position); + + if (!LocalSpace) { + particles.GetControlPointAtTime(controlPoint, creationTime, out Vector3 cpPosition); + position += cpPosition; + } + else { + particles.GetControlPointTransformAtTime(controlPoint, creationTime, out Matrix3x4 transform); + MathLib.VectorRotate(in position, in transform, out position); + } + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, position); + } + } +} + +public sealed class C_INIT_CreateOnModel : ParticleOperatorInstance +{ + const int MAX_POINTS_PER_BATCH = 100; + + public int ControlPointNumber; + public int ForceInModel; + public int DesiredHitbox; + public float HitBoxScale; + public Vector3 DirectionBias; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Position on Model Random", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Int("force to be inside model", "0", (o, v) => o.ForceInModel = v) + .Float("model hitbox scale", "1.0", (o, v) => o.HitBoxScale = v) + .Vector3("direction bias", "0 0 0", (o, v) => o.DirectionBias = v) + .Int("desired hitbox", "-1", (o, v) => o.DesiredHitbox = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v)); + + public override uint GetWrittenAttributes() => 0xc105; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << (ControlPointNumber & 63); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int controlPoint = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + particles.UpdateHitBoxInfo(controlPoint, HitboxSetName); + + Span points = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span relativeCoords = stackalloc Vector3[MAX_POINTS_PER_BATCH]; + Span hitboxIndices = stackalloc int[MAX_POINTS_PER_BATCH]; + int particle = firstParticle; + while (numParticles > 0) { + int count = Math.Min(numParticles, MAX_POINTS_PER_BATCH); + points[..count].Clear(); + relativeCoords[..count].Clear(); + hitboxIndices[..count].Clear(); + particles.Mgr!.Query().GetRandomPointsOnControllingObjectHitBox(particles, controlPoint, count, HitBoxScale, ForceInModel, points, DirectionBias, relativeCoords, hitboxIndices, DesiredHitbox, HitboxSetName); + + for (int i = 0; i < count; i++, particle++) { + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, particle, points[i]); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, particle, points[i]); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, particle, relativeCoords[i]); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK) != 0) + particles.GetIntAttributeRefForWrite(PARTICLE_ATTRIBUTE_HITBOX_INDEX, particle) = hitboxIndices[i]; + } + numParticles -= count; + } + } +} + +public sealed class C_INIT_PositionOffset : ParticleOperatorInstance +{ + public Vector3 OffsetMin; + public Vector3 OffsetMax; + public int ControlPointNumber; + public bool LocalCoords; + public bool Proportional; + + public static readonly ParticleOperatorDefinition Definition = new("Position Modify Offset Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Vector3("offset min", "0 0 0", (o, v) => o.OffsetMin = v) + .Vector3("offset max", "0 0 0", (o, v) => o.OffsetMax = v) + .Bool("offset in local space 0/1", "0", (o, v) => o.LocalCoords = v) + .Bool("offset proportional to radius 0/1", "0", (o, v) => o.Proportional = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 offset; + if (!Proportional) + particles.RandomVector(OffsetMin, OffsetMax, out offset); + else { + float radius = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p); + particles.RandomVector(OffsetMin * radius, OffsetMax * radius, out offset); + } + + if (LocalCoords) { + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Matrix3x4 transform); + MathLib.VectorRotate(in offset, in transform, out offset); + } + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + offset); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + offset); + } + } +} + +public sealed class C_INIT_PositionWarp : ParticleOperatorInstance +{ + struct Context + { + public float StartTime; + public int StartCount; + public int ParticleCount; + } + + public Vector3 WarpMin; + public Vector3 WarpMax; + public int ControlPointNumber; + public float WarpTime; + public float WarpStartTime; + public bool InvertWarp; + public bool UseCount; + + public static readonly ParticleOperatorDefinition Definition = new("Position Modify Warp Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Vector3("warp min", "1 1 1", (o, v) => o.WarpMin = v) + .Vector3("warp max", "1 1 1", (o, v) => o.WarpMax = v) + .Float("warp transition time (treats min/max as start/end sizes)", "0", (o, v) => o.WarpTime = v) + .Float("warp transition start time", "0", (o, v) => o.WarpStartTime = v) + .Bool("reverse warp (0/1)", "0", (o, v) => o.InvertWarp = v) + .Bool("use particle count instead of time", "0", (o, v) => o.UseCount = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override bool InitMultipleOverride() => true; + public override int GetRequiredContextBytes() => 12; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.StartTime = particles.CurTime; + ctx.StartCount = 0; + ctx.ParticleCount = 0; + } + + public override void Restart(ParticleCollection particles, Span context) => InitializeContextData(particles, context); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref Context ctx = ref Ctx(context); + Vector3 warpEnd = InvertWarp ? WarpMin : WarpMax; + Vector3 warpStart = InvertWarp ? WarpMax : WarpMin; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + Vector3 warp; + if (WarpTime == 0.0f) + particles.RandomVector(WarpMin, WarpMax, out warp); + else { + float t; + if (!UseCount) { + float start = WarpStartTime + ctx.StartTime; + t = ParticleInitUtil.RemapClamped(creationTime, start, start + WarpTime, 0.0f, 1.0f); + } + else { + float start = WarpStartTime + ctx.StartCount; + t = ParticleInitUtil.RemapClamped(ctx.ParticleCount, start, start + WarpTime, 0.0f, 1.0f); + ctx.ParticleCount++; + } + warp = (warpEnd - warpStart) * t + warpStart; + } + + particles.GetControlPointTransformAtTime(ControlPointNumber, creationTime, out Matrix3x4 transform); + + MathLib.VectorITransform(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), in transform, out Vector3 local); + MathLib.VectorTransform(local * warp, in transform, out Vector3 position); + MathLib.VectorITransform(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p), in transform, out Vector3 prevLocal); + MathLib.VectorTransform(prevLocal * warp, in transform, out Vector3 prevPosition); + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prevPosition); + } + } +} + +public sealed class C_INIT_CreateSequentialPath : ParticleOperatorInstance +{ + struct Context + { + public int Unused; + public float PathPosition; + public float StepDirection; + public float CPPairPosition; + public float Step; + public float CPStep; + } + + public float MaxDistance; + public float NumToAssign; + public bool Loop; + public bool CPPairs; + public bool SaveOffset; + public PathParameters PathParams; + + public static readonly ParticleOperatorDefinition Definition = new("Position Along Path Sequential", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Float("maximum distance", "0", (o, v) => o.MaxDistance = v) + .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v) + .Int("start control point number", "0", (o, v) => o.PathParams.StartControlPointNumber = v) + .Int("end control point number", "0", (o, v) => o.PathParams.EndControlPointNumber = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v) + .Float("particles to map from start to end", "100", (o, v) => o.NumToAssign = v) + .Bool("restart behavior (0 = bounce, 1 = loop )", "1", (o, v) => o.Loop = v) + .Bool("Use sequential CP pairs between start and end point", "0", (o, v) => o.CPPairs = v) + .Bool("Save Offset", "0", (o, v) => o.SaveOffset = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override int GetRequiredContextBytes() => 24; + + public override ulong GetReadControlPointMask() { + ulong startMask = (1UL << PathParams.StartControlPointNumber) - 1; + if (CPPairs) + return ~startMask; + return ~startMask & ((1UL << ((PathParams.EndControlPointNumber + 1) & 63)) - 1); + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + PathParams.StartControlPointNumber = Math.Clamp(PathParams.StartControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + PathParams.EndControlPointNumber = Math.Clamp(PathParams.EndControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.PathPosition = 0.0f; + ctx.Step = NumToAssign <= 1.0f ? 0.0f : 1.0f / (NumToAssign - 1.0f); + ctx.StepDirection = -1.0f; + if (!CPPairs) + return; + + ctx.CPPairPosition = PathParams.StartControlPointNumber; + int pairs = PathParams.EndControlPointNumber - PathParams.StartControlPointNumber; + if (pairs > 1 && NumToAssign > 1.0f) { + ctx.Step = pairs * ctx.Step; + ctx.CPStep = ctx.Step; + } + else + ctx.CPStep = 0.0f; + } + + public override void Restart(ParticleCollection particles, Span context) => InitializeContextData(particles, context); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + ref Context ctx = ref Ctx(context); + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + PathParameters path = PathParams; + if (CPPairs) { + float span = PathParams.EndControlPointNumber - PathParams.StartControlPointNumber; + if (span < ctx.CPPairPosition || ctx.CPPairPosition < PathParams.StartControlPointNumber) { + if (!Loop) { + ctx.CPStep = -ctx.CPStep; + ctx.Step = -ctx.Step; + ctx.StepDirection = -ctx.StepDirection; + ctx.CPPairPosition = ctx.CPStep + ctx.CPStep + ctx.CPPairPosition; + ctx.PathPosition = ctx.Step + ctx.Step + ctx.PathPosition; + } + else + ctx.CPPairPosition -= span; + } + path.StartControlPointNumber = (int)ctx.CPPairPosition; + path.EndControlPointNumber = (int)ctx.CPPairPosition + 1; + } + + if (ctx.PathPosition > 1.0000001f || ctx.PathPosition < 0.0f) { + if (!Loop && !CPPairs) { + ctx.Step = -ctx.Step; + ctx.StepDirection = -ctx.StepDirection; + ctx.PathPosition = ctx.Step + ctx.Step + ctx.PathPosition; + } + else + ctx.PathPosition += ctx.StepDirection; + } + + float t = ctx.PathPosition; + particles.CalculatePathValues(in path, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 startPnt, out Vector3 midPnt, out Vector3 endPnt); + + int query = particles.RandomQueryCount; + particles.RandomQueryCount += 3; + Vector3 randomOffset = new( + particles.RandomFloat(query, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 1, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 2, -MaxDistance, MaxDistance)); + + Vector3 startMid = (midPnt - startPnt) * t + startPnt; + Vector3 midEnd = (endPnt - midPnt) * t + midPnt; + Vector3 position = (midEnd - startMid) * t + startMid + randomOffset; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, position); + if (SaveOffset) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p, new Vector3(t, path.StartControlPointNumber, path.EndControlPointNumber)); + + ctx.PathPosition += ctx.Step; + ctx.CPPairPosition += ctx.CPStep; + } + } +} + +public sealed class C_INIT_CreateAlongPath : ParticleOperatorInstance +{ + public float MaxDistance; + public PathParameters PathParams; + public bool UseRandomCPPairs; + + public static readonly ParticleOperatorDefinition Definition = new("Position Along Path Random", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Float("maximum distance", "0", (o, v) => o.MaxDistance = v) + .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v) + .Int("start control point number", "0", (o, v) => o.PathParams.StartControlPointNumber = v) + .Int("end control point number", "0", (o, v) => o.PathParams.EndControlPointNumber = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v) + .Bool("randomly select sequential CP pairs between start and end points", "0", (o, v) => o.UseRandomCPPairs = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override ulong GetReadControlPointMask() + => ((1UL << ((PathParams.EndControlPointNumber + 1) & 63)) - 1) & ~((1UL << (PathParams.StartControlPointNumber & 63)) - 1); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + PathParams.StartControlPointNumber = Math.Clamp(PathParams.StartControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + PathParams.EndControlPointNumber = Math.Clamp(PathParams.EndControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + PathParameters path = PathParams; + if (UseRandomCPPairs) { + int low = path.StartControlPointNumber + 1; + int end = (int)((path.EndControlPointNumber - low + 1) * particles.RandomFloat(0.0f, 1.0f)) + low; + path.StartControlPointNumber = end - 1; + path.EndControlPointNumber = end; + } + + particles.CalculatePathValues(in path, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 startPnt, out Vector3 midPnt, out Vector3 endPnt); + + int query = particles.RandomQueryCount; + particles.RandomQueryCount += 4; + float t = particles.RandomFloat(query, 0.0f, 1.0f); + Vector3 randomOffset = new( + particles.RandomFloat(query + 1, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 2, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 3, -MaxDistance, MaxDistance)); + + Vector3 startMid = (midPnt - startPnt) * t + startPnt; + Vector3 midEnd = (endPnt - midPnt) * t + midPnt; + Vector3 position = (midEnd - startMid) * t + startMid + randomOffset; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, position); + } + } +} + +public sealed class C_INIT_InitialRepulsionVelocity : ParticleOperatorInstance +{ + static readonly Vector3[] TraceDirections = [new(1, 0, 0), new(-1, 0, 0), new(0, 1, 0), new(0, -1, 0), new(0, 0, 1), new(0, 0, -1)]; + + public string CollisionGroupName = "NONE"; + public int CollisionGroupNumber; + public Vector3 MinVelocity; + public Vector3 MaxVelocity; + public int ControlPointNumber; + public bool PerParticle; + public bool Translate; + public bool Proportional; + public float TraceLength; + public bool PerParticleTR; + public bool InheritFromParent; + public int ChildCP; + public int ChildGroupID; + + public static readonly ParticleOperatorDefinition Definition = new("Velocity Repulse from World", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("minimum velocity", "0 0 0", (o, v) => o.MinVelocity = v) + .Vector3("maximum velocity", "1 1 1", (o, v) => o.MaxVelocity = v) + .String("collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Bool("Per Particle World Collision Tests", "0", (o, v) => o.PerParticle = v) + .Bool("Use radius for Per Particle Trace Length", "0", (o, v) => o.PerParticleTR = v) + .Bool("Offset instead of accelerate", "0", (o, v) => o.Translate = v) + .Bool("Offset proportional to radius 0/1", "0", (o, v) => o.Proportional = v) + .Float("Trace Length", "64.0", (o, v) => o.TraceLength = v) + .Bool("Inherit from Parent", "0", (o, v) => o.InheritFromParent = v) + .Int("control points to broadcast to children (n + 1)", "-1", (o, v) => o.ChildCP = v) + .Int("Child Group ID to affect", "0", (o, v) => o.ChildGroupID = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override bool InitMultipleOverride() => true; + + public override ulong GetReadControlPointMask() { + if (PerParticle) + return 0; + ulong mask = 1UL << (ControlPointNumber & 63); + if (InheritFromParent) + mask |= 1UL << ((ControlPointNumber + 1) & 63); + return mask; + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + float TraceRepulsion(IParticleSystemQuery query, in Vector3 origin, float traceLength, out Vector3 direction) { + float total = 0.0f; + direction = Vector3.Zero; + for (int i = 0; i < TraceDirections.Length; i++) { + GameTrace trace = default; + query.TraceLine(origin, origin + TraceDirections[i] * traceLength, (Mask)Contents.Solid, null, CollisionGroupNumber, ref trace); + float blocked = 1.0f - trace.Fraction; + total += blocked; + direction -= TraceDirections[i] * blocked; + } + + if (direction == Vector3.Zero) { + direction = new Vector3(0, 0, 1); + total = 0.0f; + } + MathLib.VectorNormalize(ref direction); + return total; + } + + void BroadcastToChildren(ParticleCollection particles, in Vector3 direction, float total) { + for (ParticleCollection? child = particles.Children; child != null; child = child.Next) { + if (child.GetGroupID() != ChildGroupID) + continue; + if ((uint)ChildCP < MAX_PARTICLE_CONTROL_POINTS) + child.SetControlPoint(ChildCP, direction); + if ((uint)(ChildCP + 1) < MAX_PARTICLE_CONTROL_POINTS) + child.SetControlPoint(ChildCP + 1, new Vector3(total, 0, 0)); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + IParticleSystemQuery query = particles.Mgr!.Query(); + + if (PerParticle) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 origin = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + float radius = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p); + float total = TraceRepulsion(query, origin, PerParticleTR ? radius : TraceLength, out Vector3 direction); + Vector3 velocity = ((MaxVelocity - MinVelocity) * total + MinVelocity) * direction * total; + if (Proportional) + velocity *= radius; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, origin + velocity); + if (Translate) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + velocity); + } + return; + } + + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, firstParticle); + Vector3 repulsion; + if (!InheritFromParent) { + particles.GetControlPointAtTime(ControlPointNumber, creationTime, out Vector3 origin); + float total = TraceRepulsion(query, origin, TraceLength, out Vector3 direction); + direction *= total; + repulsion = ((MaxVelocity - MinVelocity) * total + MinVelocity) * direction; + if (ChildCP != -1) + BroadcastToChildren(particles, direction, total); + } + else { + particles.GetControlPointAtTime(ControlPointNumber, creationTime, out Vector3 direction); + particles.GetControlPointAtTime(ControlPointNumber + 1, creationTime, out Vector3 amount); + repulsion = ((MaxVelocity - MinVelocity) * amount.X + MinVelocity) * direction; + } + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + if (Proportional) + repulsion *= particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + repulsion); + if (Translate) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + repulsion); + } + } +} + +public sealed class C_INIT_CreateInHierarchy : ParticleOperatorInstance +{ + public float MaxDistance; + public float GrowthTime; + public PathParameters PathParams; + public int DesiredEndPoint; + public int DesiredMidPoint; + public bool UseHighestEndCP; + public Vector3 DistanceBias; + public Vector3 DistanceBiasAbs; + bool HasDistanceBias; + bool HasDistanceBiasAbs; + + public static readonly ParticleOperatorDefinition Definition = new("Position In CP Hierarchy", ParticleOperatorId.PiPosition, false, + ParticleOperatorUnpack.Begin() + .Float("maximum distance", "0", (o, v) => o.MaxDistance = v) + .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v) + .Int("start control point number", "0", (o, v) => o.DesiredMidPoint = v) + .Int("end control point number", "1", (o, v) => o.DesiredEndPoint = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v) + .Float("growth time", "0.0", (o, v) => o.GrowthTime = v) + .Bool("use highest supplied end point", "0", (o, v) => o.UseHighestEndCP = v) + .Vector3("distance_bias", "1 1 1", (o, v) => o.DistanceBias = v) + .Vector3("distance_bias_absolute_value", "0 0 0", (o, v) => o.DistanceBiasAbs = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override ulong GetReadControlPointMask() { + ulong startMask = (1UL << (DesiredMidPoint & 63)) - 1; + if (UseHighestEndCP) + return ~startMask; + return ~startMask & ((1UL << ((DesiredEndPoint + 1) & 63)) - 1); + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + HasDistanceBias = DistanceBias.X != 1.0f || DistanceBias.Y != 1.0f || DistanceBias.Z != 1.0f; + HasDistanceBiasAbs = DistanceBiasAbs.X != 0.0f || DistanceBiasAbs.Y != 0.0f || DistanceBiasAbs.Z != 0.0f; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + int endPoint = UseHighestEndCP ? particles.GetHighestControlPoint() : DesiredEndPoint; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + int cp; + float growth; + if (GrowthTime < particles.CurTime || endPoint < 1) { + int low = Math.Min(DesiredMidPoint + 1, endPoint); + growth = 1.0f; + cp = (int)((endPoint - low + 1) * particles.RandomFloat(0.0f, 1.0f)) + low; + } + else { + int firstChild = DesiredMidPoint + 1; + float low = Math.Min(firstChild, endPoint); + float high; + if (GrowthTime == 0.0f) + high = GrowthTime <= creationTime ? endPoint : low; + else + high = Math.Clamp(creationTime / GrowthTime, 0.0f, 1.0f) * (endPoint - low) + low; + + float rand = particles.RandomFloat(0.0f, 1.0f); + float lowest = high <= firstChild ? high : firstChild; + growth = high / endPoint; + cp = (int)(((int)high - (int)lowest + 1) * rand) + (int)lowest; + if (GrowthTime == 0.0f) { + if (creationTime < GrowthTime) + growth = 0.0f; + } + else + growth = Math.Clamp(creationTime / GrowthTime, 0.0f, 1.0f) * growth; + } + + PathParameters path = PathParams; + path.StartControlPointNumber = particles.ControlPoints[cp].Parent; + path.EndControlPointNumber = cp; + particles.CalculatePathValues(in path, creationTime, out Vector3 startPnt, out Vector3 midPnt, out Vector3 endPnt); + + int query = particles.RandomQueryCount; + particles.RandomQueryCount += 4; + float t = particles.RandomFloat(query, 0.0f, 1.0f); + Vector3 randomOffset = new( + particles.RandomFloat(query + 1, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 2, -MaxDistance, MaxDistance), + particles.RandomFloat(query + 3, -MaxDistance, MaxDistance)); + if (HasDistanceBiasAbs) + randomOffset = ParticleInitUtil.Abs(randomOffset, DistanceBiasAbs); + + Vector3 startMid = (midPnt - startPnt) * t + startPnt; + Vector3 midEnd = (endPnt * growth - midPnt) * t + midPnt; + Vector3 position = (midEnd - startMid) * t + startMid + randomOffset * DistanceBias; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) != 0) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, position); + } + } +} + +public sealed class C_INIT_InitialVelocityNoise : ParticleOperatorInstance +{ + public Vector3 AbsVal; + public Vector3 AbsValInv; + public Vector3 OffsetLoc; + public float Offset; + public Vector3 OutputMin; + public Vector3 OutputMax; + public float NoiseScale; + public float NoiseScaleLoc; + public int ControlPointNumber; + public bool LocalSpace; + + public static readonly ParticleOperatorDefinition Definition = new("Velocity Noise", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point Number", "0", (o, v) => o.ControlPointNumber = v) + .Float("Time Noise Coordinate Scale", "1", (o, v) => o.NoiseScale = v) + .Float("Spatial Noise Coordinate Scale", "0.01", (o, v) => o.NoiseScaleLoc = v) + .Float("Time Coordinate Offset", "0", (o, v) => o.Offset = v) + .Vector3("Spatial Coordinate Offset", "0 0 0", (o, v) => o.OffsetLoc = v) + .Vector3("Absolute Value", "0 0 0", (o, v) => o.AbsVal = v) + .Vector3("Invert Abs Value", "0 0 0", (o, v) => o.AbsValInv = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v) + .Bool("Apply Velocity in Local Space (0/1)", "0", (o, v) => o.LocalSpace = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + + static float Shape(float noise, bool abs, bool invert) { + if (abs) + noise = MathF.Abs(noise); + return invert ? 1.0f - noise : noise; + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + bool anyInvert = AbsValInv.X != 0.0f || AbsValInv.Y != 0.0f || AbsValInv.Z != 0.0f; + Vector3 valueScale = new(AbsVal.X != 0.0f ? 1.0f : 0.5f, AbsVal.Y != 0.0f ? 1.0f : 0.5f, AbsVal.Z != 0.0f ? 1.0f : 0.5f); + Vector3 range = OutputMax - OutputMin; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float coordTime = (Offset + creationTime) * NoiseScale; + Vector3 coord = (position + OffsetLoc) * NoiseScaleLoc + new Vector3(coordTime); + + float noiseX = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z); + float noiseY = NoiseSIMD.Noise(coord.X + 100000.5f, coord.Y + 300000.25f, coord.Z + 9000001.0f); + float noiseZ = NoiseSIMD.Noise(coord.X + 110000.25f, coord.Y + 310000.75f, coord.Z + 9100000.0f); + + Vector3 noise = new( + Shape(noiseX, AbsVal.X != 0.0f, anyInvert && AbsValInv.X != 0.0f), + Shape(noiseY, AbsVal.Y != 0.0f, anyInvert && AbsValInv.Y != 0.0f), + Shape(noiseZ, AbsVal.Z != 0.0f, anyInvert && AbsValInv.Z != 0.0f)); + + Vector3 velocity = (noise * range * valueScale + (Vector3.One - valueScale) * range + OutputMin) * particles.PreviousDt; + + if (LocalSpace) { + particles.GetControlPointTransformAtTime(ControlPointNumber, creationTime, out Matrix3x4 transform); + MathLib.VectorRotate(in velocity, in transform, out velocity); + } + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) - velocity); + } + } +} + +public sealed class C_INIT_InheritVelocity : ParticleOperatorInstance +{ + public int ControlPointNumber; + public float VelocityScale; + + public static readonly ParticleOperatorDefinition Definition = new("Velocity Inherit from Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Float("velocity scale", "1", (o, v) => o.VelocityScale = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + particles.GetControlPointAtPrevTime(ControlPointNumber, out Vector3 prevPosition); + Vector3 delta = (particles.ControlPoints[ControlPointNumber].Position - prevPosition) * VelocityScale; + for (int p = firstParticle; p < firstParticle + numParticles; p++) + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) - delta); + } +} + +public sealed class C_INIT_CreationNoise : ParticleOperatorInstance +{ + public int FieldOutput; + public bool AbsVal; + public bool AbsValInv; + public float Offset; + public float OutputMin; + public float OutputMax; + public float NoiseScale; + public float NoiseScaleLoc; + public Vector3 OffsetLoc; + public float WorldTimeScale; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Noise to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("time noise coordinate scale", "0.1", (o, v) => o.NoiseScale = v) + .Float("spatial noise coordinate scale", "0.001", (o, v) => o.NoiseScaleLoc = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("time coordinate offset", "0", (o, v) => o.Offset = v) + .Vector3("spatial coordinate offset", "0 0 0", (o, v) => o.OffsetLoc = v) + .Bool("absolute value", "0", (o, v) => o.AbsVal = v) + .Bool("invert absolute value", "0", (o, v) => o.AbsValInv = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Float("world time noise coordinate scale", "0", (o, v) => o.WorldTimeScale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => FieldOutput = Math.Clamp(FieldOutput, 0, 21); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + float valueScale = AbsVal ? 1.0f : 0.5f; + float outputMin = OutputMin; + float outputMax = OutputMax; + if ((ParticleInitUtil.ROTATION_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) { + outputMin *= ParticleInitUtil.DEG2RAD; + outputMax *= ParticleInitUtil.DEG2RAD; + } + float range = outputMax - outputMin; + float coordTime = (particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, firstParticle) + Offset) * NoiseScale; + float worldTime = (float)(uint)MSTime * WorldTimeScale; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + Vector3 coord = (particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + OffsetLoc) * NoiseScaleLoc + new Vector3(worldTime + coordTime); + float noise = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z); + if (AbsVal) + noise = MathF.Abs(noise); + if (AbsValInv) + noise = 1.0f - noise; + + float value = noise * range * valueScale + (1.0f - valueScale) * range + outputMin; + if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) + value = Math.Clamp(value, 0.0f, 1.0f); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + } +} + +public sealed class C_INIT_AgeNoise : ParticleOperatorInstance +{ + public bool AbsVal; + public bool AbsValInv; + public float Offset; + public float AgeMin; + public float AgeMax; + public float NoiseScale; + public float NoiseScaleLoc; + public Vector3 OffsetLoc; + + public static readonly ParticleOperatorDefinition Definition = new("Lifetime Pre-Age Noise", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("time noise coordinate scale", "1.0", (o, v) => o.NoiseScale = v) + .Float("spatial noise coordinate scale", "1.0", (o, v) => o.NoiseScaleLoc = v) + .Float("time coordinate offset", "0", (o, v) => o.Offset = v) + .Vector3("spatial coordinate offset", "0 0 0", (o, v) => o.OffsetLoc = v) + .Bool("absolute value", "0", (o, v) => o.AbsVal = v) + .Bool("invert absolute value", "0", (o, v) => o.AbsValInv = v) + .Float("start age minimum", "0", (o, v) => o.AgeMin = v) + .Float("start age maximum", "1", (o, v) => o.AgeMax = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override bool InitMultipleOverride() => true; + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + float valueScale = AbsVal ? 1.0f : 0.5f; + float range = AgeMax - AgeMin; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + ref float creationTime = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float coordTime = (creationTime + Offset) * NoiseScale; + Vector3 coord = (particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + OffsetLoc) * NoiseScaleLoc + new Vector3(coordTime); + float noise = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z); + if (AbsVal) + noise = MathF.Abs(noise); + if (AbsValInv) + noise = 1.0f - noise; + + float age = Math.Clamp(range * valueScale * noise + (1.0f - valueScale) * range + AgeMin, 0.0f, 1.0f); + creationTime -= age * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + } + } +} + +public sealed class C_INIT_RemapScalar : ParticleOperatorInstance +{ + public int FieldInput; + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public float StartTime; + public float EndTime; + public bool ScaleInitialRange; + public bool ActiveRange; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Initial Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input field", "8", (o, v) => o.FieldInput = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("only active within specified input range", "0", (o, v) => o.ActiveRange = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 1u << FieldInput; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldInput = Math.Clamp(FieldInput, 0, 21); + if (FieldOutput < 0 || FieldOutput > 21) { + FieldOutput = Math.Clamp(FieldOutput, 0, 21); + return; + } + if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) { + OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f); + OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float input = ParticleInitUtil.ReadScalar(particles, FieldInput, p); + bool inTime = (StartTime <= creationTime && creationTime < EndTime) || StartTime == -1.0f || EndTime == -1.0f; + if (!inTime || (ActiveRange && (input < InputMin || input > InputMax))) + continue; + + float output = ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin, OutputMax); + if (ScaleInitialRange) + output *= ParticleInitUtil.ReadScalar(particles, FieldOutput, p); + ParticleInitUtil.WriteScalar(particles, FieldOutput, p, output); + } + } +} + +public sealed class C_INIT_RemapCPtoScalar : ParticleOperatorInstance +{ + public int CPInput; + public int FieldOutput; + public int Field; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public float StartTime; + public float EndTime; + public bool ScaleInitialRange; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Control Point to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input control point number", "0", (o, v) => o.CPInput = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("input field 0-2 X/Y/Z", "0", (o, v) => o.Field = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << CPInput; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = Math.Clamp(FieldOutput, 0, 21); + CPInput = Math.Clamp(CPInput, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + Field = Math.Clamp(Field, 0, 2); + if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) { + OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f); + OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + } + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + particles.GetControlPointAtTime(CPInput, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, firstParticle), out Vector3 cpPosition); + float input = cpPosition[Field]; + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + if (!((StartTime <= creationTime && creationTime < EndTime) || StartTime == -1.0f || EndTime == -1.0f)) + continue; + + float output = ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin, OutputMax); + if (ScaleInitialRange) + output *= ParticleInitUtil.ReadScalar(particles, FieldOutput, p); + ParticleInitUtil.WriteScalar(particles, FieldOutput, p, output); + } + } +} + +public sealed class C_INIT_RtEnvCull : ParticleOperatorInstance +{ + public Vector3 TestDir; + public Vector3 TestNormal; + public bool UseVelocity; + public bool CullOnMiss; + public bool LifeAdjust; + public string RtEnvName = "PRECIPITATION"; + int RtEnv; + + public static readonly ParticleOperatorDefinition Definition = new("Cull relative to Ray Trace Environment", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Bool("cull on miss", "0", (o, v) => o.CullOnMiss = v) + .Bool("velocity test adjust lifespan", "0", (o, v) => o.LifeAdjust = v) + .Bool("use velocity for test direction", "0", (o, v) => o.UseVelocity = v) + .Vector3("test direction", "0 0 1", (o, v) => o.TestDir = v) + .Vector3("cull normal", "0 0 0", (o, v) => o.TestNormal = v) + .String("ray trace environment name", "PRECIPITATION", 128, (o, v) => o.RtEnvName = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override bool InitMultipleOverride() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) + => RtEnv = def.Mgr.Query().GetRayTraceEnvironmentFromName(RtEnvName); + + public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { + bool hasNormal = TestNormal != Vector3.Zero; + IParticleSystemQuery query = particles.Mgr!.Query(); + + for (int p = firstParticle; p < firstParticle + numParticles; p++) { + ref float lifetime = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + if (lifetime == -1.0f) + continue; + + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + if (!UseVelocity) { + query.TraceAgainstRayTraceEnv(RtEnv, position, TestDir, 0.0f, float.MaxValue, out ParticleRayTraceResult result); + bool missOrWrongNormal = result.HitId == -1 || (hasNormal && result.SurfaceNormal != TestNormal); + bool cull = missOrWrongNormal ? CullOnMiss : (!CullOnMiss || hasNormal); + if (cull) + lifetime = -1.0f; + continue; + } + + Vector3 delta = position - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + float length = delta.Length(); + Vector3 direction = delta * (1.0f / length); + float speed = length / particles.PreviousDt; + query.TraceAgainstRayTraceEnv(RtEnv, position, direction, 0.0f, lifetime * speed, out ParticleRayTraceResult velocityResult); + + if (velocityResult.HitId == -1 || (hasNormal && velocityResult.SurfaceNormal != TestNormal)) { + if (CullOnMiss) + lifetime = -1.0f; + } + else if (LifeAdjust) + lifetime = Math.Min(lifetime, velocityResult.HitDistance / (speed + 1.1920929e-07f)); + else if (!CullOnMiss) + lifetime = -1.0f; + } + } +} diff --git a/Source.Particles/BuiltinParticleOperators.ControlPoints.cs b/Source.Particles/BuiltinParticleOperators.ControlPoints.cs new file mode 100644 index 00000000..5c9abe93 --- /dev/null +++ b/Source.Particles/BuiltinParticleOperators.ControlPoints.cs @@ -0,0 +1,849 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +internal static class ParticleCPUtil +{ + public static void OrientationFromMovement(ParticleCollection particles, int p, out Vector3 forward, out Vector3 right, out Vector3 up) { + forward = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + MathLib.VectorNormalize(ref forward); + MathLib.VectorVectors(forward, out right, out up); + } + + public static void SetFromParticle(ParticleCollection target, int cp, ParticleCollection source, int p, bool setOrientation) { + target.SetControlPoint(cp, source.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p)); + if (setOrientation) { + OrientationFromMovement(source, p, out Vector3 forward, out Vector3 right, out Vector3 up); + target.SetControlPointOrientation(cp, forward, right, up); + } + } + + public static float LOSDistance(ParticleCollection particles, in Vector3 start, in Vector3 end, float distance, float maxTraceLength, int collisionGroup, float losScale) { + Vector3 endPoint = end; + if (maxTraceLength != -1.0f && maxTraceLength < distance) { + MathLib.VectorNormalize(ref endPoint); + endPoint = endPoint * maxTraceLength + start; + } + GameTrace trace = new(); + particles.Mgr!.Query().TraceLine(start, endPoint, Mask.OpaqueAndNPCs, null, collisionGroup, ref trace); + if (trace.Fraction != 1.0f) + distance *= trace.Fraction * losScale; + return distance; + } + + public static float ClosestPointFraction(in Vector3 p, in Vector3 a, in Vector3 b) { + Vector3 dir = b - a; + float div = Vector3.Dot(dir, dir); + return div < 0.00001f ? 0.0f : (Vector3.Dot(dir, p) - Vector3.Dot(dir, a)) / div; + } + + public static float PercentageBetween(in Vector3 cp1, in Vector3 cp2, in Vector3 position, bool radial) { + if (radial) { + float distance = (cp1 - cp2).Length(); + float particleDistance = (cp1 - position).Length() + 1.1920929e-07f; + return 1.0f / (distance / particleDistance); + } + return ClosestPointFraction(position, cp1, cp2); + } +} + +public sealed class C_OP_SetChildControlPoints : ParticleOperatorInstance +{ + public int ChildGroupID; + public int FirstControlPoint; + public int NumControlPoints; + public int FirstSourcePoint; + public bool SetOrientation; + + public static readonly ParticleOperatorDefinition Definition = new("Set child control points from particle positions", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Group ID to affect", "0", (o, v) => o.ChildGroupID = v) + .Int("First control point to set", "0", (o, v) => o.FirstControlPoint = v) + .Int("# of control points to set", "1", (o, v) => o.NumControlPoints = v) + .Int("first particle to copy", "0", (o, v) => o.FirstSourcePoint = v) + .Bool("set orientation", "0", (o, v) => o.SetOrientation = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int first = ParticleOpUtil.ClampCP(FirstControlPoint); + int toSet = Math.Min(particles.ActiveParticles - FirstSourcePoint, NumControlPoints); + toSet = Math.Min(toSet, MAX_PARTICLE_CONTROL_POINTS - first); + if (toSet <= 0) + return; + for (ParticleCollection? child = particles.Children; child != null; child = child.Next) { + if (child.GetGroupID() != ChildGroupID) + continue; + for (int p = 0; p < toSet; p++) + ParticleCPUtil.SetFromParticle(child, p + first, particles, p + FirstSourcePoint, SetOrientation); + } + } +} + +public sealed class C_OP_SetControlPointsToParticle : ParticleOperatorInstance +{ + public int FirstControlPoint; + public int NumControlPoints; + public int FirstSourcePoint; + public bool SetOrientation; + + public static readonly ParticleOperatorDefinition Definition = new("Set control points from particle positions", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("First control point to set", "0", (o, v) => o.FirstControlPoint = v) + .Int("# of control points to set", "1", (o, v) => o.NumControlPoints = v) + .Int("first particle to copy", "0", (o, v) => o.FirstSourcePoint = v) + .Bool("set orientation", "0", (o, v) => o.SetOrientation = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int first = ParticleOpUtil.ClampCP(FirstControlPoint); + int toSet = Math.Min(particles.ActiveParticles - FirstSourcePoint, NumControlPoints); + toSet = Math.Min(toSet, MAX_PARTICLE_CONTROL_POINTS - first); + for (int p = 0; p < toSet; p++) + ParticleCPUtil.SetFromParticle(particles, p + first, particles, p + FirstSourcePoint, SetOrientation); + } +} + +public sealed class C_OP_SetPerChildControlPoint : ParticleOperatorInstance +{ + public int ChildGroupID; + public int FirstControlPoint; + public int NumControlPoints; + public int FirstSourcePoint; + public bool SetOrientation; + + public static readonly ParticleOperatorDefinition Definition = new("Set per child control point from particle positions", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Group ID to affect", "0", (o, v) => o.ChildGroupID = v) + .Int("control point to set", "0", (o, v) => o.FirstControlPoint = v) + .Int("# of children to set", "1", (o, v) => o.NumControlPoints = v) + .Int("first particle to copy", "0", (o, v) => o.FirstSourcePoint = v) + .Bool("set orientation", "0", (o, v) => o.SetOrientation = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int childCount = 0; + for (ParticleCollection? child = particles.Children; child != null; child = child.Next) + childCount++; + int toSet = Math.Min(NumControlPoints, Math.Min(particles.ActiveParticles - FirstSourcePoint, childCount)); + if (toSet <= 0) + return; + int current = FirstSourcePoint; + int cp = ParticleOpUtil.ClampCP(FirstControlPoint); + for (ParticleCollection? child = particles.Children; child != null && toSet > 0; child = child.Next) { + if (child.GetGroupID() != ChildGroupID) + continue; + ParticleCPUtil.SetFromParticle(child, cp, particles, current, SetOrientation); + toSet--; + current++; + } + } +} + +public sealed class C_OP_SetControlPointPositions : ParticleOperatorInstance +{ + public bool UseWorldLocation; + public readonly int[] CP = new int[4]; + public readonly int[] CPParent = new int[4]; + public readonly Vector3[] CPPos = new Vector3[4]; + public int HeadLocation; + + public static readonly ParticleOperatorDefinition Definition = new("Set Control Point Positions", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("First Control Point Number", "1", (o, v) => o.CP[0] = v) + .Int("First Control Point Parent", "0", (o, v) => o.CPParent[0] = v) + .Vector3("First Control Point Location", "128 0 0", (o, v) => o.CPPos[0] = v) + .Int("Second Control Point Number", "2", (o, v) => o.CP[1] = v) + .Int("Second Control Point Parent", "0", (o, v) => o.CPParent[1] = v) + .Vector3("Second Control Point Location", "0 128 0", (o, v) => o.CPPos[1] = v) + .Int("Third Control Point Number", "3", (o, v) => o.CP[2] = v) + .Int("Third Control Point Parent", "0", (o, v) => o.CPParent[2] = v) + .Vector3("Third Control Point Location", "-128 0 0", (o, v) => o.CPPos[2] = v) + .Int("Fourth Control Point Number", "4", (o, v) => o.CP[3] = v) + .Int("Fourth Control Point Parent", "0", (o, v) => o.CPParent[3] = v) + .Vector3("Fourth Control Point Location", "0 -128 0", (o, v) => o.CPPos[3] = v) + .Bool("Set positions in world space", "0", (o, v) => o.UseWorldLocation = v) + .Int("Control Point to offset positions from", "0", (o, v) => o.HeadLocation = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override bool ShouldRunBeforeEmitters() => true; + + public override ulong GetReadControlPointMask() { + ulong mask = ParticleOpUtil.CPMask(CP[0]) | ParticleOpUtil.CPMask(CP[1]) | ParticleOpUtil.CPMask(CP[2]) | ParticleOpUtil.CPMask(CP[3]); + return UseWorldLocation ? mask : mask | ParticleOpUtil.CPMask(HeadLocation); + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + for (int i = 0; i < 4; i++) + CP[i] = ParticleOpUtil.ClampCP(CP[i]); + HeadLocation = ParticleOpUtil.ClampCP(HeadLocation); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Matrix3x4 mat = default; + if (!UseWorldLocation) + particles.GetControlPointTransformAtTime(HeadLocation, particles.CurTime, out mat); + for (int i = 0; i < 4; i++) { + particles.SetControlPoint(CP[i], UseWorldLocation ? CPPos[i] : ParticleOpUtil.Transform(CPPos[i], mat)); + particles.SetControlPointParent(CP[i], CPParent[i]); + } + } +} + +public sealed class C_OP_DampenToCP : ParticleOperatorInstance +{ + public int ControlPointNumber; + public float Range; + public float Scale; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Dampen Relative to Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("falloff range", "100", (o, v) => o.Range = v) + .Float("dampen scale", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (Range <= 0.0f) + return; + Vector3 controlPoint = particles.GetControlPointAtCurrentTime(ControlPointNumber); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + float distance = (position - controlPoint).Length(); + if (distance > Range) + continue; + float dampen = MathF.Pow(distance / Range, Scale); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 dampened = prev + (position - prev) * dampen; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, Vector3.Lerp(position, dampened, opStrength)); + } + } +} + +public sealed class C_OP_DistanceBetweenCPs : ParticleOperatorInstance +{ + public int FieldOutput; + public int StartCP; + public int EndCP; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public float MaxTraceLength; + public float LOSScale; + public string CollisionGroupName = "NONE"; + public bool LOS; + public bool ScaleInitialRange; + public bool ScaleCurrent; + int CollisionGroupNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Distance Between Two Control Points to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("distance minimum", "0", (o, v) => o.InputMin = v) + .Float("distance maximum", "128", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Int("starting control point", "0", (o, v) => o.StartCP = v) + .Int("ending control point", "1", (o, v) => o.EndCP = v) + .Bool("ensure line of sight", "0", (o, v) => o.LOS = v) + .String("LOS collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Float("Maximum Trace Length", "-1", (o, v) => o.MaxTraceLength = v) + .Float("LOS Failure Scalar", "0", (o, v) => o.LOSScale = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override ulong GetReadControlPointMask() => (1UL << StartCP) | (1UL << EndCP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + StartCP = ParticleOpUtil.ClampCP(StartCP); + EndCP = ParticleOpUtil.ClampCP(EndCP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + min = Math.Clamp(OutputMin, 0.0f, 1.0f); + max = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + Vector3 cp1 = particles.GetControlPointAtCurrentTime(StartCP); + Vector3 cp2 = particles.GetControlPointAtCurrentTime(EndCP); + float distance = (cp1 - cp2).Length(); + if (LOS) + distance = ParticleCPUtil.LOSDistance(particles, cp1, cp2, distance, MaxTraceLength, CollisionGroupNumber, LOSScale); + for (int p = 0; p < particles.ActiveParticles; p++) { + float output = ParticleOpUtil.RemapClamped(distance, InputMin, InputMax, min, max); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + if (ScaleCurrent) + output *= value; + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_DistanceBetweenCPsToCP : ParticleOperatorInstance +{ + public int StartCP; + public int EndCP; + public int OutputCP; + public int OutputCPField; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public float MaxTraceLength; + public float LOSScale; + public bool LOS; + public string CollisionGroupName = "NONE"; + int CollisionGroupNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Distance Between Two Control Points to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("distance minimum", "0", (o, v) => o.InputMin = v) + .Float("distance maximum", "128", (o, v) => o.InputMax = v) + .Int("output control point", "2", (o, v) => o.OutputCP = v) + .Int("output control point field", "0", (o, v) => o.OutputCPField = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Int("starting control point", "0", (o, v) => o.StartCP = v) + .Int("ending control point", "1", (o, v) => o.EndCP = v) + .Bool("ensure line of sight", "0", (o, v) => o.LOS = v) + .String("LOS collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Float("Maximum Trace Length", "-1", (o, v) => o.MaxTraceLength = v) + .Float("LOS Failure Scale", "0", (o, v) => o.LOSScale = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => (1UL << StartCP) | (1UL << EndCP) | (1UL << OutputCP); + public override bool ShouldRunBeforeEmitters() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + StartCP = ParticleOpUtil.ClampCP(StartCP); + EndCP = ParticleOpUtil.ClampCP(EndCP); + OutputCP = ParticleOpUtil.ClampCP(OutputCP); + OutputCPField = Math.Clamp(OutputCPField, 0, 2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cp1 = particles.GetControlPointAtCurrentTime(StartCP); + Vector3 cp2 = particles.GetControlPointAtCurrentTime(EndCP); + float distance = (cp1 - cp2).Length(); + if (LOS) + distance = ParticleCPUtil.LOSDistance(particles, cp1, cp2, distance, MaxTraceLength, CollisionGroupNumber, LOSScale); + distance = ParticleOpUtil.RemapClamped(distance, InputMin, InputMax, OutputMin, OutputMax); + ParticleOpUtil.SetControlPointComponent(particles, OutputCP, OutputCPField, distance); + } +} + +public sealed class C_OP_PercentageBetweenCPs : ParticleOperatorInstance +{ + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public int StartCP; + public int EndCP; + public bool ScaleInitialRange; + public bool ScaleCurrent; + public bool ActiveRange; + public bool RadialCheck; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Percentage Between Two Control Points to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("percentage minimum", "0", (o, v) => o.InputMin = v) + .Float("percentage maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Int("starting control point", "0", (o, v) => o.StartCP = v) + .Int("ending control point", "1", (o, v) => o.EndCP = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v) + .Bool("only active within input range", "0", (o, v) => o.ActiveRange = v) + .Bool("treat distance between points as radius", "1", (o, v) => o.RadialCheck = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override ulong GetReadControlPointMask() => (1UL << StartCP) | (1UL << EndCP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + StartCP = ParticleOpUtil.ClampCP(StartCP); + EndCP = ParticleOpUtil.ClampCP(EndCP); + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f); + OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cp1 = particles.GetControlPointAtCurrentTime(StartCP); + Vector3 cp2 = particles.GetControlPointAtCurrentTime(EndCP); + int count = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < count; p++) { + float perc = ParticleCPUtil.PercentageBetween(cp1, cp2, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), RadialCheck); + float output = ParticleOpUtil.RemapClamped(perc, InputMin, InputMax, OutputMin, OutputMax); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + if (ScaleCurrent) + output *= value; + if (!ActiveRange || (perc >= InputMin && perc <= InputMax)) + value = output; + } + } +} + +public sealed class C_OP_PercentageBetweenCPsVector : ParticleOperatorInstance +{ + public int FieldOutput; + public float InputMin; + public float InputMax; + public Vector3 OutputMin; + public Vector3 OutputMax; + public int StartCP; + public int EndCP; + public bool ScaleInitialRange; + public bool ScaleCurrent; + public bool ActiveRange; + public bool RadialCheck; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Percentage Between Two Control Points to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("percentage minimum", "0", (o, v) => o.InputMin = v) + .Float("percentage maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "6", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v) + .Int("starting control point", "0", (o, v) => o.StartCP = v) + .Int("ending control point", "1", (o, v) => o.EndCP = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v) + .Bool("only active within input range", "0", (o, v) => o.ActiveRange = v) + .Bool("treat distance between points as radius", "1", (o, v) => o.RadialCheck = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override ulong GetReadControlPointMask() => (1UL << StartCP) | (1UL << EndCP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + StartCP = ParticleOpUtil.ClampCP(StartCP); + EndCP = ParticleOpUtil.ClampCP(EndCP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cp1 = particles.GetControlPointAtCurrentTime(StartCP); + Vector3 cp2 = particles.GetControlPointAtCurrentTime(EndCP); + int count = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < count; p++) { + float perc = ParticleCPUtil.PercentageBetween(cp1, cp2, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), RadialCheck); + Vector3 output = new( + ParticleOpUtil.RemapClamped(perc, InputMin, InputMax, OutputMin.X, OutputMax.X), + ParticleOpUtil.RemapClamped(perc, InputMin, InputMax, OutputMin.Y, OutputMax.Y), + ParticleOpUtil.RemapClamped(perc, InputMin, InputMax, OutputMin.Z, OutputMax.Z)); + if (ScaleInitialRange) + output *= ParticleOpUtil.GetInitialVector(particles, FieldOutput, p); + if (ScaleCurrent) + output *= ParticleOpUtil.GetVector(particles, FieldOutput, p); + if (!ActiveRange || (perc >= InputMin && perc <= InputMax)) + ParticleOpUtil.SetVector(particles, FieldOutput, p, output); + } + } +} + +public sealed class C_OP_DistanceToCP : ParticleOperatorInstance +{ + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public int StartCP; + public bool LOS; + public string CollisionGroupName = "NONE"; + public float MaxTraceLength; + public float LOSScale; + public bool ScaleInitialRange; + public bool ScaleCurrent; + public bool ActiveRange; + int CollisionGroupNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Distance to Control Point to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("distance minimum", "0", (o, v) => o.InputMin = v) + .Float("distance maximum", "128", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Int("control point", "0", (o, v) => o.StartCP = v) + .Bool("ensure line of sight", "0", (o, v) => o.LOS = v) + .String("LOS collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Float("Maximum Trace Length", "-1", (o, v) => o.MaxTraceLength = v) + .Float("LOS Failure Scalar", "0", (o, v) => o.LOSScale = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v) + .Bool("only active within specified distance", "0", (o, v) => o.ActiveRange = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override ulong GetReadControlPointMask() => 1UL << StartCP; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + StartCP = ParticleOpUtil.ClampCP(StartCP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + min = Math.Clamp(OutputMin, 0.0f, 1.0f); + max = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + Vector3 cp = particles.GetControlPointAtCurrentTime(StartCP); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + float distance = (cp - position).Length(); + if (ActiveRange && (distance < InputMin || distance > InputMax)) + continue; + if (LOS) + distance = ParticleCPUtil.LOSDistance(particles, cp, position, distance, MaxTraceLength, CollisionGroupNumber, LOSScale); + float output = ParticleOpUtil.RemapClamped(distance, InputMin, InputMax, min, max); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + if (ScaleCurrent) + output *= value; + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_SetControlPointToPlayer : ParticleOperatorInstance +{ + public int CP1; + public Vector3 CP1Pos; + public bool OrientToEyes; + + public static readonly ParticleOperatorDefinition Definition = new("Set Control Point To Player", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point Number", "1", (o, v) => o.CP1 = v) + .Vector3("Control Point Offset", "0 0 0", (o, v) => o.CP1Pos = v) + .Bool("Use Eye Orientation", "0", (o, v) => o.OrientToEyes = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override bool ShouldRunBeforeEmitters() => true; + public override void InitParams(ParticleSystemDefinition def, Element element) => CP1 = ParticleOpUtil.ClampCP(CP1); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + IParticleSystemQuery query = particles.Mgr!.Query(); + particles.SetControlPoint(CP1, CP1Pos + query.GetLocalPlayerPos()); + query.GetLocalPlayerEyeVectors(out Vector3 forward, out Vector3 right, out Vector3 up); + if (!OrientToEyes && MathF.Abs(forward.Z - 1.0f) > 1e-3f) { + forward.Z = 0; + MathLib.VectorNormalize(ref forward); + up = new Vector3(0, 0, 1); + right = new Vector3(forward.Y, -forward.X, 0.0f); + } + particles.SetControlPointOrientation(CP1, forward, right, up); + } +} + +public sealed class C_OP_LockToBone : ParticleOperatorInstance +{ + public int ControlPointNumber; + public float LifeTimeFadeStart; + public float LifeTimeFadeEnd; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Lock to Bone", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("lifetime fade start", "0", (o, v) => o.LifeTimeFadeStart = v) + .Float("lifetime fade end", "0", (o, v) => o.LifeTimeFadeEnd = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK | PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + + static Vector3 BoxPoint(in ModelHitBoxInfo box, in Vector3 uvw) + => ParticleOpUtil.Transform(new Vector3( + ParticleOpUtil.Lerp(uvw.X, box.BoxMins.X, box.BoxMaxes.X), + ParticleOpUtil.Lerp(uvw.Y, box.BoxMins.Y, box.BoxMaxes.Y), + ParticleOpUtil.Lerp(uvw.Z, box.BoxMins.Z, box.BoxMaxes.Z)), box.Transform); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + particles.UpdateHitBoxInfo(ControlPointNumber, HitboxSetName); + ModelHitBoxesInfo info = particles.ControlPointHitBoxes[ControlPointNumber]; + if (!info.CurAndPrevValid()) + return; + + float ageThreshold = LifeTimeFadeEnd <= 0.0f ? 1.0e20f : LifeTimeFadeEnd; + float iScale = LifeTimeFadeEnd > LifeTimeFadeStart ? 1.0f / (LifeTimeFadeEnd - LifeTimeFadeStart) : 0.0f; + for (int p = 0; p < particles.ActiveParticles; p++) { + float age = ParticleOpUtil.Age(particles, p); + float frameBias = Math.Min(age, particles.Dt) * (1.0f / particles.Dt); + if (!(age < ageThreshold)) + continue; + int box = particles.GetIntAttributeValue(PARTICLE_ATTRIBUTE_HITBOX_INDEX, p); + if (box < 0 || box >= info.NumHitBoxes || box >= info.NumPrevHitBoxes) + continue; + Vector3 uvw = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p); + Vector3 delta = (BoxPoint(info.HitBoxes![box], uvw) - BoxPoint(info.PrevBoxes![box], uvw)) * frameBias; + if (age > LifeTimeFadeStart) + delta *= opStrength * (1.0f - (age - LifeTimeFadeStart) * iScale); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + delta); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + delta); + } + } +} + +public sealed class C_OP_CPOffsetToPercentageBetweenCPs : ParticleOperatorInstance +{ + public float InputMin; + public float InputMax; + public float InputBias; + public int StartCP; + public int EndCP; + public int OffsetCP; + public int OutputCP; + public int InputCP; + public bool RadialCheck; + public bool ScaleOffset; + public Vector3 Offset; + + public static readonly ParticleOperatorDefinition Definition = new("Set CP Offset to CP Percentage Between Two Control Points", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("percentage minimum", "0", (o, v) => o.InputMin = v) + .Float("percentage maximum", "1", (o, v) => o.InputMax = v) + .Float("percentage bias", ".5", (o, v) => o.InputBias = v) + .Int("starting control point", "0", (o, v) => o.StartCP = v) + .Int("ending control point", "1", (o, v) => o.EndCP = v) + .Int("offset control point", "2", (o, v) => o.OffsetCP = v) + .Int("input control point", "3", (o, v) => o.InputCP = v) + .Int("output control point", "4", (o, v) => o.OutputCP = v) + .Vector3("offset amount", "0 0 0", (o, v) => o.Offset = v) + .Bool("treat distance between points as radius", "1", (o, v) => o.RadialCheck = v) + .Bool("treat offset as scale of total distance", "0", (o, v) => o.ScaleOffset = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => (1UL << StartCP) | (1UL << EndCP) | (1UL << OffsetCP) | (1UL << OutputCP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + StartCP = ParticleOpUtil.ClampCP(StartCP); + EndCP = ParticleOpUtil.ClampCP(EndCP); + OffsetCP = ParticleOpUtil.ClampCP(OffsetCP); + OutputCP = ParticleOpUtil.ClampCP(OutputCP); + InputCP = ParticleOpUtil.ClampCP(InputCP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cp1 = particles.GetControlPointAtCurrentTime(StartCP); + Vector3 cp2 = particles.GetControlPointAtCurrentTime(EndCP); + Vector3 cpOffset = particles.GetControlPointAtCurrentTime(OffsetCP); + Vector3 cpInput = particles.GetControlPointAtCurrentTime(InputCP); + float totalDistance = (cp1 - cp2).Length(); + Vector3 offset = ScaleOffset ? Offset * totalDistance : Offset; + float percentage = ParticleCPUtil.PercentageBetween(cp1, cp2, cpInput, RadialCheck); + percentage = ParticleOpUtil.RemapClamped(percentage, InputMin, InputMax, 0.0f, 1.0f); + percentage = ParticleOpUtil.Bias(percentage, ParticleOpUtil.PreCalcBiasParameter(InputBias)); + particles.SetControlPoint(OutputCP, cpOffset + offset * percentage); + } +} + +public sealed class C_OP_PlaneCull : ParticleOperatorInstance +{ + public int PlaneControlPoint; + public Vector3 PlaneDirection; + public float PlaneOffset; + + public static readonly ParticleOperatorDefinition Definition = new("Cull when crossing plane", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point for point on plane", "0", (o, v) => o.PlaneControlPoint = v) + .Float("Cull plane offset", "0", (o, v) => o.PlaneOffset = v) + .Vector3("Plane Normal", "0 0 1", (o, v) => o.PlaneDirection = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(PlaneControlPoint); + public override void InitParams(ParticleSystemDefinition def, Element element) => PlaneControlPoint = ParticleOpUtil.ClampCP(PlaneControlPoint); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 normal = Vector3.Normalize(PlaneDirection); + Vector3 point = particles.GetControlPointAtCurrentTime(PlaneControlPoint) - normal * PlaneOffset; + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + float plane = Vector3.Dot(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - point, normal); + if (plane < 0.0f || (plane == 0.0f && float.IsNegative(plane))) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_DistanceCull : ParticleOperatorInstance +{ + public int ControlPoint; + public Vector3 PointOffset; + public float Distance; + public bool CullInside; + + public static readonly ParticleOperatorDefinition Definition = new("Cull when crossing sphere", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point", "0", (o, v) => o.ControlPoint = v) + .Float("Cull Distance", "0", (o, v) => o.Distance = v) + .Vector3("Control Point offset", "0 0 0", (o, v) => o.PointOffset = v) + .Bool("Cull inside instead of outside", "0", (o, v) => o.CullInside = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(ControlPoint); + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPoint = ParticleOpUtil.ClampCP(ControlPoint); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cullPosition = particles.GetControlPointAtCurrentTime(ControlPoint) + PointOffset; + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + float distance = (particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cullPosition).Length(); + if (CullInside ? distance < Distance : distance > Distance) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_ModelCull : ParticleOperatorInstance +{ + public int ControlPointNumber; + public bool BoundBox; + public bool CullOutside; + public string HitboxSetName = "effects"; + + public static readonly ParticleOperatorDefinition Definition = new("Cull relative to model", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Bool("use only bounding box", "0", (o, v) => o.BoundBox = v) + .Bool("cull outside instead of inside", "0", (o, v) => o.CullOutside = v) + .String("hitbox set", "effects", 128, (o, v) => o.HitboxSetName = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (particles.ControlPoint(ControlPointNumber).Object == null) + return; + particles.UpdateHitBoxInfo(ControlPointNumber, HitboxSetName); + if (!particles.ControlPointHitBoxes[ControlPointNumber].CurAndPrevValid()) + return; + IParticleSystemQuery query = particles.Mgr!.Query(); + for (int p = 0; p < particles.ActiveParticles; p++) { + bool inside = query.IsPointInControllingObjectHitBox(particles, ControlPointNumber, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p), BoundBox); + if (inside != CullOutside) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_SetControlPointToCenter : ParticleOperatorInstance +{ + public int CP1; + public Vector3 CP1Pos; + + public static readonly ParticleOperatorDefinition Definition = new("Set Control Point To Particles' Center", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point Number to Set", "1", (o, v) => o.CP1 = v) + .Vector3("Center Offset", "0 0 0", (o, v) => o.CP1Pos = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override bool ShouldRunBeforeEmitters() => true; + public override void InitParams(ParticleSystemDefinition def, Element element) => CP1 = ParticleOpUtil.ClampCP(CP1); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + particles.GetBounds(out Vector3 min, out Vector3 max); + particles.SetControlPoint(CP1, CP1Pos + (min + max) / 2); + } +} + +public sealed class C_OP_VelocityMatchingForce : ParticleOperatorInstance +{ + struct MatchContext + { + public Vector3 AvgVelocity; + public float AvgSpeed; + } + + public float DirScale; + public float SpdScale; + public int CPBroadcast; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Match Particle Velocities", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Direction Matching Strength", "0.25", (o, v) => o.DirScale = v) + .Float("Speed Matching Strength", "0.25", (o, v) => o.SpdScale = v) + .Int("Control Point to Broadcast Speed and Direction To", "-1", (o, v) => o.CPBroadcast = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override int GetRequiredContextBytes() => System.Runtime.CompilerServices.Unsafe.SizeOf(); + public override void InitializeContextData(ParticleCollection particles, Span context) => ParticleOpUtil.Context(context) = default; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref MatchContext ctx = ref ParticleOpUtil.Context(context); + Vector3 velocityAvg = Vector3.Zero; + float avgSpeed = 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 velocity = (xyz - prev) / particles.Dt; + velocityAvg += velocity; + float speed = velocity.Length(); + avgSpeed += speed; + if (ctx.AvgVelocity != Vector3.Zero) { + Vector3 scaled = ParticleOpUtil.NormalizeOrZero(Vector3.Lerp(ParticleOpUtil.NormalizeOrZero(velocity), ctx.AvgVelocity, DirScale)); + speed = ParticleOpUtil.Lerp(SpdScale, speed, ctx.AvgSpeed); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, scaled * speed * particles.Dt + prev); + } + } + ctx.AvgVelocity = ParticleOpUtil.NormalizeOrZero(velocityAvg); + ctx.AvgSpeed = avgSpeed / particles.ActiveParticles; + if (CPBroadcast != -1) { + particles.SetControlPoint(CPBroadcast, new Vector3(ctx.AvgSpeed)); + particles.SetControlPointForwardVector(CPBroadcast, ctx.AvgVelocity); + } + } +} diff --git a/Source.Particles/BuiltinParticleOperators.Movement.cs b/Source.Particles/BuiltinParticleOperators.Movement.cs new file mode 100644 index 00000000..9bbf4c9d --- /dev/null +++ b/Source.Particles/BuiltinParticleOperators.Movement.cs @@ -0,0 +1,380 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.Intrinsics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public abstract class C_OP_GeneralSpin : ParticleOperatorInstance +{ + public int SpinRateDegrees; + public int SpinRateMinDegrees; + public float SpinRateStopTime; + float SpinRateRadians; + float SpinRateMinRadians; + + protected abstract int AttributeToSpin { get; } + + public override uint GetWrittenAttributes() => SpinRateDegrees != 0 ? 1u << AttributeToSpin : 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + SpinRateRadians = SpinRateDegrees * 0.017453292f; + SpinRateMinRadians = SpinRateMinDegrees * 0.017453292f; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float curSpinRate = SpinRateRadians * opStrength; + if (curSpinRate == 0.0f) + return; + + float dt = particles.Dt; + float drot = MathF.Abs(curSpinRate * 2.0f * MathF.PI) * dt; + if (SpinRateStopTime == 0.0f) + drot = (float)(drot % (2.0 * Math.PI)); + if (curSpinRate < 0.0f) + drot = -drot; + + float minSpeed = MathF.Abs(SpinRateMinRadians * 2.0f * MathF.PI) * dt; + const float twoPi = 6.2831855f; + int attribute = AttributeToSpin; + int count = (particles.ActiveParticles + 3) & ~3; + for (int p = 0; p < count; p++) { + float ooFadeRate = 0.0f; + if (SpinRateStopTime != 0.0f) + ooFadeRate = 1.0f / (SpinRateStopTime * ParticleOpUtil.Lifetime(particles, p)); + float scale = Math.Max(0.0f, 1.0f - ParticleOpUtil.Age(particles, p) * ooFadeRate); + float delta = drot * scale; + if (delta <= minSpeed) + delta = minSpeed; + ref float rot = ref particles.GetFloatAttributeRefForWrite(attribute, p); + float newRot = rot + delta; + float wrapped = newRot >= twoPi ? newRot - twoPi : newRot; + rot = newRot <= -twoPi ? wrapped + twoPi : wrapped; + } + } +} + +public sealed class C_OP_Spin : C_OP_GeneralSpin +{ + protected override int AttributeToSpin => PARTICLE_ATTRIBUTE_ROTATION; + + public static readonly ParticleOperatorDefinition Definition = new("Rotation Spin Roll", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("spin_rate_degrees", "0", (o, v) => o.SpinRateDegrees = v) + .Float("spin_stop_time", "0", (o, v) => o.SpinRateStopTime = v) + .Int("spin_rate_min", "0", (o, v) => o.SpinRateMinDegrees = v)); +} + +public sealed class C_OP_SpinYaw : C_OP_GeneralSpin +{ + protected override int AttributeToSpin => PARTICLE_ATTRIBUTE_YAW; + + public static readonly ParticleOperatorDefinition Definition = new("Rotation Spin Yaw", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("yaw_rate_degrees", "0", (o, v) => o.SpinRateDegrees = v) + .Float("yaw_stop_time", "0", (o, v) => o.SpinRateStopTime = v) + .Int("yaw_rate_min", "0", (o, v) => o.SpinRateMinDegrees = v)); +} + +public sealed class C_OP_SpinUpdate : ParticleOperatorInstance +{ + public static readonly ParticleOperatorDefinition Definition = new("Rotation Basic", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin()); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ROTATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_ROTATION_MASK | PARTICLE_ATTRIBUTE_ROTATION_SPEED_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int count = (particles.ActiveParticles + 3) & ~3; + for (int p = 0; p < count; p++) { + float simTime = Math.Min(particles.Dt, ParticleOpUtil.Age(particles, p)); + ref float rot = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ROTATION, p); + rot = simTime * opStrength * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION_SPEED, p) + rot; + } + } +} + +public sealed class C_OP_PositionLock : ParticleOperatorInstance +{ + struct LockContext + { + public Vector3 PrevPosition; + public Matrix3x4 PrevTransform; + } + + public int ControlPointNumber; + public float StartTimeMin; + public float StartTimeMax; + public float StartTimeExp; + public float EndTimeMin; + public float EndTimeMax; + public float EndTimeExp; + public float Range; + public bool LockRot; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Lock to Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v) + .Float("start_fadeout_min", "1", (o, v) => o.StartTimeMin = v) + .Float("start_fadeout_max", "1", (o, v) => o.StartTimeMax = v) + .Float("start_fadeout_exponent", "1", (o, v) => o.StartTimeExp = v) + .Float("end_fadeout_min", "1", (o, v) => o.EndTimeMin = v) + .Float("end_fadeout_max", "1", (o, v) => o.EndTimeMax = v) + .Float("end_fadeout_exponent", "1", (o, v) => o.EndTimeExp = v) + .Float("distance fade range", "0", (o, v) => o.Range = v) + .Bool("lock rotation", "0", (o, v) => o.LockRot = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + public override int GetRequiredContextBytes() => System.Runtime.CompilerServices.Unsafe.SizeOf(); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref LockContext ctx = ref ParticleOpUtil.Context(context); + ctx.PrevPosition = Vector3.Zero; + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.CurTime, out ctx.PrevTransform); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref LockContext ctx = ref ParticleOpUtil.Context(context); + Vector3 controlPoint = particles.GetControlPointAtCurrentTime(ControlPointNumber); + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.CurTime, out Matrix3x4 currentTransform); + + if (ctx.PrevPosition == Vector3.Zero) { + ctx.PrevPosition = controlPoint; + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.CurTime, out ctx.PrevTransform); + } + else if (!LockRot ? ctx.PrevPosition == controlPoint : ParticleOpUtil.MatricesAreEqual(currentTransform, ctx.PrevTransform, 1e-5f)) + return; + + Matrix3x4 transformLock = default; + if (LockRot) { + MathLib.MatrixInvert(ctx.PrevTransform, out Matrix3x4 prevInverse); + MathLib.ConcatTransforms(currentTransform, prevInverse, out transformLock); + } + + Vector3 delta = (controlPoint - ctx.PrevPosition) * opStrength; + float dt = particles.Dt; + float ooDt = 1.0f / dt; + bool useRange = Range != 0.0f; + float ooRange = useRange ? 1.0f / Range : 1.0f; + float biasParam = ParticleOpUtil.PreCalcBiasParameter(0.2f); + int count = ParticleOpUtil.PaddedCount(particles); + + if (StartTimeMin >= 1.0f) { + for (int p = 0; p < count; p++) { + float frameBias = ooDt * Math.Min(ParticleOpUtil.Age(particles, p), dt); + Vector3 scaledDelta = delta * frameBias; + float lockStrength = opStrength; + Apply(particles, p, scaledDelta, lockStrength, frameBias, controlPoint, useRange, ooRange, biasParam, transformLock); + } + } + else { + int randContext = RandSIMD.GetContext(); + int startExponent = (int)(StartTimeExp * 4.0f); + int endExponent = (int)(EndTimeExp * 4.0f); + Vector128 startTimes = default, endTimes = default; + for (int p = 0; p < count; p++) { + if ((p & 3) == 0) { + startTimes = RandSIMD.PowFixedPointExponent(RandSIMD.Next(randContext), startExponent) * (StartTimeMax - StartTimeMin) + Vector128.Create(StartTimeMin); + endTimes = RandSIMD.PowFixedPointExponent(RandSIMD.Next(randContext), endExponent) * (EndTimeMax - EndTimeMin) + Vector128.Create(EndTimeMin); + } + float age = ParticleOpUtil.Age(particles, p); + float frameBias = ooDt * Math.Min(age, dt); + Vector3 scaledDelta = delta * frameBias; + float lifeTime = Math.Max(0.0f, Math.Min(1.0f, age / ParticleOpUtil.Lifetime(particles, p))); + float startTime = startTimes[p & 3]; + float endTime = endTimes[p & 3]; + float lockScale = 1.0f - Math.Max(0.0f, Math.Min(1.0f, (lifeTime - startTime) / (endTime - startTime))); + if (!(lockScale > 0.0f)) + continue; + Apply(particles, p, scaledDelta * lockScale, lockScale, frameBias, controlPoint, useRange, ooRange, biasParam, transformLock); + } + RandSIMD.ReleaseContext(randContext); + } + + ctx.PrevPosition = controlPoint; + ctx.PrevTransform = currentTransform; + } + + void Apply(ParticleCollection particles, int p, Vector3 scaledDelta, float lockStrength, float frameBias, in Vector3 controlPoint, bool useRange, float ooRange, float biasParam, in Matrix3x4 transformLock) { + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prevXyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + if (useRange) { + float distance = (xyz + scaledDelta - controlPoint).Length(); + distance = ParticleOpUtil.Bias(Math.Min(1.0f, distance * ooRange), biasParam); + scaledDelta *= 1.0f - distance; + lockStrength = 1.0f - distance * lockStrength; + } + if (LockRot) { + lockStrength *= frameBias; + Vector3 cur = (ParticleOpUtil.Transform(xyz, transformLock) - xyz) * lockStrength; + Vector3 prev = (ParticleOpUtil.Transform(prevXyz, transformLock) - prevXyz) * lockStrength; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz + cur); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prevXyz + prev); + } + else { + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz + scaledDelta); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prevXyz + scaledDelta); + } + } +} + +public sealed class C_OP_ControlpointLight : ParticleOperatorInstance +{ + public sealed class Light + { + public int ControlPoint; + public Vector3 Offset; + public bool Spot; + public Color Color; + public bool Dynamic; + public Vector3 Direction; + public float FiftyDist; + public float ZeroDist; + public float Theta; + public float Phi; + public bool Active; + public LightDesc Desc; + } + + public readonly Light[] Lights = [new(), new(), new(), new()]; + public float Scale; + public bool ClampLowerRange; + public bool ClampUpperRange; + public bool UseNormal; + public bool UseHLambert; + + static DmxElementUnpackStructure AddLight(DmxElementUnpackStructure s, int i) { + string n = $"Light {i + 1} "; + return s.Int(n + "Control Point", "0", (o, v) => o.Lights[i].ControlPoint = v) + .Vector3(n + "Control Point Offset", "0 0 0", (o, v) => o.Lights[i].Offset = v) + .Bool(n + "Type 0=Point 1=Spot", "0", (o, v) => o.Lights[i].Spot = v) + .Color(n + "Color", "0 0 0 255", (o, v) => o.Lights[i].Color = v) + .Bool(n + "Dynamic Light", "0", (o, v) => o.Lights[i].Dynamic = v) + .Vector3(n + "Direction", "0 0 0", (o, v) => o.Lights[i].Direction = v) + .Float(n + "50% Distance", "100", (o, v) => o.Lights[i].FiftyDist = v) + .Float(n + "0% Distance", "200", (o, v) => o.Lights[i].ZeroDist = v) + .Float(n + "Spot Inner Cone", "30.0", (o, v) => o.Lights[i].Theta = v) + .Float(n + "Spot Outer Cone", "45.0", (o, v) => o.Lights[i].Phi = v); + } + + public static readonly ParticleOperatorDefinition Definition = new("Color Light from Control Point", ParticleOperatorId.Generic, false, + AddLight(AddLight(AddLight(AddLight(ParticleOperatorUnpack.Begin(), 0), 1), 2), 3) + .Float("Initial Color Bias", "0.0", (o, v) => o.Scale = v) + .Bool("Clamp Minimum Light Value to Initial Color", "0", (o, v) => o.ClampLowerRange = v) + .Bool("Clamp Maximum Light Value to Initial Color", "0", (o, v) => o.ClampUpperRange = v) + .Bool("Compute Normals From Control Points", "0", (o, v) => o.UseNormal = v) + .Bool("Half-Lambert Normals", "1", (o, v) => o.UseHLambert = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_TINT_RGB_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_TINT_RGB_MASK; + + public override ulong GetReadControlPointMask() { + ulong mask = 0; + foreach (Light light in Lights) + mask |= ParticleOpUtil.CPMask(light.ControlPoint); + return mask; + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + foreach (Light light in Lights) { + light.ControlPoint = ParticleOpUtil.ClampCP(light.ControlPoint); + light.Desc = new LightDesc { + Color = new Vector3(light.Color.R, light.Color.G, light.Color.B) / 255.0f, + Direction = light.Direction, + Theta = light.Theta, + Phi = light.Phi, + Range = 0, + Falloff = 5.0f, + Type = light.Spot ? LightType.Spot : LightType.Point + }; + light.Active = !light.Dynamic && !(light.Color.R == 0 && light.Color.G == 0 && light.Color.B == 0 && light.Color.A == 255); + light.Desc.SetupNewStyleAttenuation(light.FiftyDist, light.ZeroDist); + } + } + + struct LightState + { + public LightDesc Desc; + public Vector3 CPPosition; + public float OneOverSpread; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Span states = stackalloc LightState[4]; + for (int i = 0; i < 4; i++) { + Light light = Lights[i == 3 ? 2 : i]; + Vector3 location = particles.GetControlPointAtCurrentTime(Lights[i].ControlPoint); + states[i].CPPosition = location; + states[i].Desc = light.Desc; + states[i].Desc.Position = location + Lights[i].Offset; + if (Lights[i].Dynamic) { + particles.Mgr!.Query().GetLightingAtPoint(states[i].Desc.Position, out Color lc); + states[i].Desc.Color = new Vector3(lc.R, lc.G, lc.B) / 255.0f; + } + states[i].Desc.RecalculateDerivedValues(); + float spread = states[i].Desc.ThetaDot - states[i].Desc.PhiDot; + states[i].OneOverSpread = spread > 1.0e-10f ? 1.0f / spread : 1.0f; + } + + int count = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < count; p++) { + Vector3 initial = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, p); + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 lighting = initial * Scale; + for (int i = 0; i < 4; i++) { + Vector3? normal = UseNormal ? ParticleOpUtil.NormalizeOrZero(position - states[i].CPPosition) : null; + lighting += ComputeLight(states[i], position, normal, UseHLambert); + } + lighting = ClampLowerRange ? Vector3.Max(lighting, initial) : Vector3.Max(lighting, Vector3.Zero); + lighting = ClampUpperRange ? Vector3.Min(lighting, initial) : Vector3.Min(lighting, Vector3.One); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_TINT_RGB, p, lighting); + } + } + + static Vector3 ComputeLight(in LightState state, in Vector3 position, Vector3? normal, bool halfLambert) { + ref readonly LightDesc desc = ref state.Desc; + if (desc.Type == LightType.Directional) { + if (normal == null) + return Vector3.Zero; + float d = Vector3.Dot(desc.Direction, normal.Value); + float s = halfLambert ? d * 0.5f + 0.5f : Math.Max(0.0f, d); + return desc.Color * s; + } + + Vector3 delta = desc.Position - position; + float dist2 = Math.Max(1.0f, delta.LengthSquared()); + float falloff = desc.Attenuation0 != 0.0f ? desc.Attenuation0 : 1.1920929e-07f; + if (desc.Attenuation1 != 0.0f) + falloff += desc.Attenuation1 * MathF.Sqrt(dist2); + if (desc.Attenuation2 != 0.0f) + falloff += desc.Attenuation2 * dist2; + falloff = 1.0f / falloff; + if (desc.Range != 0.0f && !(dist2 < desc.Range * desc.Range)) + falloff = 0.0f; + + delta = ParticleOpUtil.NormalizeOrZero(delta); + float strength = 1.0f; + if (normal != null) { + float d = Vector3.Dot(delta, normal.Value); + strength = halfLambert ? d * 0.5f + 0.5f : Math.Max(0.0f, d); + } + if (desc.Type == LightType.Spot) { + float dot2 = -Vector3.Dot(delta, desc.Direction); + float cone = Math.Min(state.OneOverSpread * (dot2 - desc.PhiDot), 1.0f); + if (desc.Falloff != 0.0f && desc.Falloff != 1.0f) + cone = MathF.Pow(cone, desc.Falloff); + strength = dot2 > desc.PhiDot ? cone * strength : 0.0f; + } + return desc.Color * (strength * falloff); + } +} diff --git a/Source.Particles/BuiltinParticleOperators.Remap.cs b/Source.Particles/BuiltinParticleOperators.Remap.cs new file mode 100644 index 00000000..9bc13c25 --- /dev/null +++ b/Source.Particles/BuiltinParticleOperators.Remap.cs @@ -0,0 +1,728 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +internal static class ParticleVectorUtil +{ + public static Vector3 RSqrtNormalize(Vector3 v) => v * (1.0f / MathF.Sqrt(v.LengthSquared())); + + public static float InvPrevDt(ParticleCollection particles) => 1.0f / MathF.Max(1e-20f, particles.PreviousDt); + + public static Vector3 ControlPointVelocity(ParticleCollection particles, int cp) { + particles.GetControlPointAtPrevTime(cp, out Vector3 prev); + return particles.GetControlPointAtCurrentTime(cp) - prev; + } +} + +public sealed class C_OP_NormalizeVector : ParticleOperatorInstance +{ + public int FieldOutput; + public float Scale; + + public static readonly ParticleOperatorDefinition Definition = new("Normalize Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 1u << FieldOutput; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) + ParticleOpUtil.SetVector(particles, FieldOutput, p, ParticleVectorUtil.RSqrtNormalize(ParticleOpUtil.GetVector(particles, FieldOutput, p)) * Scale); + } +} + +public sealed class C_OP_RemapVelocityToVector : ParticleOperatorInstance +{ + public int FieldOutput; + public float Scale; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Velocity to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Bool("normalize", "0", (o, v) => o.Normalize = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float scale = Normalize ? Scale : Scale * ParticleVectorUtil.InvPrevDt(particles); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 vel = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + if (Normalize) + vel = ParticleVectorUtil.RSqrtNormalize(vel); + ParticleOpUtil.SetVector(particles, FieldOutput, p, vel * scale); + } + } +} + +public sealed class C_OP_RemapCPVelocityToVector : ParticleOperatorInstance +{ + public int ControlPoint; + public int FieldOutput; + public float Scale; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Remap CP Velocity to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Int("control point", "0", (o, v) => o.ControlPoint = v) + .Bool("normalize", "0", (o, v) => o.Normalize = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << ControlPoint; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + ControlPoint = ParticleOpUtil.ClampCP(ControlPoint); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 vel = ParticleVectorUtil.ControlPointVelocity(particles, ControlPoint); + if (Normalize) { + MathLib.VectorNormalize(ref vel); + vel *= Scale; + } + else + vel *= Scale * ParticleVectorUtil.InvPrevDt(particles); + for (int p = 0; p < particles.ActiveParticles; p++) + ParticleOpUtil.SetVector(particles, FieldOutput, p, vel); + } +} + +public sealed class C_OP_SetCPOrientationToDirection : ParticleOperatorInstance +{ + public int InputControlPoint; + public int OutputControlPoint; + + public static readonly ParticleOperatorDefinition Definition = new("Set CP Orientation to CP Direction", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("input control point", "0", (o, v) => o.InputControlPoint = v) + .Int("output control point", "0", (o, v) => o.OutputControlPoint = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => (1UL << (OutputControlPoint & 0x3f)) | (1UL << (InputControlPoint & 0x3f)); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if ((uint)OutputControlPoint > 0x3f) + return; + int input = (uint)InputControlPoint > 0x3f ? 0 : InputControlPoint; + Vector3 forward = ParticleVectorUtil.ControlPointVelocity(particles, input); + MathLib.VectorNormalize(ref forward); + MathLib.VectorVectors(forward, out Vector3 right, out Vector3 up); + particles.SetControlPointOrientation(OutputControlPoint, forward, right, up); + } +} + +public sealed class C_OP_RemapDirectionToCPToVector : ParticleOperatorInstance +{ + public int ControlPoint; + public int FieldOutput; + public float Scale; + public float OffsetRot; + public Vector3 OffsetAxis; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Direction to CP to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control point", "0", (o, v) => o.ControlPoint = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Bool("normalize", "0", (o, v) => o.Normalize = v) + .Vector3("offset axis", "0 0 0", (o, v) => o.OffsetAxis = v) + .Float("offset rotation", "0", (o, v) => o.OffsetRot = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPoint; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + ControlPoint = ParticleOpUtil.ClampCP(ControlPoint); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Matrix3x4 rot = ParticleRotationUtil.RotationAboutAxis(OffsetAxis, OffsetRot); + Vector3 cp = particles.GetControlPointAtCurrentTime(ControlPoint); + if (Normalize) { + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 v = ParticleOpUtil.Rotate(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp, rot); + ParticleOpUtil.SetVector(particles, FieldOutput, p, ParticleVectorUtil.RSqrtNormalize(v) * Scale); + } + return; + } + float scale = Scale * ParticleVectorUtil.InvPrevDt(particles); + for (int p = 0; p < particles.ActiveParticles; p++) { + int lane = p & 3; + Vector3 offset = new(rot[0, lane], rot[1, lane], rot[2, lane]); + Vector3 v = ParticleOpUtil.Rotate(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp + offset, rot); + ParticleOpUtil.SetVector(particles, FieldOutput, p, v * scale); + } + } +} + +public sealed class C_OP_RemapControlPointDirectionToVector : ParticleOperatorInstance +{ + public int FieldOutput; + public float Scale; + public int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Control Point Direction to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Int("control point number", "0", (o, v) => o.ControlPointNumber = v) + .Float("scale factor", "1", (o, v) => o.Scale = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 v = particles.ControlPoint(ControlPointNumber).ForwardVector * Scale; + for (int p = 0; p < particles.ActiveParticles; p++) + ParticleOpUtil.SetVector(particles, FieldOutput, p, v); + } +} + +public sealed class C_OP_RemapDotProductToScalar : ParticleOperatorInstance +{ + public int InputCP1; + public int InputCP2; + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public bool UseParticleVelocity; + public bool ScaleInitialRange; + public bool ScaleCurrent; + public bool ActiveRange; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Dot Product to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Bool("use particle velocity for first input", "0", (o, v) => o.UseParticleVelocity = v) + .Int("first input control point", "0", (o, v) => o.InputCP1 = v) + .Int("second input control point", "0", (o, v) => o.InputCP2 = v) + .Float("input minimum (-1 to 1)", "0", (o, v) => o.InputMin = v) + .Float("input maximum (-1 to 1)", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v) + .Bool("only active within specified input range", "0", (o, v) => o.ActiveRange = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadInitialAttributes() => ScaleInitialRange ? 1u << FieldOutput : 0; + public override ulong GetReadControlPointMask() => (1UL << InputCP2) | (1UL << InputCP1); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + InputCP1 = ParticleOpUtil.ClampCP(InputCP1); + InputCP2 = ParticleOpUtil.ClampCP(InputCP2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float outMin = OutputMin; + float outMax = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + outMin = Math.Clamp(outMin, 0.0f, 1.0f); + outMax = Math.Clamp(outMax, 0.0f, 1.0f); + } + + particles.GetControlPointOrientationAtTime(InputCP1, particles.CurTime, out Vector3 forward1, out _, out _); + particles.GetControlPointOrientationAtTime(InputCP2, particles.CurTime, out Vector3 forward2, out _, out _); + float input = Vector3.Dot(forward1, forward2); + if (ActiveRange && !UseParticleVelocity && (input < InputMin || input > InputMax)) + return; + + bool isInt = (ATTRIBUTES_WHICH_ARE_INTS & (1 << FieldOutput)) != 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + if (UseParticleVelocity) { + Vector3 vel = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + MathLib.VectorNormalize(ref vel); + float velInput = Vector3.Dot(vel, forward2); + if (ActiveRange && (velInput < InputMin || velInput > InputMax)) + continue; + } + + float output = ParticleOpUtil.RemapClamped(input, InputMin, InputMax, outMin, outMax); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleCurrent) + output *= value; + value = isInt ? (int)output : output; + } + } +} + +public sealed class C_OP_RemapCPtoScalar : ParticleOperatorInstance +{ + public int CPInput; + public int FieldOutput; + public int Field; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public float StartTime; + public float EndTime; + public bool ScaleInitialRange; + public bool ScaleCurrent; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Control Point to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input control point number", "0", (o, v) => o.CPInput = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("input field 0-2 X/Y/Z", "0", (o, v) => o.Field = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override uint GetReadInitialAttributes() => ScaleInitialRange ? 1u << FieldOutput : 0; + public override ulong GetReadControlPointMask() => 1UL << CPInput; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + CPInput = ParticleOpUtil.ClampCP(CPInput); + Field = Math.Clamp(Field, 0, 2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float outMin = OutputMin; + float outMax = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + outMin = Math.Clamp(outMin, 0.0f, 1.0f); + outMax = Math.Clamp(outMax, 0.0f, 1.0f); + } + float input = ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(CPInput), Field); + bool isInt = (ATTRIBUTES_WHICH_ARE_INTS & (1 << FieldOutput)) != 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + if (!(StartTime <= creationTime && creationTime < EndTime) && StartTime != -1.0f && EndTime != -1.0f) + continue; + float output = ParticleOpUtil.RemapClamped(input, InputMin, InputMax, outMin, outMax); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleCurrent) + output *= value; + value = isInt ? (int)output : output; + } + } +} + +public sealed class C_OP_RemapCPtoVector : ParticleOperatorInstance +{ + public int CPInput; + public int FieldOutput; + public int LocalSpaceCP; + public Vector3 InputMin; + public Vector3 InputMax; + public Vector3 OutputMin; + public Vector3 OutputMax; + public float StartTime; + public float EndTime; + public bool ScaleInitialRange; + public bool ScaleCurrent; + public bool Offset; + public bool Accelerate; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Control Point to Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v) + .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v) + .Int("input control point number", "0", (o, v) => o.CPInput = v) + .Vector3("input minimum", "0 0 0", (o, v) => o.InputMin = v) + .Vector3("input maximum", "0 0 0", (o, v) => o.InputMax = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "0 0 0", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v) + .Bool("offset position", "0", (o, v) => o.Offset = v) + .Bool("accelerate position", "0", (o, v) => o.Accelerate = v) + .Int("local space CP", "-1", (o, v) => o.LocalSpaceCP = v)); + + public override uint GetWrittenAttributes() => (1u << FieldOutput) | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override uint GetReadInitialAttributes() => ScaleInitialRange ? 1u << FieldOutput : 0; + public override ulong GetReadControlPointMask() => (1UL << CPInput) | (LocalSpaceCP != -1 ? 1UL << LocalSpaceCP : 0); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + CPInput = ParticleOpUtil.ClampCP(CPInput); + LocalSpaceCP = Math.Clamp(LocalSpaceCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + static float Remap(float value, float inMin, float inMax, float outMin, float outMax) => ParticleOpUtil.RemapClamped(value, inMin, inMax, outMin, outMax); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 cp = particles.GetControlPointAtCurrentTime(CPInput); + Vector3 outMin = OutputMin; + Vector3 outMax = OutputMax; + if (LocalSpaceCP != -1) { + particles.GetControlPointTransformAtTime(LocalSpaceCP, particles.CurTime, out Matrix3x4 mat); + outMin = ParticleOpUtil.Rotate(outMin, mat); + outMax = ParticleOpUtil.Rotate(outMax, mat); + } + + bool isColor = (ParticleOpUtil.ATTRIBUTES_WHICH_ARE_COLOR_AND_OPACITY & (1 << FieldOutput)) != 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + if (!(StartTime <= creationTime && creationTime < EndTime) && StartTime != -1.0f && EndTime != -1.0f) + continue; + + Vector3 output = new( + Remap(cp.X, InputMin.X, InputMax.X, outMin.X, outMax.X), + Remap(cp.Y, InputMin.Y, InputMax.Y, outMin.Y, outMax.Y), + Remap(cp.Z, InputMin.Z, InputMax.Z, outMin.Z, outMax.Z)); + if (ScaleInitialRange) + output *= ParticleOpUtil.GetInitialVector(particles, FieldOutput, p); + Vector3 current = ParticleOpUtil.GetVector(particles, FieldOutput, p); + if (ScaleCurrent) + output *= current.X; + + if (isColor) { + ParticleOpUtil.SetVector(particles, FieldOutput, p, Vector3.Clamp(output, Vector3.Zero, Vector3.One)); + continue; + } + + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + if (Accelerate) { + if (Offset) { + output += current; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev + output); + ParticleOpUtil.SetVector(particles, FieldOutput, p, output + output * particles.Dt); + } + else + ParticleOpUtil.SetVector(particles, FieldOutput, p, output * particles.Dt); + continue; + } + + if (Offset) { + output += current; + prev += output; + } + else + prev = output; + ParticleOpUtil.SetVector(particles, FieldOutput, p, output); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev); + } + } +} + +public sealed class C_OP_MaintainSequentialPath : ParticleOperatorInstance +{ + struct SequentialPositionContext + { + public int ParticleCount; + public float Step; + public int CountAmount; + public int Padding; + public Vector3 PrevPosStart; + public Vector3 PrevPosEnd; + } + + public float MaxDistance; + public float NumToAssign; + public float CohesionStrength; + public float Tolerance; + public bool Loop; + public bool UseParticleCount; + public PathParameters PathParams; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Maintain Position Along Path", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("maximum distance", "0", (o, v) => o.MaxDistance = v) + .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v) + .Int("start control point number", "0", (o, v) => o.PathParams.StartControlPointNumber = v) + .Int("end control point number", "0", (o, v) => o.PathParams.EndControlPointNumber = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v) + .Float("particles to map from start to end", "100", (o, v) => o.NumToAssign = v) + .Bool("restart behavior (0 = bounce, 1 = loop )", "1", (o, v) => o.Loop = v) + .Float("cohesion strength", "1", (o, v) => o.CohesionStrength = v) + .Bool("use existing particle count", "0", (o, v) => o.UseParticleCount = v) + .Float("control point movement tolerance", "0", (o, v) => o.Tolerance = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + public override void InitParams(ParticleSystemDefinition def, Element element) => PathParams.ClampControlPointIndices(); + + public override ulong GetReadControlPointMask() { + ulong startMask = (1UL << PathParams.StartControlPointNumber) - 1; + ulong endMask = (1UL << ((PathParams.EndControlPointNumber + 1) & 0x3f)) - 1; + return endMask & ~startMask; + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref SequentialPositionContext ctx = ref ParticleOpUtil.Context(context); + ctx.ParticleCount = 0; + ctx.Step = NumToAssign > 1.0f ? 1.0f / (NumToAssign - 1.0f) : 0.0f; + ctx.CountAmount = 1; + if (Tolerance > 0.0f) { + ctx.PrevPosStart = ParticleInitUtil.Vec3Invalid; + ctx.PrevPosEnd = ParticleInitUtil.Vec3Invalid; + } + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref SequentialPositionContext ctx = ref ParticleOpUtil.Context(context); + if (Tolerance > 0.0f) { + Vector3 start = particles.GetControlPointAtCurrentTime(PathParams.StartControlPointNumber); + Vector3 end = particles.GetControlPointAtCurrentTime(PathParams.EndControlPointNumber); + if ((start - ctx.PrevPosStart).Length() < Tolerance && (end - ctx.PrevPosEnd).Length() < Tolerance) + return; + ctx.PrevPosStart = start; + ctx.PrevPosEnd = end; + } + + float cohesion = 1.0f - CohesionStrength; + float numToAssign = NumToAssign; + if (UseParticleCount) { + numToAssign = particles.ActiveParticles; + ctx.Step = numToAssign > 1.0f ? 1.0f / (numToAssign - 1.0f) : 0.0f; + } + + for (int p = 0; p < particles.ActiveParticles; p++) { + particles.CalculatePathValues(PathParams, particles.CurTime, out Vector3 startPnt, out Vector3 midP, out Vector3 endPnt); + if (ctx.ParticleCount >= numToAssign || ctx.ParticleCount < 0) { + if (Loop) + ctx.ParticleCount = 0; + else { + ctx.CountAmount = -ctx.CountAmount; + ctx.ParticleCount = Math.Max(1, (int)MathF.Min(ctx.ParticleCount, numToAssign - 1.0f)); + } + } + + float t = ctx.ParticleCount * ctx.Step; + Vector3 l0 = startPnt + t * (midP - startPnt); + Vector3 l1 = midP + t * (endPnt - midP); + Vector3 pnt = l0 + (l1 - l0) * t; + + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - pnt; + Vector3 pxyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) - pnt; + float xyzOffset = MathF.Min(xyz.Length(), MaxDistance); + float pxyzOffset = MathF.Min(pxyz.Length(), MaxDistance); + MathLib.VectorNormalize(ref xyz); + MathLib.VectorNormalize(ref pxyz); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz * (xyzOffset * cohesion) + pnt); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, pxyz * (pxyzOffset * cohesion) + pnt); + ctx.ParticleCount += ctx.CountAmount; + } + } +} + +public sealed class C_OP_LockToSavedSequentialPath : ParticleOperatorInstance +{ + public bool CPPairs; + public PathParameters PathParams; + int PathCount; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Lock to Saved Position Along Path", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v) + .Int("start control point number", "0", (o, v) => o.PathParams.StartControlPointNumber = v) + .Int("end control point number", "1", (o, v) => o.PathParams.EndControlPointNumber = v) + .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v) + .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v) + .Bool("Use sequential CP pairs between start and end point", "0", (o, v) => o.CPPairs = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK; + public override int GetRequiredContextBytes() => Unsafe.SizeOf() * MAX_PARTICLE_CONTROL_POINTS * 3; + + public override ulong GetReadControlPointMask() { + ulong startMask = (1UL << PathParams.StartControlPointNumber) - 1; + ulong endMask = CPPairs ? ulong.MaxValue : (1UL << ((PathParams.EndControlPointNumber + 1) & 0x3f)) - 1; + return endMask & ~startMask; + } + + public override void InitParams(ParticleSystemDefinition def, Element element) { + PathParams.ClampControlPointIndices(); + PathCount = CPPairs ? Math.Max(1, PathParams.EndControlPointNumber - PathParams.StartControlPointNumber) : 1; + } + + static Span Points(Span context) => System.Runtime.InteropServices.MemoryMarshal.Cast(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + Span prevStart = Points(context)[..MAX_PARTICLE_CONTROL_POINTS]; + for (int i = 0; i < PathCount; i++) + prevStart[i] = ParticleInitUtil.Vec3Invalid; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Span points = Points(context); + Span prevStart = points[..MAX_PARTICLE_CONTROL_POINTS]; + Span prevMid = points.Slice(MAX_PARTICLE_CONTROL_POINTS, MAX_PARTICLE_CONTROL_POINTS); + Span prevEnd = points.Slice(MAX_PARTICLE_CONTROL_POINTS * 2, MAX_PARTICLE_CONTROL_POINTS); + + Span startPnt = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span midP = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span endPnt = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span delta0 = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span delta1 = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span prevDelta0 = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + Span prevDelta1 = stackalloc Vector3[MAX_PARTICLE_CONTROL_POINTS]; + + for (int i = 0; i < PathCount; i++) { + PathParameters current = PathParams; + if (CPPairs) { + current.StartControlPointNumber += i; + current.EndControlPointNumber = current.StartControlPointNumber + 1; + } + particles.CalculatePathValues(current, particles.CurTime, out startPnt[i], out midP[i], out endPnt[i]); + if (prevStart[i] == ParticleInitUtil.Vec3Invalid) + particles.CalculatePathValues(current, particles.CurTime - particles.Dt, out prevStart[i], out prevMid[i], out prevEnd[i]); + delta0[i] = midP[i] - startPnt[i]; + delta1[i] = endPnt[i] - midP[i]; + prevDelta0[i] = prevMid[i] - prevStart[i]; + prevDelta1[i] = prevEnd[i] - prevMid[i]; + } + + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 saved = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p); + float bias = MathF.Min(ParticleOpUtil.Age(particles, p), particles.Dt) / particles.Dt; + float t = saved.X; + int cp = Math.Min((int)MathF.Max(0.0f, saved.Y - PathParams.StartControlPointNumber), MAX_PARTICLE_CONTROL_POINTS - 1); + + Vector3 prevL0 = prevStart[cp] + t * prevDelta0[cp]; + Vector3 prevL1 = prevMid[cp] + t * prevDelta1[cp]; + Vector3 prevPnt = prevL0 + (prevL1 - prevL0) * t; + Vector3 l0 = startPnt[cp] + t * delta0[cp]; + Vector3 l1 = midP[cp] + t * delta1[cp]; + Vector3 pnt = (l0 + (l1 - l0) * t - prevPnt) * bias; + + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + pnt); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + pnt); + } + + for (int i = 0; i < PathCount; i++) { + prevStart[i] = startPnt[i]; + prevMid[i] = midP[i]; + prevEnd[i] = endPnt[i]; + } + } +} + +public sealed class C_OP_NormalLock : ParticleOperatorInstance +{ + public int ControlPointNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Normal Lock to Control Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_NORMAL_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber; + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber); + + public override void InitializeContextData(ParticleCollection particles, Span context) => + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.CurTime, out ParticleOpUtil.Context(context)); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref Matrix3x4 prevTransform = ref ParticleOpUtil.Context(context); + particles.GetControlPointTransformAtTime(ControlPointNumber, particles.CurTime, out Matrix3x4 current); + MathLib.MatrixInvert(prevTransform, out Matrix3x4 inverse); + MathLib.ConcatTransforms(current, inverse, out Matrix3x4 delta); + + for (int p = 0; p < particles.ActiveParticles; p++) { + float bias = MathF.Min(ParticleOpUtil.Age(particles, p), particles.Dt) / particles.Dt; + Vector3 normal = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_NORMAL, p); + Vector3 rotated = ParticleOpUtil.Rotate(normal, delta); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_NORMAL, p, normal + (rotated - normal) * bias); + } + + prevTransform = current; + } +} + +public sealed class C_OP_SetControlPointToImpactPoint : ParticleOperatorInstance +{ + public int CPOut; + public int CPIn; + public float UpdateRate; + public float TraceLength; + public float Offset; + public Vector3 TraceDir; + public string CollisionGroupName = "NONE"; + int CollisionGroupNumber; + + public static readonly ParticleOperatorDefinition Definition = new("Set Control Point to Impact Point", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Control Point to Set", "1", (o, v) => o.CPOut = v) + .Int("Control Point to Trace From", "1", (o, v) => o.CPIn = v) + .Vector3("Trace Direction Override", "0 0 0", (o, v) => o.TraceDir = v) + .Float("Trace Update Rate", "0.5", (o, v) => o.UpdateRate = v) + .Float("Max Trace Length", "1024", (o, v) => o.TraceLength = v) + .Float("Offset End Point Amount", "0", (o, v) => o.Offset = v) + .String("trace collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override bool ShouldRunBeforeEmitters() => true; + public override int GetRequiredContextBytes() => sizeof(float); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + CPIn = ParticleOpUtil.ClampCP(CPIn); + CPOut = ParticleOpUtil.ClampCP(CPOut); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) => ParticleOpUtil.Context(context) = -UpdateRate; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref float nextUpdateTime = ref ParticleOpUtil.Context(context); + if (nextUpdateTime > particles.CurTime) + return; + + Vector3 dir = TraceDir; + if (dir == Vector3.Zero) + particles.GetControlPointOrientationAtTime(CPIn, particles.CurTime, out dir, out _, out _); + + Vector3 start = particles.GetControlPointAtCurrentTime(CPIn); + GameTrace trace = new(); + particles.Mgr!.Query().TraceLine(start, start + dir * TraceLength, Mask.All, null, CollisionGroupNumber, ref trace); + + Vector3 normal = trace.Plane.Normal; + MathLib.VectorVectors(normal, out Vector3 right, out Vector3 up); + particles.SetControlPoint(CPOut, trace.EndPos - dir * Offset); + particles.SetControlPointOrientation(CPOut, normal, right, up); + nextUpdateTime = UpdateRate + particles.CurTime; + } +} diff --git a/Source.Particles/BuiltinParticleOperators.Transform.cs b/Source.Particles/BuiltinParticleOperators.Transform.cs new file mode 100644 index 00000000..6327a5b3 --- /dev/null +++ b/Source.Particles/BuiltinParticleOperators.Transform.cs @@ -0,0 +1,615 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +internal static class ParticleRotationUtil +{ + public static Matrix3x4 RotationAboutAxis(in Vector3 axis, float angleDegrees) { + float radians = angleDegrees * (MathF.PI / 180.0f); + float sin = MathF.Sin(radians); + float cos = MathF.Cos(radians); + float xx = axis.X * axis.X; + float yy = axis.Y * axis.Y; + float zz = axis.Z * axis.Z; + float oneMinusCos = 1 - cos; + return new Matrix3x4( + xx + (1 - xx) * cos, axis.X * axis.Y * oneMinusCos - axis.Z * sin, axis.Z * axis.X * oneMinusCos + axis.Y * sin, 0, + axis.X * axis.Y * oneMinusCos + axis.Z * sin, yy + (1 - yy) * cos, axis.Y * axis.Z * oneMinusCos - axis.X * sin, 0, + axis.Z * axis.X * oneMinusCos - axis.Y * sin, axis.Y * axis.Z * oneMinusCos + axis.X * sin, zz + (1 - zz) * cos, 0); + } + + public static float OrientRotation(Vector3 direction, float current, float rotOffset, float spinStrength) { + direction.Z = 0.0f; + direction = ParticleOpUtil.NormalizeOrZero(direction); + float velRot = MathF.Atan2(direction.Y, direction.X) + MathF.PI + rotOffset; + return ParticleOpUtil.Lerp(spinStrength, current, velRot); + } +} + +public sealed class C_OP_MovementMaintainOffset : ParticleOperatorInstance +{ + public Vector3 Offset; + public int CP; + public bool RadiusScale; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Maintain Offset", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Local Space CP", "-1", (o, v) => o.CP = v) + .Vector3("Desired Offset", "0 0 0", (o, v) => o.Offset = v) + .Bool("Scale by Radius", "0", (o, v) => o.RadiusScale = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 localOffset = Offset; + if (CP > -1) { + particles.GetControlPointTransformAtCurrentTime(Math.Min(CP, MAX_PARTICLE_CONTROL_POINTS - 1), out Matrix3x4 mat); + localOffset = ParticleOpUtil.Rotate(Offset, mat); + } + int count = particles.ActiveParticles; + Vector3 offsetPos = localOffset * (count - 1) / 2; + Vector3 avgPos = Vector3.Zero, avgPrevPos = Vector3.Zero; + for (int p = 0; p < count; p++) { + avgPos += particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + avgPrevPos += particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + } + avgPos /= count; + avgPrevPos /= count; + for (int p = 0; p < count; p++) { + float radius = RadiusScale ? particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p) : 1.0f; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, avgPos + offsetPos * radius); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, avgPrevPos + offsetPos * radius); + offsetPos -= localOffset; + } + } +} + +public sealed class C_OP_MovementPlaceOnGround : ParticleOperatorInstance +{ + struct PlaceOnGroundContext + { + public Vector3 PrevPos1; + public Vector3 PrevPos2; + public Vector3 PrevPosLerp; + public float LerpTime; + } + + public float Offset; + public float MaxTraceLength; + public float Tolerance; + public float TraceOffset; + public float LerpRate; + public string CollisionGroupName = "NONE"; + public int RefCP1; + public int RefCP2; + public int LerpCP; + public bool Kill; + public bool IncludeWater; + int CollisionGroupNumber; + Mask CollisionMask; + bool UsesCPs; + bool UsesLerp; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Place On Ground", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("offset", "0", (o, v) => o.Offset = v) + .Bool("kill on no collision", "0", (o, v) => o.Kill = v) + .Bool("include water", "0", (o, v) => o.IncludeWater = v) + .Float("max trace length", "128", (o, v) => o.MaxTraceLength = v) + .Float("trace offset", "64", (o, v) => o.TraceOffset = v) + .String("collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v) + .Int("reference CP 1", "-1", (o, v) => o.RefCP1 = v) + .Int("reference CP 2", "-1", (o, v) => o.RefCP2 = v) + .Float("CP movement tolerance", "32", (o, v) => o.Tolerance = v) + .Float("interpolation rate", "0", (o, v) => o.LerpRate = v) + .Int("interploation distance tolerance cp", "-1", (o, v) => o.LerpCP = v)); + + public override uint GetWrittenAttributes() => 0x208007; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK; + public override ulong GetReadControlPointMask() => (RefCP1 != -1 ? ParticleOpUtil.CPMask(RefCP1) : 0) | (RefCP2 != -1 ? ParticleOpUtil.CPMask(RefCP2) : 0) | (LerpCP != -1 ? ParticleOpUtil.CPMask(LerpCP) : 0); + public override int GetRequiredContextBytes() => System.Runtime.CompilerServices.Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName); + CollisionMask = IncludeWater ? Mask.ShotHull | Mask.SplitAreaPortal : Mask.ShotHull; + UsesCPs = (RefCP1 > -1 || RefCP2 > -1 || LerpCP > -1) && Tolerance > 0; + UsesLerp = LerpCP > -1 || LerpRate > 0; + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref PlaceOnGroundContext ctx = ref ParticleOpUtil.Context(context); + ctx.PrevPos1 = ParticleInitUtil.Vec3Invalid; + ctx.PrevPos2 = ParticleInitUtil.Vec3Invalid; + ctx.PrevPosLerp = ParticleInitUtil.Vec3Invalid; + ctx.LerpTime = particles.CurTime; + } + + bool CheckMoved(ParticleCollection particles, int cp, ref Vector3 prev) { + Vector3 position = particles.GetControlPointAtCurrentTime(cp); + if (!((position - prev).Length() > Tolerance)) + return false; + prev = position; + return true; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref PlaceOnGroundContext ctx = ref ParticleOpUtil.Context(context); + bool dirty = false; + if (UsesCPs) { + if (RefCP1 > -1 && CheckMoved(particles, RefCP1, ref ctx.PrevPos1)) { + dirty = true; + ctx.LerpTime = particles.CurTime; + } + if (RefCP2 > -1 && CheckMoved(particles, RefCP2, ref ctx.PrevPos2)) { + dirty = true; + ctx.LerpTime = particles.CurTime; + } + if (LerpCP > -1) + CheckMoved(particles, LerpCP, ref ctx.PrevPosLerp); + } + else if (!UsesLerp) + dirty = true; + + float perc = 0; + if (UsesLerp) { + if (LerpRate > 0) { + perc = ParticleOpUtil.RemapClamped(particles.CurTime, ctx.LerpTime, ctx.LerpTime + LerpRate, 0.0f, 1.0f); + if (perc == 1.0f && !UsesCPs) { + dirty = true; + ctx.LerpTime = particles.CurTime; + } + } + else if (LerpCP > -1) + perc = Math.Clamp((particles.GetControlPointAtCurrentTime(LerpCP) - ctx.PrevPosLerp).Length() / Tolerance, 0.0f, 1.0f); + } + + if (!dirty && !UsesLerp) + return; + + IParticleSystemQuery query = particles.Mgr!.Query(); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prevPosition = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 desiredZ = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p); + if (UsesLerp && desiredZ.Y != 1) { + desiredZ = new Vector3(position.Z, 1, position.Z); + dirty = true; + } + if (dirty) { + Vector3 tracePos = position; + tracePos.Z += TraceOffset; + GameTrace trace = new(); + query.TraceLine(tracePos, tracePos + new Vector3(0, 0, -1) * MaxTraceLength, CollisionMask, null, CollisionGroupNumber, ref trace); + if (trace.Fraction == 1.0f && Kill) + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = -1.0f; + else { + float endZ = trace.EndPos.Z + Offset; + if (UsesLerp) { + desiredZ.X = desiredZ.Z; + desiredZ.Z = endZ; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p, desiredZ); + } + else { + position.Z = endZ; + prevPosition.Z = endZ; + } + } + } + if (UsesLerp) { + position.Z = ParticleOpUtil.Lerp(perc, desiredZ.X, desiredZ.Z); + prevPosition.Z = position.Z; + } + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prevPosition); + } + } +} + +public sealed class C_OP_InheritFromParentParticles : ParticleOperatorInstance +{ + public float Scale; + public int FieldOutput; + public int Increment; + public bool RandomDistribution; + + public static readonly ParticleOperatorDefinition Definition = new("Inherit Attribute From Parent Particle", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Inherited Field", "3", (o, v) => o.FieldOutput = v) + .Float("Scale", "1", (o, v) => o.Scale = v) + .Bool("Random Parent Particle Distribution", "0", (o, v) => o.RandomDistribution = v) + .Int("Particle Increment Amount", "1", (o, v) => o.Increment = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override int GetRequiredContextBytes() => sizeof(int); + public override void InitializeContextData(ParticleCollection particles, Span context) => ParticleOpUtil.Context(context) = 0; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ParticleCollection? parent = particles.Parent; + if (parent == null || parent.ActiveParticles == 0) + return; + ref int current = ref ParticleOpUtil.Context(context); + int lastParent = Math.Max(0, parent.ActiveParticles - 1); + for (int p = 0; p < particles.ActiveParticles; p++) { + if (RandomDistribution) + current = particles.RandomInt(0, lastParent); + else if (current > lastParent) + current = 0; + if (ParticleOpUtil.IsVectorAttribute(FieldOutput)) { + Vector3 value = parent.GetVectorAttributeValue(FieldOutput, current) * Scale; + if ((ParticleOpUtil.ATTRIBUTES_WHICH_ARE_COLOR_AND_OPACITY & (1 << FieldOutput)) != 0) + value = Vector3.Max(Vector3.Min(value, Vector3.One), Vector3.Zero); + particles.SetVectorAttribute(FieldOutput, p, value); + } + else { + float value = parent.GetFloatAttributeValue(FieldOutput, current) * Scale; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) + value = Math.Clamp(value, 0.0f, 1.0f); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value; + } + current += Increment; + } + } +} + +public sealed class C_OP_OrientTo2dDirection : ParticleOperatorInstance +{ + public float RotOffset; + public float SpinStrength; + public int FieldOutput; + + public static readonly ParticleOperatorDefinition Definition = new("Rotation Orient to 2D Direction", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Rotation Offset", "0", (o, v) => o.RotOffset = v) + .Float("Spin Strength", "1", (o, v) => o.SpinStrength = v) + .Int("rotation field", "4", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float rotOffset = RotOffset * (MathF.PI / 180.0f); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 velocity = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + ref float roll = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + roll = ParticleRotationUtil.OrientRotation(velocity, roll, rotOffset, SpinStrength); + } + } +} + +public sealed class C_OP_Orient2DRelToCP : ParticleOperatorInstance +{ + public float RotOffset; + public float SpinStrength; + public int CP; + public int FieldOutput; + + public static readonly ParticleOperatorDefinition Definition = new("Rotation Orient Relative to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Rotation Offset", "0", (o, v) => o.RotOffset = v) + .Float("Spin Strength", "1", (o, v) => o.SpinStrength = v) + .Int("Control Point", "0", (o, v) => o.CP = v) + .Int("rotation field", "4", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << CP; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + CP = ParticleOpUtil.ClampCP(CP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float rotOffset = RotOffset * (MathF.PI / 180.0f); + Vector3 cp = particles.GetControlPointAtCurrentTime(CP); + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 direction = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - cp; + ref float roll = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + roll = ParticleRotationUtil.OrientRotation(direction, roll, rotOffset, SpinStrength); + } + } +} + +public sealed class C_OP_RestartAfterDuration : ParticleOperatorInstance +{ + struct RestartContext + { + public float LastRestart; + public float RestartDuration; + } + + public float DurationMin; + public float DurationMax; + public int CP; + public int CPField; + public int ChildGroupID; + public bool OnlyChildren; + + public static readonly ParticleOperatorDefinition Definition = new("Restart Effect after Duration", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Minimum Restart Time", "0", (o, v) => o.DurationMin = v) + .Float("Maximum Restart Time", "1", (o, v) => o.DurationMax = v) + .Int("Control Point to Scale Duration", "-1", (o, v) => o.CP = v) + .Int("Control Point Field X/Y/Z", "0", (o, v) => o.CPField = v) + .Bool("Only Restart Children", "0", (o, v) => o.OnlyChildren = v) + .Int("Child Group ID", "0", (o, v) => o.ChildGroupID = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(CP); + public override int GetRequiredContextBytes() => System.Runtime.CompilerServices.Unsafe.SizeOf(); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CP = Math.Clamp(CP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + CPField = Math.Clamp(CPField, 0, 2); + } + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref RestartContext ctx = ref ParticleOpUtil.Context(context); + ctx.RestartDuration = particles.RandomFloat(DurationMin, DurationMax); + ctx.LastRestart = 0; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (particles.EmissionStopped) + return; + ref RestartContext ctx = ref ParticleOpUtil.Context(context); + float duration = ctx.RestartDuration; + if (CP > -1) + duration *= ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(CP), CPField); + if (!(particles.CurTime > duration + ctx.LastRestart)) + return; + if (OnlyChildren) { + for (ParticleCollection? child = particles.Children; child != null; child = child.Next) { + if (child.GetGroupID() == ChildGroupID) + child.Restart(); + } + } + else + particles.Restart(); + ctx.LastRestart = particles.CurTime; + ctx.RestartDuration = particles.RandomFloat(DurationMin, DurationMax); + } +} + +public sealed class C_OP_StopAfterCPDuration : ParticleOperatorInstance +{ + public float Duration; + public int CP; + public int CPField; + public bool DestroyImmediately; + + public static readonly ParticleOperatorDefinition Definition = new("Stop Effect after Duration", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Duration at which to Stop", "1", (o, v) => o.Duration = v) + .Int("Control Point to Scale Duration", "-1", (o, v) => o.CP = v) + .Int("Control Point Field X/Y/Z", "0", (o, v) => o.CPField = v) + .Bool("Destroy All Particles Immediately", "0", (o, v) => o.DestroyImmediately = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(CP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + CP = Math.Clamp(CP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + CPField = Math.Clamp(CPField, 0, 2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (particles.EmissionStopped) + return; + float duration = Duration; + if (CP > -1) + duration *= ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(CP), CPField); + if (particles.CurTime > duration) + particles.StopEmission(false, DestroyImmediately, true); + } +} + +public sealed class C_OP_SetControlPointRotation : ParticleOperatorInstance +{ + public Vector3 RotAxis; + public float RotRate; + public int CP; + public int LocalCP; + + public static readonly ParticleOperatorDefinition Definition = new("Set Control Point Rotation", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("Rotation Axis", "0 0 1", (o, v) => o.RotAxis = v) + .Float("Rotation Rate", "180", (o, v) => o.RotRate = v) + .Int("Control Point", "0", (o, v) => o.CP = v) + .Int("Local Space Control Point", "-1", (o, v) => o.LocalCP = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(CP) | (LocalCP != -1 ? ParticleOpUtil.CPMask(LocalCP) : 0); + public override bool ShouldRunBeforeEmitters() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + MathLib.VectorNormalize(ref RotAxis); + CP = ParticleOpUtil.ClampCP(CP); + LocalCP = Math.Clamp(LocalCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 axis = RotAxis; + if (LocalCP > -1) { + particles.GetControlPointTransformAtCurrentTime(LocalCP, out Matrix3x4 localMat); + axis = ParticleOpUtil.Rotate(RotAxis, localMat); + } + particles.GetControlPointTransformAtCurrentTime(CP, out Matrix3x4 cpMat); + Matrix3x4 rot = ParticleRotationUtil.RotationAboutAxis(axis, RotRate * particles.Dt); + MathLib.ConcatTransforms(cpMat, rot, out Matrix3x4 result); + MathLib.MatrixAngles(result, out Quaternion q, out _); + particles.SetControlPointOrientation(CP, q); + } +} + +public sealed class C_OP_MovementRotateParticleAroundAxis : ParticleOperatorInstance +{ + public Vector3 RotAxis; + public float RotRate; + public int CP; + public bool LocalSpace; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Rotate Particle Around Axis", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("Rotation Axis", "0 0 1", (o, v) => o.RotAxis = v) + .Float("Rotation Rate", "180", (o, v) => o.RotRate = v) + .Int("Control Point", "0", (o, v) => o.CP = v) + .Bool("Use Local Space", "0", (o, v) => o.LocalSpace = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override ulong GetReadControlPointMask() => 1UL << CP; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + MathLib.VectorNormalize(ref RotAxis); + CP = ParticleOpUtil.ClampCP(CP); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 axis = RotAxis; + if (LocalSpace) { + particles.GetControlPointTransformAtCurrentTime(CP, out Matrix3x4 localMat); + axis = ParticleOpUtil.Rotate(RotAxis, localMat); + } + Matrix3x4 rot = ParticleRotationUtil.RotationAboutAxis(axis, RotRate * particles.Dt); + Vector3 cp = particles.GetControlPointAtCurrentTime(CP); + int count = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < count; p++) { + Vector3 xyz = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 cur = (ParticleOpUtil.Rotate(xyz - cp, rot) + cp - xyz) * opStrength; + Vector3 prevDelta = (ParticleOpUtil.Rotate(prev - cp, rot) + cp - prev) * opStrength; + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, xyz + cur); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, prev + prevDelta); + } + } +} + +public sealed class C_OP_RotateVector : ParticleOperatorInstance +{ + public int FieldOutput; + public Vector3 RotAxisMin; + public Vector3 RotAxisMax; + public float RotRateMin; + public float RotRateMax; + public bool Normalize; + + public static readonly ParticleOperatorDefinition Definition = new("Rotate Vector Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "21", (o, v) => o.FieldOutput = v) + .Vector3("Rotation Axis Min", "0 0 1", (o, v) => o.RotAxisMin = v) + .Vector3("Rotation Axis Max", "0 0 1", (o, v) => o.RotAxisMax = v) + .Float("Rotation Rate Min", "180", (o, v) => o.RotRateMin = v) + .Float("Rotation Rate Max", "180", (o, v) => o.RotRateMax = v) + .Float("Normalize Ouput", "0", (o, v) => o.Normalize = (BitConverter.SingleToInt32Bits(v) & 0xFF) != 0)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => (1u << FieldOutput) | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + MathLib.VectorNormalize(ref RotAxisMin); + MathLib.VectorNormalize(ref RotAxisMax); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + int particleId = particles.GetIntAttributeValue(PARTICLE_ATTRIBUTE_PARTICLE_ID, p); + float rotRate = particles.RandomFloat(particleId, RotRateMin, RotRateMax) * particles.Dt; + Vector3 axis = Vector3.Lerp(RotAxisMin, RotAxisMax, particles.RandomFloat(particleId, 0, 1)); + MathLib.VectorNormalize(ref axis); + Vector3 input = ParticleOpUtil.GetVector(particles, FieldOutput, p); + Vector3 output = ParticleOpUtil.Rotate(input, ParticleRotationUtil.RotationAboutAxis(axis, rotRate)); + if (Normalize) + MathLib.VectorNormalize(ref output); + ParticleOpUtil.SetVector(particles, FieldOutput, p, Vector3.Lerp(input, output, opStrength)); + } + } +} + +public sealed class C_OP_MaxVelocity : ParticleOperatorInstance +{ + public float MaxVelocity; + public int OverrideCP; + public int OverrideCPField; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Max Velocity", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Maximum Velocity", "0", (o, v) => o.MaxVelocity = v) + .Int("Override Max Velocity from this CP", "-1", (o, v) => o.OverrideCP = v) + .Int("Override CP field", "0", (o, v) => o.OverrideCPField = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(OverrideCP); + public override void InitParams(ParticleSystemDefinition def, Element element) => OverrideCPField = Math.Clamp(OverrideCPField, 0, 2); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float maxVelocity = MaxVelocity; + if (OverrideCP >= 0) + maxVelocity = ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(ParticleOpUtil.ClampCP(OverrideCP)), OverrideCPField); + float maxPerFrame = maxVelocity * particles.Dt; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 velocity = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - prev; + float speed = velocity.Length(); + MathLib.VectorNormalize(ref velocity); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, prev + velocity * Math.Min(speed, maxPerFrame)); + } + } +} + +public sealed class C_OP_LagCompensation : ParticleOperatorInstance +{ + public int DesiredVelocityCP; + public int LatencyCP; + public int LatencyCPField; + public int DesiredVelocityCPField; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Lag Compensation", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Desired Velocity CP", "-1", (o, v) => o.DesiredVelocityCP = v) + .Int("Desired Velocity CP Field Override(for speed only)", "-1", (o, v) => o.DesiredVelocityCPField = v) + .Int("Latency CP", "-1", (o, v) => o.LatencyCP = v) + .Int("Latency CP field", "0", (o, v) => o.LatencyCPField = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(DesiredVelocityCP) | ParticleOpUtil.CPMask(LatencyCP); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + LatencyCPField = Math.Clamp(LatencyCPField, 0, 2); + DesiredVelocityCPField = Math.Clamp(DesiredVelocityCPField, -1, 2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (DesiredVelocityCP < 0 || LatencyCP < 0) + return; + Vector3 desiredVelocity = particles.GetControlPointAtCurrentTime(ParticleOpUtil.ClampCP(DesiredVelocityCP)); + float latency = ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(ParticleOpUtil.ClampCP(LatencyCP)), LatencyCPField) + 1.1920929e-07f; + float desiredSpeed = DesiredVelocityCPField > -1 ? ParticleOpUtil.Component(desiredVelocity, DesiredVelocityCPField) : desiredVelocity.Length(); + float startSpeed = desiredSpeed * 3; + float catchupTime = latency / 1000.0f; + for (int p = 0; p < particles.ActiveParticles; p++) { + float currentSpeed = ParticleOpUtil.RemapClamped(ParticleOpUtil.Age(particles, p), 0.0f, catchupTime, startSpeed, desiredSpeed); + Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + Vector3 velocity = ParticleOpUtil.NormalizeOrZero(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - prev); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, prev + velocity * (currentSpeed * particles.Dt)); + } + } +} diff --git a/Source.Particles/BuiltinParticleOperators.cs b/Source.Particles/BuiltinParticleOperators.cs new file mode 100644 index 00000000..9df0fd39 --- /dev/null +++ b/Source.Particles/BuiltinParticleOperators.cs @@ -0,0 +1,1776 @@ +using Datamodel; + +using Source.Common; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.Intrinsics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleOperators +{ + public static void AddBuiltInParticleOperators(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_Decay.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_BasicMovement.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeAndKill.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeAndKillForTracers.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeIn.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeOut.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeInSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_FadeOutSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_ClampScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_ClampVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_OscillateScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_OscillateScalarSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_OscillateVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_OscillateVectorSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_InterpolateRadius.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_ColorInterpolate.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DifferencePreviousParticle.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LerpScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LerpEndCapScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LerpEndCapVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LerpVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapSpeed.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapSpeedtoCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapBoundingVolumetoCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapAverageScalarValuetoCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RampScalarLinear.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RampScalarSpline.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RampScalarLinearSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RampScalarSplineSimple.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_Noise.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_VectorNoise.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_VelocityDecay.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_AlphaDecay.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RadiusDecay.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DecayMaintainCount.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_Cull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_Spin.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SpinUpdate.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SpinYaw.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_PositionLock.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_ControlpointLight.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetChildControlPoints.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointsToParticle.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetPerChildControlPoint.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointPositions.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DampenToCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DistanceBetweenCPs.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DistanceBetweenCPsToCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_PercentageBetweenCPs.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_PercentageBetweenCPsVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DistanceToCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointToPlayer.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LockToBone.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_CPOffsetToPercentageBetweenCPs.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_PlaneCull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_DistanceCull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_ModelCull.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointToCenter.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_VelocityMatchingForce.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_MovementMaintainOffset.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_MovementPlaceOnGround.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_InheritFromParentParticles.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_OrientTo2dDirection.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_Orient2DRelToCP.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RestartAfterDuration.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_StopAfterCPDuration.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointRotation.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_MovementRotateParticleAroundAxis.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RotateVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_MaxVelocity.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LagCompensation.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_NormalizeVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapVelocityToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapCPVelocityToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetCPOrientationToDirection.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapDirectionToCPToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapControlPointDirectionToVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapDotProductToScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapCPtoScalar.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_RemapCPtoVector.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_MaintainSequentialPath.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_LockToSavedSequentialPath.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_NormalLock.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Operator, C_OP_SetControlPointToImpactPoint.Definition); + } +} + +internal static class ParticleOpUtil +{ + public const int MAX_GMOD_ATTRIBUTE = 21; + public const int ATTRIBUTES_WHICH_ARE_0_TO_1 = 0x10080; + public const int ATTRIBUTES_WHICH_ARE_SIZE = 0x408; + public const int ATTRIBUTES_WHICH_ARE_COLOR_AND_OPACITY = 0x100c0; + + public static int ClampField(int field) => Math.Clamp(field, 0, MAX_GMOD_ATTRIBUTE); + + public static bool IsVectorAttribute(int attribute) => (ATTRIBUTES_WHICH_ARE_VEC3S_MASK & (1 << attribute)) != 0; + + public static float SimpleSpline(float t) => t * t * 3.0f - t * 2.0f * t * t; + + public static float PreCalcBiasParameter(float bias) => 1.0f / bias - 2.0f; + + public static float Bias(float x, float biasParam) => x / ((1.0f - x) * biasParam + 1.0f); + + public static float SinEst01(float x) { + float a = MathF.Abs(x); + float rounded = BitConverter.Int32BitsToSingle(BitConverter.SingleToInt32Bits(a + 8388608.0f) & ~1) - 8388608.0f; + if (a < rounded) + rounded -= 2.0f; + a -= rounded; + bool flip = a >= 1.0f; + if (flip) + a -= 1.0f; + float value = (4.0f - a * 4.0f) * a; + return (x < 0.0f || (x == 0.0f && float.IsNegative(x))) != flip ? -value : value; + } + + public static float PowFixedPoint(float x, float exponent) => RandSIMD.PowFixedPointExponent(Vector128.Create(x), (int)(exponent * 4.0f))[0]; + + public static float Age(ParticleCollection particles, int p) => particles.CurTime - particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + + public static float Lifetime(ParticleCollection particles, int p) => particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + + public static float NormalizedAge(ParticleCollection particles, int p) => Age(particles, p) / Lifetime(particles, p); + + public static int PaddedCount(ParticleCollection particles) => particles.PaddedActiveParticles * 4; + + public static Vector3 GetVector(ParticleCollection particles, int attribute, int p) { + if (IsVectorAttribute(attribute)) + return particles.GetVectorAttributeValue(attribute, p); + return new Vector3(particles.GetFloatAttributeValue(attribute, p), 0, 0); + } + + public static void SetVector(ParticleCollection particles, int attribute, int p, Vector3 v) { + if (IsVectorAttribute(attribute)) + particles.SetVectorAttribute(attribute, p, v); + else + particles.GetFloatAttributeRefForWrite(attribute, p) = v.X; + } + + public static Vector3 GetInitialVector(ParticleCollection particles, int attribute, int p) { + if (IsVectorAttribute(attribute)) + return particles.GetInitialVectorAttributeValue(attribute, p); + return new Vector3(particles.GetInitialFloatAttributeValue(attribute, p), 0, 0); + } + + public const int ATTRIBUTES_WHICH_ARE_ANGLES = 0x101010; + public const float MIN_PARTICLE_SPEED = 0.001f; + + public static bool IsUnitAttribute(int attribute) => (ATTRIBUTES_WHICH_ARE_0_TO_1 & (1 << attribute)) != 0; + + public static void GetClampRange(int field, out float min, out float max) { + if ((ATTRIBUTES_WHICH_ARE_0_TO_1 & (1 << field)) != 0) { + min = 0.0f; + max = 1.0f; + } + else if ((ATTRIBUTES_WHICH_ARE_SIZE & (1 << field)) != 0) { + min = 0.0f; + max = float.MaxValue; + } + else { + min = -float.MaxValue; + max = float.MaxValue; + } + } + + public static float RemapClamped(float value, float inMin, float inMax, float outMin, float outMax) => ParticleInitUtil.RemapClamped(value, inMin, inMax, outMin, outMax); + + public static float Lerp(float t, float a, float b) => a + (b - a) * t; + + public static ulong CPMask(int cp) => cp >= 0 && cp < 64 ? 1UL << cp : 0; + + public static float ReadScalar(ParticleCollection particles, int attribute, int p) => ParticleInitUtil.ReadScalar(particles, attribute, p); + + public static void WriteScalar(ParticleCollection particles, int attribute, int p, float value) => ParticleInitUtil.WriteScalar(particles, attribute, p, value); + + public static void SetControlPointComponent(ParticleCollection particles, int cp, int component, float value) { + Vector3 v = particles.GetControlPointAtCurrentTime(cp); + switch (component) { + case 0: v.X = value; break; + case 1: v.Y = value; break; + default: v.Z = value; break; + } + particles.SetControlPoint(cp, v); + } + + public static float Component(in Vector3 v, int component) => component switch { 0 => v.X, 1 => v.Y, _ => v.Z }; + + public static ref T Context(Span context) where T : unmanaged => ref System.Runtime.InteropServices.MemoryMarshal.AsRef(context); + + public static int ClampCP(int cp) => Math.Clamp(cp, 0, MAX_PARTICLE_CONTROL_POINTS - 1); + + public static bool MatricesAreEqual(in Matrix3x4 a, in Matrix3x4 b, float tolerance) { + for (int r = 0; r < 3; r++) { + for (int c = 0; c < 4; c++) { + if (MathF.Abs(a[r, c] - b[r, c]) > tolerance) + return false; + } + } + return true; + } + + public static Vector3 Transform(in Vector3 v, in Matrix3x4 m) { + MathLib.VectorTransform(v, m, out Vector3 result); + return result; + } + + public static Vector3 Rotate(in Vector3 v, in Matrix3x4 m) { + MathLib.VectorRotate(v, m, out Vector3 result); + return result; + } + + public static Vector3 NormalizeOrZero(Vector3 v) { + float length = v.Length(); + return length > 0.0f ? v / length : Vector3.Zero; + } + + public static float SimpleSplineRemapValClamped(float value, float a, float b, float c, float d) { + if (a == b) + return value >= b ? d : c; + float t = Math.Clamp((value - a) / (b - a), 0.0f, 1.0f); + return c + (d - c) * SimpleSpline(t); + } +} + +public sealed class C_OP_Decay : ParticleOperatorInstance +{ + public static readonly ParticleOperatorDefinition Definition = new("Lifespan Decay", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin()); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int limit = particles.PaddedActiveParticles * 4; + for (int i = 0; i < limit; i++) { + float lifeDuration = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, i); + float age = particles.CurTime - particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, i); + if (lifeDuration <= age || lifeDuration <= 0.0f) + particles.KillParticle(i); + } + } +} + +public sealed class C_OP_BasicMovement : ParticleOperatorInstance +{ + public Vector3 Gravity; + public float Drag; + public int MaxConstraintPasses; + + public static readonly ParticleOperatorDefinition Definition = new("Movement Basic", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Vector3("gravity", "0 0 0", (o, v) => o.Gravity = v) + .Float("drag", "0", (o, v) => o.Drag = v) + .Int("max constraint passes", "3", (o, v) => o.MaxConstraintPasses = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadAttributes() => 0; + + static readonly FourVectors[] PerParticleForceAccumulator = new FourVectors[MAX_PARTICLES_IN_A_SYSTEM / 4 + 1]; + static readonly bool[] ConstraintSatisfied = new bool[MAX_PARTICLE_CONTROL_POINTS]; + static readonly bool[] FinalConstraint = new bool[MAX_PARTICLE_CONTROL_POINTS]; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ParticleSystemDefinition def = particles.Def!; + float dt = particles.Dt; + float adjustedDrag = MathF.Exp(dt * 30.0f * MathF.Log(1.0f - Math.Max(Drag, 0.0f))) * (dt / particles.PreviousDt); + int blocks = particles.PaddedActiveParticles; + + FourVectors gravity = new(Gravity); + int accumulatorStride; + if (def.ForceGenerators.Count == 0) { + PerParticleForceAccumulator[0] = gravity; + accumulatorStride = 0; + } + else { + PerParticleForceAccumulator.AsSpan(0, blocks).Fill(gravity); + for (int i = 0; i < def.ForceGenerators.Count; i++) { + ParticleOperatorInstance op = def.ForceGenerators[i]; + if (particles.CheckIfOperatorShouldRun(op, out float strength)) + op.AddForces(PerParticleForceAccumulator.AsSpan(0, blocks), particles, blocks, strength, particles.OperatorContextData.AsSpan(def.ForceGeneratorsCtxOffsets[i])); + } + accumulatorStride = 1; + } + + float dtSquared = dt * dt; + Span memory = particles.AttributeMemory; + int xyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int xyzStride); + int prevXyz = particles.GetAttributeOffset(PARTICLE_ATTRIBUTE_PREV_XYZ, out int prevXyzStride); + + for (int block = 0, accumulator = 0; block < blocks; block++, accumulator += accumulatorStride) { + ref FourVectors force = ref PerParticleForceAccumulator[accumulator]; + for (int lane = 0; lane < 4; lane++) { + for (int axis = 0; axis < 3; axis++) { + float accel = axis switch { 0 => force.x[lane], 1 => force.y[lane], _ => force.z[lane] }; + ref float prev = ref memory[prevXyz + axis * 4 + lane]; + float cur = memory[xyz + axis * 4 + lane]; + prev = (cur - prev) * adjustedDrag + accel * dtSquared + cur; + } + } + xyz += xyzStride; + prevXyz += prevXyzStride; + } + + particles.SwapPosAndPrevPos(); + + int constraintCount = def.Constraints.Count; + if (constraintCount == 0 || particles.PaddedActiveParticles == 0) + return; + + for (int i = 0; i < constraintCount; i++) { + ParticleOperatorInstance op = def.Constraints[i]; + FinalConstraint[i] = op.IsFinalConstraint(); + ConstraintSatisfied[i] = false; + op.SetupConstraintPerFrameData(particles, particles.OperatorContextData.AsSpan(def.ConstraintsCtxOffsets[i])); + } + + for (int pass = 0; pass < MaxConstraintPasses; pass++) { + for (int i = 0; i < constraintCount; i++) { + if (ConstraintSatisfied[i]) + continue; + ConstraintSatisfied[i] = true; + + ParticleOperatorInstance op = def.Constraints[i]; + if (FinalConstraint[i] || !particles.CheckIfOperatorShouldRun(op, out _)) + continue; + if (!op.EnforceConstraint(0, particles.PaddedActiveParticles, particles, particles.OperatorContextData.AsSpan(def.ConstraintsCtxOffsets[i]), particles.ActiveParticles)) + continue; + + for (int j = 0; j < constraintCount; j++) { + if (j != i) + ConstraintSatisfied[j] = false; + } + } + } + + for (int i = 0; i < constraintCount; i++) { + if (!FinalConstraint[i]) + continue; + ParticleOperatorInstance op = def.Constraints[i]; + if (particles.CheckIfOperatorShouldRun(op, out _)) + op.EnforceConstraint(0, particles.PaddedActiveParticles, particles, particles.OperatorContextData.AsSpan(def.ConstraintsCtxOffsets[i]), particles.ActiveParticles); + } + } +} + +public abstract class C_OP_FadeAndKillBase : ParticleOperatorInstance +{ + public float StartFadeInTime; + public float EndFadeInTime; + public float StartFadeOutTime; + public float EndFadeOutTime; + public float StartAlpha; + public float EndAlpha; + + protected static DmxElementUnpackStructure Unpack() where T : C_OP_FadeAndKillBase + => ParticleOperatorUnpack.Begin() + .Float("start_alpha", "1", (o, v) => o.StartAlpha = v) + .Float("end_alpha", "0", (o, v) => o.EndAlpha = v) + .Float("start_fade_in_time", "0", (o, v) => o.StartFadeInTime = v) + .Float("end_fade_in_time", "0.5", (o, v) => o.EndFadeInTime = v) + .Float("start_fade_out_time", "0.5", (o, v) => o.StartFadeOutTime = v) + .Float("end_fade_out_time", "1", (o, v) => o.EndFadeOutTime = v); + + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + if (EndFadeInTime < StartFadeInTime) + EndFadeInTime = StartFadeInTime; + if (EndFadeOutTime < StartFadeOutTime) + EndFadeOutTime = StartFadeOutTime; + if (StartFadeOutTime < StartFadeInTime) + (StartFadeInTime, StartFadeOutTime) = (StartFadeOutTime, StartFadeInTime); + if (EndFadeOutTime < EndFadeInTime) + (EndFadeInTime, EndFadeOutTime) = (EndFadeOutTime, EndFadeInTime); + } + + protected static float SplineRemapClamped(float value, float a, float oneOverRange, float c, float deltaC) + => c + deltaC * ParticleOpUtil.SimpleSpline(Math.Clamp((value - a) * oneOverRange, 0.0f, 1.0f)); + + protected bool FadeParticle(ParticleCollection particles, int p) { + float age = ParticleOpUtil.Age(particles, p); + float lifetime = ParticleOpUtil.Lifetime(particles, p); + bool kill = lifetime <= age; + float t = age / lifetime; + if (kill) + return true; + + float initialAlpha = particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p); + ref float alpha = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ALPHA, p); + if (StartFadeInTime <= t && t < EndFadeInTime) { + float goal = initialAlpha * StartAlpha; + alpha = SplineRemapClamped(t, StartFadeInTime, 1.0f / (EndFadeInTime - StartFadeInTime), goal, initialAlpha - goal); + } + if (StartFadeOutTime <= t && t < EndFadeOutTime) { + float goal = initialAlpha * EndAlpha; + alpha = SplineRemapClamped(t, StartFadeOutTime, 1.0f / (EndFadeOutTime - StartFadeOutTime), initialAlpha, goal - initialAlpha); + } + return false; + } +} + +public sealed class C_OP_FadeAndKill : C_OP_FadeAndKillBase +{ + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade and Decay", ParticleOperatorId.Generic, false, Unpack()); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + if (FadeParticle(particles, p)) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_FadeAndKillForTracers : C_OP_FadeAndKillBase +{ + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade and Decay for Tracers", ParticleOperatorId.Generic, false, Unpack()); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int limit = ParticleOpUtil.PaddedCount(particles); + float previousTime = particles.CurTime - particles.Dt; + for (int p = 0; p < limit; p++) { + if (!FadeParticle(particles, p)) + continue; + + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float previousAge = previousTime - creationTime; + if (previousAge < lifetime) { + float fraction = (lifetime - previousAge) / particles.Dt; + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p); + Vector3 previous = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, (position - previous) * fraction + previous); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, p) *= fraction; + } + else + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_FadeIn : ParticleOperatorInstance +{ + public float FadeInTimeMin; + public float FadeInTimeMax; + public float FadeInTimeExp; + public bool Proportional; + + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade In Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("fade in time min", ".25", (o, v) => o.FadeInTimeMin = v) + .Float("fade in time max", ".25", (o, v) => o.FadeInTimeMax = v) + .Float("fade in time exponent", "1", (o, v) => o.FadeInTimeExp = v) + .Bool("proportional 0/1", "1", (o, v) => o.Proportional = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float fadeInTime = ParticleOpUtil.PowFixedPoint(particles.OperatorRandomFloat(p), FadeInTimeExp) * (FadeInTimeMax - FadeInTimeMin) + FadeInTimeMin; + float lifeTime = ParticleOpUtil.Age(particles, p); + if (Proportional) + lifeTime = Math.Max(0.0f, Math.Min(1.0f, lifeTime / ParticleOpUtil.Lifetime(particles, p))); + if (fadeInTime <= lifeTime) + continue; + + float t = Math.Clamp(lifeTime / fadeInTime, 0.0f, 1.0f); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ALPHA, p) = ParticleOpUtil.SimpleSpline(t) * particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p); + } + } +} + +public sealed class C_OP_FadeOut : ParticleOperatorInstance +{ + public float FadeOutTimeMin; + public float FadeOutTimeMax; + public float FadeOutTimeExp; + public float FadeBias; + public bool Proportional; + public bool EaseInAndOut; + float BiasParam; + + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade Out Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("fade out time min", ".25", (o, v) => o.FadeOutTimeMin = v) + .Float("fade out time max", ".25", (o, v) => o.FadeOutTimeMax = v) + .Float("fade out time exponent", "1", (o, v) => o.FadeOutTimeExp = v) + .Bool("proportional 0/1", "1", (o, v) => o.Proportional = v) + .Bool("ease in and out", "1", (o, v) => o.EaseInAndOut = v) + .Float("fade bias", "0.5", (o, v) => o.FadeBias = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + BiasParam = ParticleOpUtil.PreCalcBiasParameter(FadeBias == 0.0f ? 0.5f : FadeBias); + if (FadeOutTimeMin == 0.0f && FadeOutTimeMax == 0.0f) { + FadeOutTimeMin = 1.1920929e-07f; + FadeOutTimeMax = 1.1920929e-07f; + } + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float fadeOutTime = ParticleOpUtil.PowFixedPoint(particles.OperatorRandomFloat(p), FadeOutTimeExp) * (FadeOutTimeMax - FadeOutTimeMin) + FadeOutTimeMin; + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float lifeTime = ParticleOpUtil.Age(particles, p); + float baseTime = lifetime; + if (Proportional) { + lifeTime /= lifetime; + baseTime = 1.0f; + } + + float start = baseTime - fadeOutTime; + float span = baseTime - start; + if (lifeTime <= start) + continue; + + float t = Math.Clamp((lifeTime - start) / span, 0.0f, 1.0f); + float initialAlpha = particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ALPHA, p) = EaseInAndOut + ? Math.Max(0.0f, ParticleOpUtil.SimpleSpline(t) * (0.0f - initialAlpha) + initialAlpha) + : (1.0f - ParticleOpUtil.Bias(t, BiasParam)) * initialAlpha; + } + } +} + +public sealed class C_OP_FadeInSimple : ParticleOperatorInstance +{ + public float FadeInTime; + + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade In Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("proportional fade in time", ".25", (o, v) => o.FadeInTime = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float t = Math.Max(0.0f, Math.Min(1.0f, ParticleOpUtil.NormalizedAge(particles, p))); + if (FadeInTime <= t) + continue; + float frac = Math.Min(1.0f, Math.Max(0.0f, t / FadeInTime)); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ALPHA, p) = ParticleOpUtil.SimpleSpline(frac) * particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p); + } + } +} + +public sealed class C_OP_FadeOutSimple : ParticleOperatorInstance +{ + public float FadeOutTime; + + public static readonly ParticleOperatorDefinition Definition = new("Alpha Fade Out Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("proportional fade out time", ".25", (o, v) => o.FadeOutTime = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float start = 1.0f - FadeOutTime; + for (int p = 0; p < particles.ActiveParticles; p++) { + float t = ParticleOpUtil.NormalizedAge(particles, p); + if (t <= start) + continue; + float frac = Math.Clamp((t - start) / FadeOutTime, 0.0f, 1.0f); + ref float alpha = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ALPHA, p); + alpha = Math.Min((1.0f - ParticleOpUtil.SimpleSpline(frac)) * particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p), alpha); + } + } +} + +public sealed class C_OP_ClampScalar : ParticleOperatorInstance +{ + public int FieldOutput; + public float OutputMin; + public float OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Clamp Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + ref float output = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + float clamped = Math.Min(Math.Max(output, OutputMin), OutputMax); + output = (clamped - output) * opStrength + output; + } + } +} + +public sealed class C_OP_ClampVector : ParticleOperatorInstance +{ + public int FieldOutput; + public Vector3 OutputMin; + public Vector3 OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Clamp Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 output = ParticleOpUtil.GetVector(particles, FieldOutput, p); + Vector3 clamped = Vector3.Min(Vector3.Max(output, OutputMin), OutputMax); + ParticleOpUtil.SetVector(particles, FieldOutput, p, (clamped - output) * opStrength + output); + } + } +} + +public sealed class C_OP_OscillateScalar : ParticleOperatorInstance +{ + public float RateMin; + public float RateMax; + public float FrequencyMin; + public float FrequencyMax; + public int Field; + public bool Proportional; + public bool ProportionalOp; + public float StartTimeMin; + public float StartTimeMax; + public float EndTimeMin; + public float EndTimeMax; + public float OscMult; + public float OscAdd; + + public static readonly ParticleOperatorDefinition Definition = new("Oscillate Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("oscillation field", "7", (o, v) => o.Field = v) + .Float("oscillation rate min", "0", (o, v) => o.RateMin = v) + .Float("oscillation rate max", "0", (o, v) => o.RateMax = v) + .Float("oscillation frequency min", "1", (o, v) => o.FrequencyMin = v) + .Float("oscillation frequency max", "1", (o, v) => o.FrequencyMax = v) + .Bool("proportional 0/1", "1", (o, v) => o.Proportional = v) + .Float("start time min", "0", (o, v) => o.StartTimeMin = v) + .Float("start time max", "0", (o, v) => o.StartTimeMax = v) + .Float("end time min", "1", (o, v) => o.EndTimeMin = v) + .Float("end time max", "1", (o, v) => o.EndTimeMax = v) + .Bool("start/end proportional", "1", (o, v) => o.ProportionalOp = v) + .Float("oscillation multiplier", "2", (o, v) => o.OscMult = v) + .Float("oscillation start phase", ".5", (o, v) => o.OscAdd = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => Field = ParticleOpUtil.ClampField(Field); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int offset = particles.OperatorRandomSampleOffset(); + float scale = opStrength * particles.Dt; + float cosFactor = OscMult * particles.CurTime + OscAdd; + bool clamp = (ParticleOpUtil.ATTRIBUTES_WHICH_ARE_0_TO_1 & (1 << Field)) != 0; + + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float age = ParticleOpUtil.Age(particles, p); + float lifeTime = ProportionalOp ? age / lifetime : age; + float startTime = particles.OperatorRandomFloat(p, offset + 11) * (StartTimeMax - StartTimeMin) + StartTimeMin; + float endTime = particles.OperatorRandomFloat(p, offset + 12) * (EndTimeMax - EndTimeMin) + EndTimeMin; + if (!(lifetime > 0.0f && startTime <= lifeTime && lifeTime < endTime)) + continue; + + float frequency = particles.OperatorRandomFloat(p, offset) * (FrequencyMax - FrequencyMin) + FrequencyMin; + float rate = particles.OperatorRandomFloat(p, offset + 1) * (RateMax - RateMin) + RateMin; + float cos = Proportional ? age / lifetime * frequency * OscMult + OscAdd : frequency * cosFactor; + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + float result = ParticleOpUtil.SinEst01(cos) * rate * scale + value; + value = clamp ? Math.Max(Math.Min(result, 1.0f), 0.0f) : result; + } + } +} + +public sealed class C_OP_OscillateScalarSimple : ParticleOperatorInstance +{ + public float Rate; + public float Frequency; + public int Field; + public float OscMult; + public float OscAdd; + float MinCmp; + float MaxCmp; + + public static readonly ParticleOperatorDefinition Definition = new("Oscillate Scalar Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("oscillation field", "7", (o, v) => o.Field = v) + .Float("oscillation rate", "0", (o, v) => o.Rate = v) + .Float("oscillation frequency", "1", (o, v) => o.Frequency = v) + .Float("oscillation multiplier", "2", (o, v) => o.OscMult = v) + .Float("oscillation start phase", ".5", (o, v) => o.OscAdd = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => 0; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Field = ParticleOpUtil.ClampField(Field); + MinCmp = -float.MaxValue; + MaxCmp = float.MaxValue; + if ((ParticleOpUtil.ATTRIBUTES_WHICH_ARE_0_TO_1 & (1 << Field)) != 0) { + MinCmp = 0.0f; + MaxCmp = 1.0f; + } + else if ((ParticleOpUtil.ATTRIBUTES_WHICH_ARE_SIZE & (1 << Field)) != 0) + MinCmp = 0.0f; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float amount = ParticleOpUtil.SinEst01((OscMult * particles.CurTime + OscAdd) * Frequency) * (opStrength * particles.Dt * Rate); + for (int p = 0; p < particles.ActiveParticles; p++) { + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + value = Math.Max(Math.Min(value + amount, MaxCmp), MinCmp); + } + } +} + +public sealed class C_OP_OscillateVector : ParticleOperatorInstance +{ + public Vector3 RateMin; + public Vector3 RateMax; + public Vector3 FrequencyMin; + public Vector3 FrequencyMax; + public int Field; + public bool Proportional; + public bool ProportionalOp; + public float StartTimeMin; + public float StartTimeMax; + public float EndTimeMin; + public float EndTimeMax; + public float OscMult; + public float OscAdd; + + public static readonly ParticleOperatorDefinition Definition = new("Oscillate Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("oscillation field", "0", (o, v) => o.Field = v) + .Vector3("oscillation rate min", "0 0 0", (o, v) => o.RateMin = v) + .Vector3("oscillation rate max", "0 0 0", (o, v) => o.RateMax = v) + .Vector3("oscillation frequency min", "1 1 1", (o, v) => o.FrequencyMin = v) + .Vector3("oscillation frequency max", "1 1 1", (o, v) => o.FrequencyMax = v) + .Bool("proportional 0/1", "1", (o, v) => o.Proportional = v) + .Float("start time min", "0", (o, v) => o.StartTimeMin = v) + .Float("start time max", "0", (o, v) => o.StartTimeMax = v) + .Float("end time min", "1", (o, v) => o.EndTimeMin = v) + .Float("end time max", "1", (o, v) => o.EndTimeMax = v) + .Bool("start/end proportional", "1", (o, v) => o.ProportionalOp = v) + .Float("oscillation multiplier", "2", (o, v) => o.OscMult = v) + .Float("oscillation start phase", ".5", (o, v) => o.OscAdd = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => Field = ParticleOpUtil.ClampField(Field); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int offset = particles.OperatorRandomSampleOffset(); + float scale = opStrength * particles.Dt; + float cosFactor = OscMult * particles.CurTime + OscAdd; + Vector3 frequencyWidth = FrequencyMax - FrequencyMin; + Vector3 rateWidth = RateMax - RateMin; + + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float age = ParticleOpUtil.Age(particles, p); + float lifeTime = ProportionalOp ? age / lifetime : age; + float startTime = particles.OperatorRandomFloat(p, offset + 11) * (StartTimeMax - StartTimeMin) + StartTimeMin; + float endTime = particles.OperatorRandomFloat(p, offset + 12) * (EndTimeMax - EndTimeMin) + EndTimeMin; + if (!(lifetime > 0.0f && startTime <= lifeTime && lifeTime < endTime)) + continue; + + Vector3 frequency = new Vector3(particles.OperatorRandomFloat(p, offset + 8), particles.OperatorRandomFloat(p, offset + 12), particles.OperatorRandomFloat(p, offset + 15)) * frequencyWidth + FrequencyMin; + Vector3 rate = new Vector3(particles.OperatorRandomFloat(p, offset + 3), particles.OperatorRandomFloat(p, offset + 7), particles.OperatorRandomFloat(p, offset + 9)) * rateWidth + RateMin; + Vector3 cos = Proportional ? frequency * (age / lifetime) * OscMult + new Vector3(OscAdd) : frequency * cosFactor; + Vector3 sin = new(ParticleOpUtil.SinEst01(cos.X), ParticleOpUtil.SinEst01(cos.Y), ParticleOpUtil.SinEst01(cos.Z)); + Vector3 value = sin * rate * scale + ParticleOpUtil.GetVector(particles, Field, p); + if (Field == PARTICLE_ATTRIBUTE_TINT_RGB) + value = Vector3.Clamp(value, Vector3.Zero, Vector3.One); + ParticleOpUtil.SetVector(particles, Field, p, value); + } + } +} + +public sealed class C_OP_OscillateVectorSimple : ParticleOperatorInstance +{ + public Vector3 Rate; + public Vector3 Frequency; + public int Field; + public float OscMult; + public float OscAdd; + + public static readonly ParticleOperatorDefinition Definition = new("Oscillate Vector Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("oscillation field", "0", (o, v) => o.Field = v) + .Vector3("oscillation rate", "0 0 0", (o, v) => o.Rate = v) + .Vector3("oscillation frequency", "1 1 1", (o, v) => o.Frequency = v) + .Float("oscillation multiplier", "2", (o, v) => o.OscMult = v) + .Float("oscillation start phase", ".5", (o, v) => o.OscAdd = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => 0; + public override void InitParams(ParticleSystemDefinition def, Element element) => Field = ParticleOpUtil.ClampField(Field); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float cosFactor = OscMult * particles.CurTime + OscAdd; + Vector3 cos = Frequency * cosFactor; + Vector3 amount = new Vector3(ParticleOpUtil.SinEst01(cos.X), ParticleOpUtil.SinEst01(cos.Y), ParticleOpUtil.SinEst01(cos.Z)) * Rate * (opStrength * particles.Dt); + bool clamp = (ParticleOpUtil.ATTRIBUTES_WHICH_ARE_COLOR_AND_OPACITY & (1 << Field)) != 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 value = ParticleOpUtil.GetVector(particles, Field, p) + amount; + if (clamp) + value = Vector3.Max(Vector3.Min(value, Vector3.One), Vector3.Zero); + ParticleOpUtil.SetVector(particles, Field, p, value); + } + } +} + +public sealed class C_OP_InterpolateRadius : ParticleOperatorInstance +{ + public float StartTime; + public float EndTime; + public float StartScale; + public float EndScale; + public bool EaseInAndOut; + public float ScaleBias; + float BiasParam; + + public static readonly ParticleOperatorDefinition Definition = new("Radius Scale", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("start_time", "0", (o, v) => o.StartTime = v) + .Float("end_time", "1", (o, v) => o.EndTime = v) + .Float("radius_start_scale", "1", (o, v) => o.StartScale = v) + .Float("radius_end_scale", "1", (o, v) => o.EndScale = v) + .Bool("ease_in_and_out", "0", (o, v) => o.EaseInAndOut = v) + .Float("scale_bias", "0.5", (o, v) => o.ScaleBias = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + if (ScaleBias == 0.0f) + ScaleBias = 0.5f; + BiasParam = ParticleOpUtil.PreCalcBiasParameter(ScaleBias); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (!(StartTime < EndTime)) + return; + + float oneOverDuration = 1.0f / (EndTime - StartTime); + float scaleWidth = EndScale - StartScale; + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float t = ParticleOpUtil.Age(particles, p) / lifetime; + if (!(lifetime > 0.0f && StartTime <= t && t < EndTime)) + continue; + + float frac = (t - StartTime) * oneOverDuration; + if (EaseInAndOut) + frac = ParticleOpUtil.SimpleSpline(frac); + else if (ScaleBias != 0.5f) + frac = ParticleOpUtil.Bias(frac, BiasParam); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_RADIUS, p) = (frac * scaleWidth + StartScale) * particles.GetInitialFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p); + } + } +} + +public sealed class C_OP_ColorInterpolate : ParticleOperatorInstance +{ + public Color ColorFade; + public float FadeStartTime; + public float FadeEndTime; + public int FieldOutput; + public bool EaseInOut; + Vector3 NormColorFade; + + public static readonly ParticleOperatorDefinition Definition = new("Color Fade", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Color("color_fade", "255 255 255 255", (o, v) => o.ColorFade = v) + .Float("fade_start_time", "0", (o, v) => o.FadeStartTime = v) + .Float("fade_end_time", "1", (o, v) => o.FadeEndTime = v) + .Bool("ease_in_and_out", "1", (o, v) => o.EaseInOut = v) + .Int("output field", "6", (o, v) => o.FieldOutput = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + NormColorFade = new Vector3(ColorFade.R, ColorFade.G, ColorFade.B) * 0.003921569f; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (FadeEndTime == FadeStartTime) + return; + + float oneOverDuration = 1.0f / (FadeEndTime - FadeStartTime); + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + if (!(lifetime > 0.0f)) + continue; + + float t = Math.Min(1.0f, Math.Max(0.0f, (ParticleOpUtil.Age(particles, p) / lifetime - FadeStartTime) * oneOverDuration)); + if (EaseInOut) + t = ParticleOpUtil.SimpleSpline(t); + Vector3 initial = ParticleOpUtil.GetInitialVector(particles, FieldOutput, p); + ParticleOpUtil.SetVector(particles, FieldOutput, p, (NormColorFade - initial) * t + initial); + } + } +} + +public sealed class C_OP_DifferencePreviousParticle : ParticleOperatorInstance +{ + public int FieldInput; + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public bool ScaleInitialRange; + public bool ActiveRange; + public bool SetPreviousParticle; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Difference of Sequential Particle Vector to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("difference minimum", "0", (o, v) => o.InputMin = v) + .Float("difference maximum", "128", (o, v) => o.InputMax = v) + .Int("input field", "0", (o, v) => o.FieldInput = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("only active within specified difference", "0", (o, v) => o.ActiveRange = v) + .Bool("also set ouput to previous particle", "0", (o, v) => o.SetPreviousParticle = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 1u << FieldInput; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldInput = ParticleOpUtil.ClampField(FieldInput); + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + min = Math.Clamp(OutputMin, 0.0f, 1.0f); + max = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + + Vector3 previous = ParticleInitUtil.Vec3Invalid; + int previousParticle = 0; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 input = ParticleOpUtil.GetVector(particles, FieldInput, p); + if (previous != ParticleInitUtil.Vec3Invalid) { + float distance = Vector3.Distance(previous, input); + if (!(ActiveRange && (distance < InputMin || distance > InputMax))) { + float output = ParticleOpUtil.RemapClamped(distance, InputMin, InputMax, min, max); + float output2 = output; + if (ScaleInitialRange) + output *= particles.GetFloatAttributeValue(FieldOutput, p); + particles.GetFloatAttributeRefForWrite(FieldOutput, p) = output; + if (SetPreviousParticle) + particles.GetFloatAttributeRefForWrite(FieldOutput, previousParticle) *= output2; + } + else + continue; + } + previous = input; + previousParticle = p; + } + } +} + +public sealed class C_OP_RemapScalar : ParticleOperatorInstance +{ + public int FieldInput; + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("input field", "7", (o, v) => o.FieldInput = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 1u << FieldInput; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldInput = ParticleOpUtil.ClampField(FieldInput); + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + min = Math.Clamp(OutputMin, 0.0f, 1.0f); + max = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + for (int p = 0; p < particles.ActiveParticles; p++) { + float output = ParticleOpUtil.RemapClamped(particles.GetFloatAttributeValue(FieldInput, p), InputMin, InputMax, min, max); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_LerpScalar : ParticleOperatorInstance +{ + public int FieldOutput; + public float Output; + public float StartTime; + public float EndTime; + + public static readonly ParticleOperatorDefinition Definition = new("Lerp Initial Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("start time", "0", (o, v) => o.StartTime = v) + .Float("end time", "1", (o, v) => o.EndTime = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("value to lerp to", "1", (o, v) => o.Output = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float age = ParticleOpUtil.Age(particles, p) / (ParticleOpUtil.Lifetime(particles, p) + 1.1920929e-07f); + if (age < StartTime || age > EndTime) + continue; + float output = ParticleOpUtil.RemapClamped(age, StartTime, EndTime, particles.GetInitialFloatAttributeValue(FieldOutput, p), Output); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_LerpEndCapScalar : ParticleOperatorInstance +{ + public int FieldOutput; + public float Output; + public float LerpTime; + + public static readonly ParticleOperatorDefinition Definition = new("Lerp EndCap Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("lerp time", "1", (o, v) => o.LerpTime = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("value to lerp to", "1", (o, v) => o.Output = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override int GetRequiredContextBytes() => sizeof(float); + public override void InitializeContextData(ParticleCollection particles, Span context) => BitConverter.TryWriteBytes(context, -float.MaxValue); + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (!particles.InEndCap) + return; + ref float endCapStart = ref System.Runtime.InteropServices.MemoryMarshal.Cast(context)[0]; + if (endCapStart < 0.0f) { + endCapStart = particles.CurTime; + for (int p = 0; p < particles.ActiveParticles; p++) + particles.GetInitialFloatAttributeRefForWrite(FieldOutput, p) = particles.GetFloatAttributeValue(FieldOutput, p); + } + float age = (particles.CurTime - endCapStart) / (LerpTime + 1.1920929e-07f); + if (age > 1.0f) + return; + for (int p = 0; p < particles.ActiveParticles; p++) { + float output = ParticleOpUtil.RemapClamped(age, 0.0f, 1.0f, particles.GetInitialFloatAttributeValue(FieldOutput, p), Output); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_LerpEndCapVector : ParticleOperatorInstance +{ + public int FieldOutput; + public Vector3 Output; + public float LerpTime; + + public static readonly ParticleOperatorDefinition Definition = new("Lerp EndCap Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("lerp time", "1", (o, v) => o.LerpTime = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("value to lerp to", "0 0 0", (o, v) => o.Output = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => 0; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override int GetRequiredContextBytes() => sizeof(float); + public override void InitializeContextData(ParticleCollection particles, Span context) => BitConverter.TryWriteBytes(context, -float.MaxValue); + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (!particles.InEndCap) + return; + ref float endCapStart = ref System.Runtime.InteropServices.MemoryMarshal.Cast(context)[0]; + if (endCapStart < 0.0f) { + endCapStart = particles.CurTime; + for (int p = 0; p < particles.ActiveParticles; p++) + particles.GetInitialFloatAttributeRefForWrite(FieldOutput, p) = particles.GetFloatAttributeValue(FieldOutput, p); + } + float age = (particles.CurTime - endCapStart) / (LerpTime + 1.1920929e-07f); + if (age > 1.0f) + return; + age *= opStrength; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 start = ParticleOpUtil.GetInitialVector(particles, FieldOutput, p); + ParticleOpUtil.SetVector(particles, FieldOutput, p, Vector3.Lerp(start, Output, age)); + } + } +} + +public sealed class C_OP_LerpVector : ParticleOperatorInstance +{ + public int FieldOutput; + public Vector3 Output; + public float StartTime; + public float EndTime; + + public static readonly ParticleOperatorDefinition Definition = new("Lerp Initial Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("start time", "0", (o, v) => o.StartTime = v) + .Float("end time", "1", (o, v) => o.EndTime = v) + .Int("output field", "0", (o, v) => o.FieldOutput = v) + .Vector3("value to lerp to", "0 0 0", (o, v) => o.Output = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float age = ParticleOpUtil.Age(particles, p) / (ParticleOpUtil.Lifetime(particles, p) + 1.1920929e-07f); + if (age < StartTime || age > EndTime) + continue; + float percent = ParticleOpUtil.RemapClamped(age, StartTime, EndTime, 0.0f, 1.0f) * opStrength; + Vector3 start = ParticleOpUtil.GetInitialVector(particles, FieldOutput, p); + ParticleOpUtil.SetVector(particles, FieldOutput, p, Vector3.Lerp(start, Output, percent)); + } + } +} + +public sealed class C_OP_RemapSpeed : ParticleOperatorInstance +{ + public int FieldOutput; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + public bool ScaleInitialRange; + public bool ScaleCurrent; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Speed to Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v) + .Bool("output is scalar of current value", "0", (o, v) => o.ScaleCurrent = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override uint GetReadInitialAttributes() => 1u << FieldOutput; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + InputMin = Math.Max(ParticleOpUtil.MIN_PARTICLE_SPEED, InputMin); + InputMax = Math.Max(ParticleOpUtil.MIN_PARTICLE_SPEED, InputMax); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if (ParticleOpUtil.IsUnitAttribute(FieldOutput)) { + min = Math.Clamp(OutputMin, 0.0f, 1.0f); + max = Math.Clamp(OutputMax, 0.0f, 1.0f); + } + float inputRange = InputMax == InputMin ? 1.0f : InputMax - InputMin; + for (int p = 0; p < particles.ActiveParticles; p++) { + Vector3 delta = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + float t = Math.Clamp((delta.Length() / particles.Dt - InputMin) / inputRange, 0.0f, 1.0f); + float output = t * (max - min) + min; + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (ScaleInitialRange) + output *= particles.GetInitialFloatAttributeValue(FieldOutput, p); + if (ScaleCurrent) + output *= value; + value = ParticleOpUtil.Lerp(opStrength, value, output); + } + } +} + +public sealed class C_OP_RemapSpeedtoCP : ParticleOperatorInstance +{ + public int InControlPoint; + public int OutControlPoint; + public int Field; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Remap CP Speed to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("input control point", "0", (o, v) => o.InControlPoint = v) + .Float("input minimum", "0", (o, v) => o.InputMin = v) + .Float("input maximum", "1", (o, v) => o.InputMax = v) + .Int("output control point", "-1", (o, v) => o.OutControlPoint = v) + .Int("Output field 0-2 X/Y/Z", "0", (o, v) => o.Field = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(InControlPoint) | ParticleOpUtil.CPMask(OutControlPoint); + public override bool ShouldRunBeforeEmitters() => true; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + if (InControlPoint == OutControlPoint) + OutControlPoint = -1; + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (OutControlPoint < 0) + return; + particles.GetControlPointAtPrevTime(InControlPoint, out Vector3 prev); + float speed = (particles.GetControlPointAtCurrentTime(InControlPoint) - prev).Length() / particles.PreviousDt; + float output = ParticleOpUtil.RemapClamped(speed, InputMin, InputMax, OutputMin, OutputMax); + ParticleOpUtil.SetControlPointComponent(particles, OutControlPoint, Math.Clamp(Field, 0, 2), output); + } +} + +public sealed class C_OP_RemapBoundingVolumetoCP : ParticleOperatorInstance +{ + public int OutControlPoint; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Particle BBox Volume to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("input volume minimum in cubic units", "0", (o, v) => o.InputMin = v) + .Float("input volume maximum in cubic units", "128", (o, v) => o.InputMax = v) + .Int("output control point", "-1", (o, v) => o.OutControlPoint = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(OutControlPoint); + public override bool ShouldRunBeforeEmitters() => true; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + if (OutControlPoint < 0) + return; + particles.GetBounds(out Vector3 min, out Vector3 max); + Vector3 size = max - min; + float volume = MathF.Pow(size.X * size.Y * size.Z, 0.33333333f); + particles.SetControlPoint(OutControlPoint, new Vector3(ParticleOpUtil.RemapClamped(volume, InputMin, InputMax, OutputMin, OutputMax), 0, 0)); + } +} + +public sealed class C_OP_RemapAverageScalarValuetoCP : ParticleOperatorInstance +{ + public int OutControlPoint; + public int Field; + public float InputMin; + public float InputMax; + public float OutputMin; + public float OutputMax; + + public static readonly ParticleOperatorDefinition Definition = new("Remap Average Scalar Value to CP", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("Scalar field", "3", (o, v) => o.Field = v) + .Float("input volume minimum", "0", (o, v) => o.InputMin = v) + .Float("input volume maximum", "1", (o, v) => o.InputMax = v) + .Int("output control point", "1", (o, v) => o.OutControlPoint = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 1u << Field; + public override ulong GetReadControlPointMask() => ParticleOpUtil.CPMask(OutControlPoint); + public override bool ShouldRunBeforeEmitters() => true; + public override void InitParams(ParticleSystemDefinition def, Element element) => Field = ParticleOpUtil.ClampField(Field); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float sum = 0.0f; + for (int p = 0; p < particles.ActiveParticles; p++) + sum += particles.GetFloatAttributeValue(Field, p); + float average = sum / particles.ActiveParticles; + particles.SetControlPoint(OutControlPoint, new Vector3(ParticleOpUtil.RemapClamped(average, InputMin, InputMax, OutputMin, OutputMax), 0, 0)); + } +} + +public sealed class C_OP_RampScalarLinear : ParticleOperatorInstance +{ + public float RateMin; + public float RateMax; + public float StartTimeMin; + public float StartTimeMax; + public float EndTimeMin; + public float EndTimeMax; + public int Field; + public bool ProportionalOp; + bool UsesStartEnd; + float MinCmp; + float MaxCmp; + + public static readonly ParticleOperatorDefinition Definition = new("Ramp Scalar Linear Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("ramp field", "3", (o, v) => o.Field = v) + .Float("ramp rate min", "0", (o, v) => o.RateMin = v) + .Float("ramp rate max", "0", (o, v) => o.RateMax = v) + .Float("start time min", "0", (o, v) => o.StartTimeMin = v) + .Float("start time max", "0", (o, v) => o.StartTimeMax = v) + .Float("end time min", "1", (o, v) => o.EndTimeMin = v) + .Float("end time max", "1", (o, v) => o.EndTimeMax = v) + .Bool("start/end proportional", "1", (o, v) => o.ProportionalOp = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Field = ParticleOpUtil.ClampField(Field); + UsesStartEnd = !(StartTimeMin == 0 && StartTimeMax == 0 && EndTimeMin == 1 && EndTimeMax == 1 && ProportionalOp); + ParticleOpUtil.GetClampRange(Field, out MinCmp, out MaxCmp); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int offset = particles.OperatorRandomSampleOffset(); + float scale = opStrength * particles.Dt; + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + if (!(lifetime > 0.0f)) + continue; + if (UsesStartEnd) { + float age = ParticleOpUtil.Age(particles, p); + float lifeTime = ProportionalOp ? age / lifetime : age; + float startTime = StartTimeMin + (StartTimeMax - StartTimeMin) * particles.OperatorRandomFloat(p, offset + 11); + float endTime = EndTimeMin + (EndTimeMax - EndTimeMin) * particles.OperatorRandomFloat(p, offset + 12); + if (!(lifeTime >= startTime && lifeTime < endTime)) + continue; + } + float rate = RateMin + (RateMax - RateMin) * particles.OperatorRandomFloat(p, offset); + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + value = Math.Max(Math.Min(value + rate * scale, MaxCmp), MinCmp); + } + } +} + +public sealed class C_OP_RampScalarSpline : ParticleOperatorInstance +{ + public float RateMin; + public float RateMax; + public float StartTimeMin; + public float StartTimeMax; + public float EndTimeMin; + public float EndTimeMax; + public float Bias; + public int Field; + public bool ProportionalOp; + public bool EaseOut; + float MinCmp; + float MaxCmp; + + public static readonly ParticleOperatorDefinition Definition = new("Ramp Scalar Spline Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("ramp field", "3", (o, v) => o.Field = v) + .Float("ramp rate min", "0", (o, v) => o.RateMin = v) + .Float("ramp rate max", "0", (o, v) => o.RateMax = v) + .Float("start time min", "0", (o, v) => o.StartTimeMin = v) + .Float("start time max", "0", (o, v) => o.StartTimeMax = v) + .Float("end time min", "1", (o, v) => o.EndTimeMin = v) + .Float("end time max", "1", (o, v) => o.EndTimeMax = v) + .Bool("start/end proportional", "1", (o, v) => o.ProportionalOp = v) + .Bool("ease out", "0", (o, v) => o.EaseOut = v) + .Float("bias", ".5", (o, v) => o.Bias = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Field = ParticleOpUtil.ClampField(Field); + ParticleOpUtil.GetClampRange(Field, out MinCmp, out MaxCmp); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int offset = particles.OperatorRandomSampleOffset(); + float scale = opStrength * particles.Dt; + float biasParam = ParticleOpUtil.PreCalcBiasParameter(Bias); + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float startTime = StartTimeMin + (StartTimeMax - StartTimeMin) * particles.OperatorRandomFloat(p, offset + 11); + float endTime = EndTimeMin + (EndTimeMax - EndTimeMin) * particles.OperatorRandomFloat(p, offset + 12); + float age = ParticleOpUtil.Age(particles, p); + float lifeTime = ProportionalOp ? age / lifetime : age; + if (!(lifetime > 0.0f && lifeTime >= startTime && lifeTime < endTime)) + continue; + + float rate = RateMin + (RateMax - RateMin) * particles.OperatorRandomFloat(p, offset); + float spline = Math.Min(1.0f, Math.Max(0.0f, (lifeTime - startTime) * (1.0f / (1.1920929e-07f + endTime - startTime)))); + if (EaseOut) { + if (spline > 0.5f) + spline = 1.0f - spline; + spline *= 2.0f; + } + spline = ParticleOpUtil.Bias(spline, biasParam); + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + value = Math.Max(Math.Min(value + rate * spline * scale, MaxCmp), MinCmp); + } + } +} + +public sealed class C_OP_RampScalarLinearSimple : ParticleOperatorInstance +{ + public float Rate; + public float StartTime; + public float EndTime; + public int Field; + float MinCmp; + float MaxCmp; + + public static readonly ParticleOperatorDefinition Definition = new("Ramp Scalar Linear Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("ramp field", "3", (o, v) => o.Field = v) + .Float("ramp rate", "0", (o, v) => o.Rate = v) + .Float("start time", "0", (o, v) => o.StartTime = v) + .Float("end time", "1", (o, v) => o.EndTime = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Field = ParticleOpUtil.ClampField(Field); + ParticleOpUtil.GetClampRange(Field, out MinCmp, out MaxCmp); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float amount = Rate * opStrength * particles.Dt; + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float t = ParticleOpUtil.Age(particles, p) / lifetime; + if (!(lifetime > 0.0f && t >= StartTime && t < EndTime)) + continue; + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + value = Math.Max(Math.Min(value + amount, MaxCmp), MinCmp); + } + } +} + +public sealed class C_OP_RampScalarSplineSimple : ParticleOperatorInstance +{ + public float Rate; + public float StartTime; + public float EndTime; + public int Field; + public bool EaseOut; + float MinCmp; + float MaxCmp; + + public static readonly ParticleOperatorDefinition Definition = new("Ramp Scalar Spline Simple", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("ramp field", "3", (o, v) => o.Field = v) + .Float("ramp rate", "0", (o, v) => o.Rate = v) + .Float("start time", "0", (o, v) => o.StartTime = v) + .Float("end time", "1", (o, v) => o.EndTime = v) + .Bool("ease out", "0", (o, v) => o.EaseOut = v)); + + public override uint GetWrittenAttributes() => 1u << Field; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + Field = ParticleOpUtil.ClampField(Field); + ParticleOpUtil.GetClampRange(Field, out MinCmp, out MaxCmp); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float scale = opStrength * particles.Dt; + float ooRange = 1.0f / (1.1920929e-07f + EndTime - StartTime); + for (int p = 0; p < particles.ActiveParticles; p++) { + float lifetime = ParticleOpUtil.Lifetime(particles, p); + float t = ParticleOpUtil.Age(particles, p) / lifetime; + if (!(lifetime > 0.0f && t >= StartTime && t < EndTime)) + continue; + float spline = Math.Min(1.0f, Math.Max(0.0f, (t - StartTime) * ooRange)); + if (EaseOut) { + if (spline > 0.5f) + spline = 1.0f - spline; + spline *= 2.0f; + } + spline = ParticleOpUtil.SimpleSpline(spline); + ref float value = ref particles.GetFloatAttributeRefForWrite(Field, p); + value = Math.Max(Math.Min(value + Rate * spline * scale, MaxCmp), MinCmp); + } + } +} + +public sealed class C_OP_Noise : ParticleOperatorInstance +{ + public int FieldOutput; + public float OutputMin; + public float OutputMax; + public float NoiseScale; + public bool Additive; + + public static readonly ParticleOperatorDefinition Definition = new("Noise Scalar", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("noise coordinate scale", "0.1", (o, v) => o.NoiseScale = v) + .Int("output field", "3", (o, v) => o.FieldOutput = v) + .Float("output minimum", "0", (o, v) => o.OutputMin = v) + .Float("output maximum", "1", (o, v) => o.OutputMax = v) + .Bool("additive", "0", (o, v) => o.Additive = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = OutputMin, max = OutputMax; + if ((ParticleOpUtil.ATTRIBUTES_WHICH_ARE_ANGLES & (1 << FieldOutput)) != 0) { + min *= 0.017453292f; + max *= 0.017453292f; + } + float valueScale = (max - min) * 0.5f; + float valueBase = valueScale + min; + int count = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < count; p++) { + float noise = NoiseSIMD.Noise(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) * NoiseScale); + ref float value = ref particles.GetFloatAttributeRefForWrite(FieldOutput, p); + if (Additive) + value = noise * valueScale * particles.Dt + valueBase * particles.Dt + value; + else + value = noise * valueScale + valueBase; + } + } +} + +public sealed class C_OP_VectorNoise : ParticleOperatorInstance +{ + public int FieldOutput; + public Vector3 OutputMin; + public Vector3 OutputMax; + public float NoiseScale; + public bool Additive; + + static readonly Vector3 OffsetY = new(100000.5f, 300000.25f, 9000000.75f); + static readonly Vector3 OffsetZ = new(110000.25f, 310000.75f, 9100000.5f); + + public static readonly ParticleOperatorDefinition Definition = new("Noise Vector", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("noise coordinate scale", "0.1", (o, v) => o.NoiseScale = v) + .Int("output field", "6", (o, v) => o.FieldOutput = v) + .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v) + .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v) + .Bool("additive", "0", (o, v) => o.Additive = v)); + + public override uint GetWrittenAttributes() => 1u << FieldOutput; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => FieldOutput = ParticleOpUtil.ClampField(FieldOutput); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + Vector3 valueScale = (OutputMax - OutputMin) * 0.5f; + Vector3 valueBase = OutputMin + valueScale; + int count = (particles.ActiveParticles + 3) & ~3; + for (int p = 0; p < count; p++) { + Vector3 coord = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) * NoiseScale; + float x = NoiseSIMD.Noise(coord); + coord += OffsetY; + float y = NoiseSIMD.Noise(coord); + coord += OffsetZ; + float z = NoiseSIMD.Noise(coord); + Vector3 noise = valueBase + valueScale * new Vector3(x, y, z); + if (Additive) + noise = ParticleOpUtil.GetVector(particles, FieldOutput, p) + noise * particles.Dt; + ParticleOpUtil.SetVector(particles, FieldOutput, p, noise); + } + } +} + +public sealed class C_OP_VelocityDecay : ParticleOperatorInstance +{ + public float MinVelocity; + + public static readonly ParticleOperatorDefinition Definition = new("Lifespan Minimum Velocity Decay", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("minimum velocity", "1", (o, v) => o.MinVelocity = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => MinVelocity = Math.Max(ParticleOpUtil.MIN_PARTICLE_SPEED, MinVelocity); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float invDt = 1.0f / particles.Dt; + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + Vector3 delta = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) - particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p); + if (delta.Length() * invDt <= MinVelocity) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_AlphaDecay : ParticleOperatorInstance +{ + public float MinAlpha; + + public static readonly ParticleOperatorDefinition Definition = new("Lifespan Minimum Alpha Decay", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("minimum alpha", "0", (o, v) => o.MinAlpha = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK | PARTICLE_ATTRIBUTE_ALPHA2_MASK; + public override void InitParams(ParticleSystemDefinition def, Element element) => MinAlpha = Math.Max(0.0f, MinAlpha); + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + float min = MinAlpha + 1.1920929e-07f; + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + if (particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, p) * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA2, p) <= min) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_RadiusDecay : ParticleOperatorInstance +{ + public float MinRadius; + + public static readonly ParticleOperatorDefinition Definition = new("Lifespan Minimum Radius Decay", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("minimum radius", "1", (o, v) => o.MinRadius = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + int limit = ParticleOpUtil.PaddedCount(particles); + for (int p = 0; p < limit; p++) { + if (particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p) <= MinRadius) + particles.KillParticle(p); + } + } +} + +public sealed class C_OP_DecayMaintainCount : ParticleOperatorInstance +{ + public int ParticlesToMaintain; + public int ScaleControlPoint; + public int ScaleControlPointField; + public float DecayDelay; + + public static readonly ParticleOperatorDefinition Definition = new("Lifespan Maintain Count Decay", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("count to maintain", "100", (o, v) => o.ParticlesToMaintain = v) + .Float("decay delay", "0", (o, v) => o.DecayDelay = v) + .Int("maintain count scale control point", "-1", (o, v) => o.ScaleControlPoint = v) + .Int("maintain count scale control point field", "0", (o, v) => o.ScaleControlPointField = v)); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK; + public override int GetRequiredContextBytes() => sizeof(int); + public override void InitializeContextData(ParticleCollection particles, Span context) => BitConverter.TryWriteBytes(context, 0); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + ScaleControlPoint = Math.Clamp(ScaleControlPoint, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + ScaleControlPointField = Math.Clamp(ScaleControlPointField, 0, 2); + } + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + ref int pendingDecay = ref System.Runtime.InteropServices.MemoryMarshal.Cast(context)[0]; + int toMaintain = ParticlesToMaintain; + if (ScaleControlPoint >= 0) + toMaintain = (int)Math.Min((float)particles.Def!.MaxParticles, ParticlesToMaintain * ParticleOpUtil.Component(particles.GetControlPointAtCurrentTime(ScaleControlPoint), ScaleControlPointField)); + + int killQueue = 0; + if (toMaintain < particles.ActiveParticles) + killQueue = particles.ActiveParticles - pendingDecay - toMaintain; + + for (int p = 0; p < particles.ActiveParticles; p++) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p); + ref float lifeDuration = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p); + if (lifeDuration < particles.CurTime - creationTime) { + particles.KillParticle(p); + killQueue--; + pendingDecay = Math.Max(0, pendingDecay - 1); + } + else if (killQueue > 0 && particles.CurTime + DecayDelay < lifeDuration) { + lifeDuration = particles.CurTime + DecayDelay - creationTime; + killQueue--; + pendingDecay++; + } + } + } +} + +public sealed class C_OP_Cull : ParticleOperatorInstance +{ + public float CullPerc; + public float CullStart; + public float CullEnd; + public float CullExp; + + public static readonly ParticleOperatorDefinition Definition = new("Cull Random", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Float("Cull Start Time", "0", (o, v) => o.CullStart = v) + .Float("Cull End Time", "1", (o, v) => o.CullEnd = v) + .Float("Cull Time Exponent", "1", (o, v) => o.CullExp = v) + .Float("Cull Percentage", "0.5", (o, v) => o.CullPerc = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK; + + public override void Operate(ParticleCollection particles, float opStrength, Span context) { + for (int p = 0; p < particles.ActiveParticles; p++) { + float rank = particles.RandomFloat(0.0f, 1.0f); + float cullTime = particles.RandomFloatExp(CullStart, CullEnd, CullExp); + if (rank > CullPerc * opStrength) + continue; + float t = Math.Clamp(ParticleOpUtil.NormalizedAge(particles, p), 0.0f, 1.0f); + if (t >= CullStart && t <= CullEnd && t >= cullTime) + particles.KillParticle(p); + } + } +} diff --git a/Source.Particles/BuiltinParticleRenderers.Models.cs b/Source.Particles/BuiltinParticleRenderers.Models.cs new file mode 100644 index 00000000..7a4376de --- /dev/null +++ b/Source.Particles/BuiltinParticleRenderers.Models.cs @@ -0,0 +1,105 @@ +using Datamodel; + +using Source.Common.MaterialSystem; +using QAngle = Source.Common.Mathematics.QAngle; +using Source.Common.Mathematics; + +using System.Numerics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_OP_RenderModels : ParticleRenderOperatorInstance +{ + public string ActivityName = ""; + public string ModelName = ""; + public bool OrientZ; + public bool ScaleAnimationRate; + public int AnimationScaleField; + public int Skin; + public float AnimationRate; + public object? Model; + public int Activity = -1; + + public static readonly ParticleOperatorDefinition Definition = new("Render models", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.BeginRender() + .String("sequence 0 model", "NONE", 256, (o, v) => o.ModelName = v) + .Float("animation rate", "30.0", (o, v) => o.AnimationRate = v) + .Bool("scale animation rate", "0", (o, v) => o.ScaleAnimationRate = v) + .Int("animation rate scale field", "10", (o, v) => o.AnimationScaleField = v) + .Bool("orient model z to normal", "0", (o, v) => o.OrientZ = v) + .Int("skin number", "0", (o, v) => o.Skin = v) + .String("activity override", "", 256, (o, v) => o.ActivityName = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => (1u << (AnimationScaleField & 31)) | 0x3112d9; + + public override void InitParams(ParticleSystemDefinition def, Element element) { + if (AnimationScaleField > 31) + AnimationScaleField = 31; + } + + public override void Precache(ParticleSystemDefinition def) { + IParticleSystemQuery query = def.Mgr.Query(); + Model = query.GetModel(ModelName); + Activity = ActivityName.Length != 0 ? query.GetActivityNumber(Model, ActivityName) : -1; + } + + static void ComputeNormalBasis(Vector3 normal, out Vector3 v) { + v = new((1.0f - normal.Z) * normal.X * normal.X + normal.Z, 0.0f, -normal.X); + MathLib.VectorNormalize(ref v); + v -= normal * Vector3.Dot(v, normal); + MathLib.VectorNormalize(ref v); + } + + public override void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { + ParticleVisibilityData visibility = new() { AlphaVisibility = 1.0f, RadiusVisibility = 1.0f }; + ParticleRenderData[] renderList = particles.GetRenderList(renderContext, false, out int count, visibility); + + IParticleSystemQuery query = particles.Mgr!.Query(); + query.SetUpLightingEnvironment(particles.Center); + + bool validScaleField = (uint)AnimationScaleField < 22; + if (!validScaleField) + Warning($"GetFloatAttributePtrForWrite invalid attribute {AnimationScaleField}\n"); + + for (int i = count - 1; i >= 0; i--) { + int particle = renderList[i].Index; + + int sequence = (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle); + int activity = Activity == -1 ? (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1, particle) : Activity; + + float rate = AnimationRate; + if (ScaleAnimationRate && validScaleField) + rate *= particles.GetFloatAttributeValue(AnimationScaleField, particle); + + Vector3 normal = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_NORMAL, particle); + MathLib.VectorNormalize(ref normal); + ComputeNormalBasis(normal, out Vector3 v); + Vector3 w = Vector3.Cross(normal, v); + + float scale = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, particle); + Matrix3x4 basis = OrientZ + ? new(w.X * scale, -v.X * scale, normal.X * scale, 0, w.Y * scale, -v.Y * scale, normal.Y * scale, 0, w.Z * scale, -v.Z * scale, normal.Z * scale, 0) + : new(normal.X * scale, v.X * scale, w.X * scale, 0, normal.Y * scale, v.Y * scale, w.Y * scale, 0, normal.Z * scale, v.Z * scale, w.Z * scale, 0); + + QAngle angles = new( + particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_PITCH, particle) * 57.29578f, + particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_YAW, particle) * 57.29578f, + particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle) * 57.29578f); + MathLib.AngleMatrix(in angles, out Matrix3x4 angleMatrix); + MathLib.ConcatTransforms(in basis, in angleMatrix, out Matrix3x4 drawMatrix); + + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle); + drawMatrix.M03 = position.X; + drawMatrix.M13 = position.Y; + drawMatrix.M23 = position.Z; + + Vector3 tint = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + float alpha = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, particle) * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA2, particle); + + query.DrawModel(Model, in drawMatrix, particles, particle, sequence, 1, Skin, activity, rate, tint.X, tint.Y, tint.Z, alpha); + } + } +} diff --git a/Source.Particles/BuiltinParticleRenderers.Rope.cs b/Source.Particles/BuiltinParticleRenderers.Rope.cs new file mode 100644 index 00000000..385acf6d --- /dev/null +++ b/Source.Particles/BuiltinParticleRenderers.Rope.cs @@ -0,0 +1,344 @@ +using Datamodel; + +using Source.Common; +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_OP_RenderRope : ParticleOperatorInstance +{ + public int SubdivCount; + public int ScaleCP1; + public int ScaleCP2; + public float TexelSizeInUnits; + public float TextureScale; + public float TextureScrollRate; + public float TextureOffset; + public float TStep; + public bool ScaleByControlPointDistance; + public bool ScaleScrollByControlPointDistance; + public bool ScaleOffsetByControlPointDistance; + public bool UsesCPScaling; + + public static readonly ParticleOperatorDefinition Definition = new("render_rope", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.Begin() + .Int("subdivision_count", "3", (o, v) => o.SubdivCount = v) + .Float("texel_size", "4.0f", (o, v) => o.TexelSizeInUnits = v) + .Float("texture_scroll_rate", "0.0f", (o, v) => o.TextureScrollRate = v) + .Float("texture_offset", "0.0f", (o, v) => o.TextureOffset = v) + .Int("scale CP start", "-1", (o, v) => o.ScaleCP1 = v) + .Int("scale CP end", "-1", (o, v) => o.ScaleCP2 = v) + .Bool("scale texture by CP distance", "0", (o, v) => o.ScaleByControlPointDistance = v) + .Bool("scale scroll by CP distance", "0", (o, v) => o.ScaleScrollByControlPointDistance = v) + .Bool("scale offset by CP distance", "0", (o, v) => o.ScaleOffsetByControlPointDistance = v)); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_TINT_RGB_MASK | PARTICLE_ATTRIBUTE_ALPHA_MASK | PARTICLE_ATTRIBUTE_ALPHA2_MASK; + public override ulong GetReadControlPointMask() => UsesCPScaling ? (1UL << (ScaleCP2 & 63)) | (1UL << (ScaleCP1 & 63)) : 0; + public override int GetRequiredContextBytes() => SubdivCount * sizeof(float) + sizeof(float); + + public override void InitParams(ParticleSystemDefinition def, Element element) { + if (SubdivCount < 1) + SubdivCount = 1; + if (TexelSizeInUnits <= 0.0f) + TexelSizeInUnits = 1.0f; + TStep = 1.0f / SubdivCount; + + UsesCPScaling = (ScaleByControlPointDistance || ScaleScrollByControlPointDistance || ScaleOffsetByControlPointDistance) && ScaleCP1 >= 0 && ScaleCP2 >= 0; + ScaleCP1 = Math.Clamp(ScaleCP1, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + ScaleCP2 = Math.Clamp(ScaleCP2, -1, MAX_PARTICLE_CONTROL_POINTS - 1); + } + + static Span ContextFloats(Span context) => MemoryMarshal.Cast(context); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + Span ctx = ContextFloats(context); + ctx[0] = 0.0f; + for (int i = 0; i < SubdivCount; i++) + ctx[1 + i] = (float)i / SubdivCount; + + IMaterial? material = particles.Def!.GetMaterial(); + TextureScale = material != null ? 1.0f / (material.GetMappingHeight() * TexelSizeInUnits) : 1.0f; + } + + public override int GetParticlesToRender(ParticleCollection particles, Span context, int firstParticle, int remainingVertices, int remainingIndices, out int vertsUsed, out int indicesUsed) { + int active = particles.ActiveParticles; + if (firstParticle >= active - 1 || active < 2) { + vertsUsed = 0; + indicesUsed = 0; + return 0; + } + + int maxCount = Math.Min((remainingVertices - 2) / (SubdivCount * 2) + 1, remainingIndices / (SubdivCount * 6)); + int count = active - firstParticle; + if (maxCount == count - 1) + maxCount--; + if (maxCount < count) + count = maxCount; + + vertsUsed = (count * 2 - 2) * SubdivCount + 2; + indicesUsed = count * SubdivCount * 6; + return count; + } + + float ControlPointDistance(ParticleCollection particles) => Vector3.Distance(particles.GetControlPointAtCurrentTime(ScaleCP1), particles.GetControlPointAtCurrentTime(ScaleCP2)); + + public override void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { + IMaterial material = particles.Def!.GetMaterial()!; + if (material.IsSpriteCard()) { + RenderSpriteCard(renderContext, particles, material); + return; + } + + renderContext.Bind(material); + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + + int remaining = particles.ActiveParticles; + int firstParticle = 0; + while (remaining != 0) { + int inBatch = GetParticlesToRender(particles, context, firstParticle, maxVertices, maxIndices, out int vertCount, out int indexCount); + if (inBatch == 0) + break; + remaining -= inBatch; + + particles.Mgr!.TallyParticlesRendered(vertCount * 3, indexCount * 3); + IMesh mesh = renderContext.GetDynamicMesh(true)!; + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, vertCount, indexCount); + RenderUnsorted(particles, context, renderContext, ref meshBuilder, 0, firstParticle, inBatch); + meshBuilder.End(); + mesh.Draw(); + + firstParticle += inBatch; + } + } + + static float QuantizeColor(float value) => BuiltinParticleRenderers.UnitToByte(value) * (1.0f / 255.0f); + + static void GenerateSeg(ParticleCollection particles, int particle, ref BeamSeg seg) { + seg.Pos = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle); + Vector3 tint = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + seg.Color = new(QuantizeColor(tint.X), QuantizeColor(tint.Y), QuantizeColor(tint.Z)); + seg.Alpha = QuantizeColor(particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, particle) * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA2, particle)); + seg.Width = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, particle); + } + + public override void RenderUnsorted(ParticleCollection particles, Span context, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { + IMaterial material = particles.Def!.GetMaterial()!; + if (material.IsSpriteCard()) + return; + + Span ctx = ContextFloats(context); + ref float renderedLength = ref ctx[0]; + Span subdivList = ctx.Slice(1, SubdivCount); + if (firstParticle == 0) + renderedLength = 0.0f; + + float textureScale = TextureScale; + float offsetScaled = TextureOffset; + if (UsesCPScaling) { + float dist = ControlPointDistance(particles); + if (ScaleByControlPointDistance) + textureScale = 1.0f / (dist * TexelSizeInUnits + 1.1920929e-07f); + if (ScaleScrollByControlPointDistance) + offsetScaled = offsetScaled / material.GetMappingHeight() * dist; + if (ScaleOffsetByControlPointDistance) + offsetScaled += TextureOffset / material.GetMappingHeight() * dist; + } + float texOffset = particles.CurTime * TextureScrollRate + offsetScaled; + + BeamSegDraw beam = new(ref meshBuilder, vertexOffset); + beam.StartWithMeshBuilder(renderContext, (particleCount - 1) * SubdivCount + 1); + + Span catmullRom = stackalloc Vector3[4]; + Span seg = stackalloc BeamSeg[2]; + GenerateSeg(particles, firstParticle, ref seg[0]); + seg[0].TexCoord = (texOffset + renderedLength) * textureScale; + beam.NextSeg(ref seg[0]); + + catmullRom[1] = seg[0].Pos; + catmullRom[0] = firstParticle == 0 ? catmullRom[1] : particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, firstParticle - 1); + + float ooSubdiv = 1.0f / SubdivCount; + int particle = firstParticle + 1; + for (int i = 1; i < particleCount; i++, particle++) { + int cur = i & 1; + int prev = 1 - cur; + GenerateSeg(particles, particle, ref seg[cur]); + renderedLength += Vector3.Distance(seg[cur].Pos, seg[prev].Pos); + seg[cur].TexCoord = (renderedLength + texOffset) * textureScale; + + if (SubdivCount > 1) { + catmullRom[(i + 1) & 3] = seg[cur].Pos; + if (particle != particles.ActiveParticles - 1) + catmullRom[(i + 2) & 3] = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle + 1); + else + catmullRom[(i + 2) & 3] = catmullRom[(i + 1) & 3]; + + ref BeamSeg subdiv = ref seg[prev]; + Vector4 color = new(subdiv.Color, subdiv.Alpha); + Vector4 colorInc = (new Vector4(seg[cur].Color, seg[cur].Alpha) - color) * ooSubdiv; + float texCoordInc = (seg[cur].TexCoord - subdiv.TexCoord) * ooSubdiv; + float widthInc = (seg[cur].Width - subdiv.Width) * ooSubdiv; + for (int s = 1; s < SubdivCount; s++) { + color += colorInc; + subdiv.Color = new(QuantizeColor(color.X), QuantizeColor(color.Y), QuantizeColor(color.Z)); + subdiv.Alpha = QuantizeColor(color.W); + subdiv.TexCoord += texCoordInc; + subdiv.Width += widthInc; + MathLib.Catmull_Rom_Spline(catmullRom[(i + 3) & 3], catmullRom[i & 3], catmullRom[(i + 1) & 3], catmullRom[(i + 2) & 3], subdivList[s], out subdiv.Pos); + beam.NextSeg(ref subdiv); + } + } + + beam.NextSeg(ref seg[cur]); + } + + beam.End(); + } + + struct SplineState + { + public Vector4 P0, P1, P2, P3; + public byte R, G, B, A; + } + + static void OutputSplineVerts(ref MeshBuilder meshBuilder, in SplineState state, float t, float u) { + for (int side = 0; side < 2; side++) { + meshBuilder.Color4ub(state.R, state.G, state.B, state.A); + meshBuilder.Position3f(t, u, side); + meshBuilder.TexCoord4f(0, state.P0.X, state.P0.Y, state.P0.Z, state.P0.W); + meshBuilder.TexCoord4f(1, state.P1.X, state.P1.Y, state.P1.Z, state.P1.W); + meshBuilder.TexCoord4f(2, state.P2.X, state.P2.Y, state.P2.Z, state.P2.W); + meshBuilder.TexCoord4f(3, state.P3.X, state.P3.Y, state.P3.Z, state.P3.W); + meshBuilder.AdvanceVertex(); + } + } + + static void OutputSplineIndices(ref MeshBuilder meshBuilder, int index) { + meshBuilder.FastIndex((ushort)index); + meshBuilder.FastIndex((ushort)(index + 1)); + meshBuilder.FastIndex((ushort)(index + 2)); + meshBuilder.FastIndex((ushort)(index + 1)); + meshBuilder.FastIndex((ushort)(index + 3)); + meshBuilder.FastIndex((ushort)(index + 2)); + } + + static Vector4 PointRadius(ParticleCollection particles, int particle) + => new(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, particle)); + + static void SetColor(ParticleCollection particles, int particle, ref SplineState state) { + Vector3 tint = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + state.R = BuiltinParticleRenderers.UnitToByte(tint.X); + state.G = BuiltinParticleRenderers.UnitToByte(tint.Y); + state.B = BuiltinParticleRenderers.UnitToByte(tint.Z); + state.A = BuiltinParticleRenderers.UnitToByte(particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, particle) * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA2, particle)); + } + + void RenderSpriteCard(IMatRenderContext renderContext, ParticleCollection particles, IMaterial material) { + int particleCount = particles.ActiveParticles; + int segmentsToRender = particleCount - 1; + if (segmentsToRender == 0) + return; + + renderContext.Bind(material); + float mappingHeight = material.GetMappingHeight(); + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + + int vertsPerSegment = SubdivCount * 2; + int indicesPerSegment = SubdivCount * 6; + int segmentsPerBatch = Math.Min((maxVertices - 2) / vertsPerSegment, maxIndices / indicesPerSegment); + int segmentsThisBatch = Math.Min(segmentsPerBatch, segmentsToRender); + + IMesh mesh = renderContext.GetDynamicMesh(true)!; + + float textureScale = TexelSizeInUnits; + float scrollRate = TextureScrollRate; + float offsetScaled = 1.0f / mappingHeight * TextureOffset; + if (UsesCPScaling) { + float dist = ControlPointDistance(particles); + if (ScaleByControlPointDistance) + textureScale = 1.0f / (dist * TexelSizeInUnits + 1.1920929e-07f); + float distOverHeight = 1.0f / mappingHeight * dist; + if (ScaleScrollByControlPointDistance) + scrollRate = scrollRate * distOverHeight * textureScale; + if (ScaleOffsetByControlPointDistance) + offsetScaled *= distOverHeight + 1.0f; + } + float u = TextureOffset + scrollRate * particles.CurTime + offsetScaled; + + SplineState state = default; + state.P1 = PointRadius(particles, 0); + state.P2 = PointRadius(particles, 1); + Vector4 delta = state.P2 - state.P1; + state.P0 = state.P1 - delta; + state.P3 = particleCount < 3 ? state.P2 + delta : PointRadius(particles, 2); + SetColor(particles, 0, ref state); + + int vertexCount = segmentsThisBatch * vertsPerSegment + 2; + int indexCount = segmentsThisBatch * indicesPerSegment; + particles.Mgr!.TallyParticlesRendered(vertexCount * 3, indexCount * 3); + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, vertexCount, indexCount); + + float duScale = TStep * TexelSizeInUnits; + float t = 0.0f; + int nextPoint = 3; + int curIndex = 0; + int available = segmentsThisBatch; + bool firstPoint = true; + + do { + if (available == 0) { + meshBuilder.End(); + mesh.Draw(); + particles.Mgr!.TallyParticlesRendered(vertexCount * 3, indexCount * 3); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, vertexCount, indexCount); + OutputSplineVerts(ref meshBuilder, in state, t, u); + available = segmentsThisBatch; + curIndex = 0; + } + available--; + + t = 0.0f; + float du = Vector3.Distance(new(state.P2.X, state.P2.Y, state.P2.Z), new(state.P1.X, state.P1.Y, state.P1.Z)) * duScale; + for (int slice = 0; slice < SubdivCount; slice++) { + OutputSplineVerts(ref meshBuilder, in state, t, u); + u += du; + t += TStep; + if (!firstPoint) { + OutputSplineIndices(ref meshBuilder, curIndex); + curIndex += 2; + } + firstPoint = false; + } + + if (segmentsToRender > 1) { + state.P0 = state.P1; + state.P1 = state.P2; + state.P2 = state.P3; + SetColor(particles, nextPoint - 2, ref state); + if (nextPoint < particleCount) { + state.P3 = PointRadius(particles, nextPoint); + nextPoint++; + } + else + state.P3 = state.P3 * 2.0f - state.P1; + } + } while (--segmentsToRender != 0); + + OutputSplineVerts(ref meshBuilder, in state, 1.0f, u); + OutputSplineIndices(ref meshBuilder, curIndex); + + meshBuilder.End(); + mesh.Draw(); + } +} diff --git a/Source.Particles/BuiltinParticleRenderers.Trail.cs b/Source.Particles/BuiltinParticleRenderers.Trail.cs new file mode 100644 index 00000000..8c0e01f8 --- /dev/null +++ b/Source.Particles/BuiltinParticleRenderers.Trail.cs @@ -0,0 +1,314 @@ +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class C_OP_RenderSpritesTrail : ParticleRenderOperatorInstance +{ + struct Context + { + public ParticleVisibilityData VisibilityData; + public int QueryHandle; + } + + public Vector4 FadeColor; + public float AnimationRate; + public float LengthFadeInTime; + public float MaxLength; + public float MinLength; + public bool ConstrainRadius; + public bool IgnoreDT; + + public static readonly ParticleOperatorDefinition Definition = new("render_sprite_trail", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.BeginRender() + .Float("animation rate", ".1", (o, v) => o.AnimationRate = v) + .Float("length fade in time", "0", (o, v) => o.LengthFadeInTime = v) + .Float("max length", "2000", (o, v) => o.MaxLength = v) + .Float("min length", "0", (o, v) => o.MinLength = v) + .Bool("constrain radius to length", "1", (o, v) => o.ConstrainRadius = v) + .Bool("ignore delta time", "0", (o, v) => o.IgnoreDT = v) + .Vector4("tail color and alpha scale factor", "1 1 1 1", (o, v) => o.FadeColor = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_TINT_RGB_MASK + | PARTICLE_ATTRIBUTE_ALPHA_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK | PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK; + public override ulong GetReadControlPointMask() => VisibilityInputs.CPin < 0 ? 0 : 1UL << (VisibilityInputs.CPin & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.VisibilityData.UseVisibility = VisibilityInputs.CPin >= 0; + ctx.VisibilityData.CameraBias = VisibilityInputs.CameraBias; + } + + public override int GetParticlesToRender(ParticleCollection particles, Span context, int firstParticle, int remainingVertices, int remainingIndices, out int vertsUsed, out int indicesUsed) { + int count = Math.Min(particles.ActiveParticles - firstParticle, Math.Min(remainingVertices / 4, remainingIndices / 6)); + vertsUsed = count * 4; + indicesUsed = count * 6; + return count; + } + + float GetOODt(ParticleCollection particles) { + if (IgnoreDT) + return 1.0f; + return particles.Dt != 0.0f ? 1.0f / particles.Dt : 1.0f; + } + + static ref readonly SheetSequenceSample GetSample(ParticleCollection particles, float ageScale, int particle) { + Sheet? sheet = particles.Sheet; + if (sheet == null) + return ref BuiltinParticleRenderers.DefaultSheetSequence; + return ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(sheet, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle), particles.CurTime, ageScale, (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle))); + } + + static void WriteQuadIndices(ref MeshBuilder meshBuilder, ref int vertexOffset) { + meshBuilder.FastIndex((ushort)vertexOffset); + meshBuilder.FastIndex((ushort)(vertexOffset + 1)); + meshBuilder.FastIndex((ushort)(vertexOffset + 2)); + meshBuilder.FastIndex((ushort)vertexOffset); + meshBuilder.FastIndex((ushort)(vertexOffset + 2)); + meshBuilder.FastIndex((ushort)(vertexOffset + 3)); + vertexOffset += 4; + } + + void RenderSpriteTrail(ref MeshBuilder meshBuilder, ParticleCollection particles, ref int vertexOffset, float ageScale, int particle, in Vector3 camera, float ooDt, in ParticleRenderData sortEntry) { + byte alpha = sortEntry.Alpha; + if (alpha == 0) + return; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + float radius = sortEntry.Radius; + ref readonly SequenceSampleTextureCoords coords = ref GetSample(particles, ageScale, particle).TextureCoordData[0]; + + float age = particles.CurTime - particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle); + float lengthScale = age >= LengthFadeInTime ? 1.0f : age / LengthFadeInTime; + + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle); + Vector3 delta = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, particle) - position; + float mag = MathF.Sqrt(delta.LengthSquared()); + float length = lengthScale * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, particle) * mag * ooDt; + if (!(length > 0.0f)) + return; + + delta *= 1.0f / mag; + float clamped = MaxLength; + if (length <= MaxLength) + clamped = length; + if (clamped <= MinLength) + clamped = MinLength; + length = clamped; + delta *= length; + + if (length < radius && ConstrainRadius) + radius = length; + + Vector3 tangent = Vector3.Cross(position - camera, delta); + MathLib.VectorNormalize(ref tangent); + + Vector3 v0 = position + tangent * (radius * 0.5f); + Vector3 v1 = position + tangent * (radius * -0.5f); + Vector3 v2 = v1 + delta; + Vector3 v3 = v0 + delta; + + byte r = BuiltinParticleRenderers.UnitToByte(color.X); + byte g = BuiltinParticleRenderers.UnitToByte(color.Y); + byte b = BuiltinParticleRenderers.UnitToByte(color.Z); + + meshBuilder.Position3f(v0.X, v0.Y, v0.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.LeftU0, coords.BottomV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(v1.X, v1.Y, v1.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.RightU0, coords.BottomV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(v2.X, v2.Y, v2.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.RightU0, coords.TopV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(v3.X, v3.Y, v3.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.LeftU0, coords.TopV0); + meshBuilder.AdvanceVertex(); + + WriteQuadIndices(ref meshBuilder, ref vertexOffset); + } + + static ReadOnlySpan SplineCorners => [0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0]; + + bool RenderSpriteTrailSpriteCard(ref MeshBuilder meshBuilder, ParticleCollection particles, ref int vertexOffset, float ageScale, int particle, float ooDt, in ParticleRenderData sortEntry) { + byte alpha = sortEntry.Alpha; + if (alpha == 0) + return false; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + float radius = sortEntry.Radius; + ref readonly SequenceSampleTextureCoords coords = ref GetSample(particles, ageScale, particle).TextureCoordData[0]; + + float age = particles.CurTime - particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle); + float lengthScale = age / LengthFadeInTime; + if (lengthScale > 1.0f) + lengthScale = 1.0f; + + Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle); + Vector3 delta = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, particle) - position; + float magSquared = delta.LengthSquared(); + float invMag = magSquared == 0.0f ? 0.0f : 1.0f / MathF.Sqrt(magSquared); + float length = invMag * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, particle) * ooDt * lengthScale * magSquared; + if (!(length > 0.0f)) + return false; + + float clamped = MaxLength; + if (length <= MaxLength) + clamped = length; + if (clamped <= MinLength) + clamped = MinLength; + length = clamped; + delta = delta * invMag * length; + + if (ConstrainRadius && length < radius) + radius = length; + + Vector3 p0 = position - delta; + Vector3 p1 = position; + Vector3 p2 = position + delta; + Vector3 p3 = position + delta * 2.0f; + Vector4 fadeColor = new Vector4(color.X, color.Y, color.Z, alpha * (1.0f / 255.0f)) * FadeColor; + + byte r = BuiltinParticleRenderers.UnitToByte(color.X); + byte g = BuiltinParticleRenderers.UnitToByte(color.Y); + byte b = BuiltinParticleRenderers.UnitToByte(color.Z); + bool hasFadeColor = meshBuilder.TextureCoordinateSize(5) != 0; + + ReadOnlySpan corners = SplineCorners; + for (int i = 0; i < 4; i++) { + meshBuilder.Position3f(corners[i * 3], corners[i * 3 + 1], corners[i * 3 + 2]); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord4f(0, p0.X, p0.Y, p0.Z, radius); + meshBuilder.TexCoord4f(1, p1.X, p1.Y, p1.Z, radius); + meshBuilder.TexCoord4f(2, p2.X, p2.Y, p2.Z, radius); + meshBuilder.TexCoord4f(3, p3.X, p3.Y, p3.Z, radius); + meshBuilder.TexCoord4f(4, coords.LeftU0, coords.TopV0, coords.RightU0, coords.BottomV0); + if (hasFadeColor) + meshBuilder.TexCoord4f(5, fadeColor.X, fadeColor.Y, fadeColor.Z, fadeColor.W); + meshBuilder.AdvanceVertex(); + } + + WriteQuadIndices(ref meshBuilder, ref vertexOffset); + return true; + } + + public override void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + IMaterial material = particles.Def!.GetMaterial()!; + + if (ctx.VisibilityData.UseVisibility) + BuiltinParticleRenderers.SetupParticleVisibility(particles, ref ctx.VisibilityData, VisibilityInputs, ref ctx.QueryHandle); + + bool spriteCard = material.IsSpriteCard(); + renderContext.Bind(material); + + float ageScale = AnimationRate * 1024.0f; + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, true, out int particleCount, ctx.VisibilityData); + int sortEnd = particleCount; + + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + int maxParticlesInBatch = Math.Min(maxVertices / 4, maxIndices / 6); + float ooDt = GetOODt(particles); + + while (particleCount != 0) { + int particlesInBatch = Math.Min(maxParticlesInBatch, particleCount); + particleCount -= particlesInBatch; + + particles.Mgr!.TallyParticlesRendered(particlesInBatch * 4 * 3); + IMesh mesh = renderContext.GetDynamicMesh(true)!; + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, particlesInBatch * 4, particlesInBatch * 6); + + int vertexOffset = 0; + for (int i = 0; i < particlesInBatch; i++) { + ref ParticleRenderData entry = ref sortList[--sortEnd]; + if (spriteCard) + RenderSpriteTrailSpriteCard(ref meshBuilder, particles, ref vertexOffset, ageScale, entry.Index, ooDt, entry); + else + RenderSpriteTrail(ref meshBuilder, particles, ref vertexOffset, ageScale, entry.Index, camera, ooDt, entry); + } + + meshBuilder.End(); + mesh.Draw(); + } + } + + public override void RenderUnsorted(ParticleCollection particles, Span context, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { + ref Context ctx = ref Ctx(context); + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + float ageScale = AnimationRate * 1024.0f; + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, false, out int sortCount, ctx.VisibilityData); + float ooDt = GetOODt(particles); + for (int i = 0; i < particleCount; i++) + RenderSpriteTrail(ref meshBuilder, particles, ref vertexOffset, ageScale, firstParticle + i, camera, ooDt, sortList[sortCount]); + } +} + +public sealed class C_OP_RenderScreenVelocityRotate : ParticleRenderOperatorInstance +{ + struct Context + { + public ParticleVisibilityData VisibilityData; + public int QueryHandle; + } + + public float RotateRateDegrees; + public float ForwardDegrees; + + public static readonly ParticleOperatorDefinition Definition = new("render_screen_velocity_rotate", ParticleOperatorId.Generic, true, + ParticleOperatorUnpack.BeginRender() + .Float("rotate_rate(dps)", "0", (o, v) => o.RotateRateDegrees = v) + .Float("forward_angle", "-90", (o, v) => o.ForwardDegrees = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ROTATION_MASK; + public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_ROTATION_MASK; + public override ulong GetReadControlPointMask() => VisibilityInputs.CPin < 0 ? 0 : 1UL << (VisibilityInputs.CPin & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.VisibilityData.UseVisibility = VisibilityInputs.CPin >= 0; + ctx.VisibilityData.CameraBias = VisibilityInputs.CameraBias; + } + + public override void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + if (ctx.VisibilityData.UseVisibility) + BuiltinParticleRenderers.SetupParticleVisibility(particles, ref ctx.VisibilityData, VisibilityInputs, ref ctx.QueryHandle); + + renderContext.GetMatrix(MaterialMatrixMode.View, out Matrix4x4 view); + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, false, out int particleCount, ctx.VisibilityData); + float forwardRadians = ForwardDegrees * 0.017453292f; + + for (int i = 0, sortEnd = particleCount; i < particleCount; i++) { + int particle = sortList[--sortEnd].Index; + MathLib.Vector3DMultiplyPosition(in view, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), out Vector3 viewPos); + if (!float.IsFinite(viewPos.X)) + continue; + MathLib.Vector3DMultiplyPosition(in view, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, particle), out Vector3 prevViewPos); + particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_ROTATION, particle) = (float)(Math.Atan2(viewPos.Y - prevViewPos.Y, viewPos.X - prevViewPos.X) + forwardRadians); + } + } +} diff --git a/Source.Particles/BuiltinParticleRenderers.cs b/Source.Particles/BuiltinParticleRenderers.cs new file mode 100644 index 00000000..a9f3ff0d --- /dev/null +++ b/Source.Particles/BuiltinParticleRenderers.cs @@ -0,0 +1,566 @@ +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public static class BuiltinParticleRenderers +{ + public static void AddBuiltInParticleRenderers(ParticleSystemMgr mgr) { + mgr.AddParticleOperator(ParticleFunctionType.Renderer, C_OP_RenderSprites.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Renderer, C_OP_RenderSpritesTrail.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Renderer, C_OP_RenderScreenVelocityRotate.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Renderer, C_OP_RenderRope.Definition); + mgr.AddParticleOperator(ParticleFunctionType.Renderer, C_OP_RenderModels.Definition); + } + + internal static readonly SheetSequenceSample DefaultSheetSequence = CreateDefaultSheetSequence(); + + static SheetSequenceSample CreateDefaultSheetSequence() { + SheetSequenceSample sample = default; + for (int i = 0; i < Sheet.MAX_IMAGES_PER_FRAME_IN_MEMORY; i++) + sample.TextureCoordData[i] = new() { LeftU0 = 0, TopV0 = 0, RightU0 = 1, BottomV0 = 1, LeftU1 = 0, TopV1 = 0, RightU1 = 1, BottomV1 = 1 }; + sample.BlendFactor = 1.0f; + return sample; + } + + internal static ref readonly SheetSequenceSample SampleOrDefault(ref readonly SheetSequenceSample sample) { + if (Unsafe.IsNullRef(in sample)) + return ref DefaultSheetSequence; + return ref sample; + } + + internal static byte UnitToByte(float value) => (byte)((int)MathF.Round(value * 255.0f) & 0xFF); + + internal static Vector3 ApplyCameraBias(Vector3 position, in Vector3 camera, float cameraBias) { + if (cameraBias == 0.0f) + return position; + Vector3 delta = camera - position; + float invLength = 1.0f / MathF.Sqrt(delta.LengthSquared() + 1e-10f); + return position + delta * cameraBias * invLength; + } + + internal static void SetupParticleVisibility(ParticleCollection particles, ref ParticleVisibilityData visibilityData, in ParticleVisibilityInputs inputs, ref int queryHandle) { + float visibility = particles.Mgr!.Query().GetPixelVisibility(ref queryHandle, particles.GetControlPointAtCurrentTime(inputs.CPin), inputs.ProxyRadius); + + if (inputs.InputMax == inputs.InputMin) { + bool max = inputs.InputMax <= visibility; + visibilityData.AlphaVisibility = max ? inputs.AlphaScaleMax : inputs.AlphaScaleMin; + visibilityData.RadiusVisibility = max ? inputs.RadiusScaleMax : inputs.RadiusScaleMin; + } + else { + float fraction = Math.Clamp((visibility - inputs.InputMin) / (inputs.InputMax - inputs.InputMin), 0.0f, 1.0f); + visibilityData.AlphaVisibility = inputs.AlphaScaleMin + (inputs.AlphaScaleMax - inputs.AlphaScaleMin) * fraction; + visibilityData.RadiusVisibility = inputs.RadiusScaleMin + (inputs.RadiusScaleMax - inputs.RadiusScaleMin) * fraction; + } + + visibilityData.CameraBias = inputs.CameraBias; + } +} + +struct SpriteRenderInfo +{ + public ParticleCollection Particles; + public Sheet? Sheet; + public float AgeScale; + public float AgeScale2; + public int VertexOffset; +} + +public sealed class C_OP_RenderSprites : ParticleRenderOperatorInstance +{ + struct Context + { + public TokenCache OrientationVarToken; + public TokenCache OrientationMatrixVarToken; + public ParticleVisibilityData VisibilityData; + public int QueryHandle; + } + + public float AnimationRate; + public bool FitCycleToLifetime; + public int OrientationType; + public int OrientationControlPoint; + public float AnimationRate2; + public bool AnimateInFPS; + + public static readonly ParticleOperatorDefinition Definition = new("render_animated_sprites", ParticleOperatorId.Generic, false, + ParticleOperatorUnpack.BeginRender() + .Float("animation rate", ".1", (o, v) => o.AnimationRate = v) + .Bool("animation_fit_lifetime", "0", (o, v) => o.FitCycleToLifetime = v) + .Int("orientation_type", "0", (o, v) => o.OrientationType = v) + .Int("orientation control point", "-1", (o, v) => o.OrientationControlPoint = v) + .Float("second sequence animation rate", "0", (o, v) => o.AnimationRate2 = v) + .Bool("use animation rate as FPS", "0", (o, v) => o.AnimateInFPS = v)); + + static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context); + + public override uint GetWrittenAttributes() => 0; + public override uint GetReadAttributes() => 0x23db; + public override ulong GetReadControlPointMask() => OrientationControlPoint < 0 ? 0 : 1UL << (OrientationControlPoint & 63); + public override int GetRequiredContextBytes() => Unsafe.SizeOf(); + + public override void InitializeContextData(ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + ctx.OrientationVarToken = default; + ctx.OrientationMatrixVarToken = default; + ctx.VisibilityData.UseVisibility = VisibilityInputs.CPin >= 0; + ctx.VisibilityData.CameraBias = VisibilityInputs.CameraBias; + } + + public override int GetParticlesToRender(ParticleCollection particles, Span context, int firstParticle, int remainingVertices, int remainingIndices, out int vertsUsed, out int indicesUsed) { + int count = Math.Min(Math.Min(particles.ActiveParticles - firstParticle, remainingIndices / 6), remainingVertices / 4); + vertsUsed = count * 4; + indicesUsed = count * 6; + return count; + } + + SpriteRenderInfo CreateRenderInfo(ParticleCollection particles) => new() { + Particles = particles, + Sheet = particles.Sheet, + AgeScale = AnimationRate * 1024.0f, + AgeScale2 = AnimationRate2 * 1024.0f, + VertexOffset = 0 + }; + + public override void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { + ref Context ctx = ref Ctx(context); + IMaterial material = particles.Def!.GetMaterial()!; + + if (ctx.VisibilityData.UseVisibility) + BuiltinParticleRenderers.SetupParticleVisibility(particles, ref ctx.VisibilityData, VisibilityInputs, ref ctx.QueryHandle); + + material.FindVarFast("$orientation", ref ctx.OrientationVarToken)?.SetIntValue(OrientationType); + + renderContext.Bind(material); + + if (!material.IsSpriteCard()) { + switch (OrientationType) { + case 0: RenderNonSpriteCardCameraFacing(particles, ref ctx, renderContext, material); break; + case 1: RenderNonSpriteCardZRotating(particles, ref ctx, renderContext, material); break; + case 2: RenderNonSpriteCardOriented(particles, ref ctx, renderContext, material, false); break; + case 3: RenderNonSpriteCardOriented(particles, ref ctx, renderContext, material, true); break; + } + return; + } + + if (OrientationType == 2) { + IMaterialVar? matrixVar = material.FindVarFast("$orientationMatrix", ref ctx.OrientationMatrixVarToken); + if (matrixVar != null) { + if (OrientationControlPoint < 0) + matrixVar.SetMatrixValue(Matrix4x4.Identity); + else { + particles.GetControlPointTransformAtCurrentTime(OrientationControlPoint, out Matrix3x4 transform); + matrixVar.SetMatrixValue((Matrix4x4)transform); + } + } + } + + SpriteRenderInfo info = CreateRenderInfo(particles); + + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + int maxParticlesInBatch = Math.Min(maxVertices / 4, maxIndices / 6); + + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, true, out int particleCount, ctx.VisibilityData); + int sortEnd = particleCount; + + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + + while (particleCount != 0) { + int particlesInBatch = Math.Min(maxParticlesInBatch, particleCount); + particleCount -= particlesInBatch; + + IMesh mesh = renderContext.GetDynamicMesh(true)!; + particles.Mgr!.TallyParticlesRendered(particlesInBatch * 4 * 3); + + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, particlesInBatch * 4, particlesInBatch * 6); + info.VertexOffset = 0; + + bool twoSequence = meshBuilder.TextureCoordinateSize(5) != 0; + for (int i = 0; i < particlesInBatch; i++) { + ref ParticleRenderData entry = ref sortList[--sortEnd]; + if (twoSequence) + RenderTwoSequenceSpriteCard(ref meshBuilder, ref ctx, ref info, entry.Index, entry, camera); + else + RenderSpriteCard(ref meshBuilder, ref ctx, ref info, entry.Index, entry, camera); + } + + meshBuilder.End(); + mesh.Draw(); + } + } + + public override void RenderUnsorted(ParticleCollection particles, Span context, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { + ref Context ctx = ref Ctx(context); + IMaterial material = particles.Def!.GetMaterial()!; + + if (!material.IsSpriteCard()) { + switch (OrientationType) { + case 1: RenderUnsortedNonSpriteCardZRotating(particles, ref ctx, renderContext, ref meshBuilder, vertexOffset, firstParticle, particleCount); break; + case 2: RenderUnsortedNonSpriteCardOriented(particles, ref ctx, renderContext, ref meshBuilder, vertexOffset, firstParticle, particleCount); break; + case 0: Warning($"C_OP_RenderSprites::RenderUnsorted: Attempting to use an unimplemented sprite renderer for system \"{particles.Def.GetName()}\"!\n"); break; + } + return; + } + + SpriteRenderInfo info = CreateRenderInfo(particles); + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, false, out int sortCount, ctx.VisibilityData); + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + + for (int i = 0; i < particleCount; i++) + RenderSpriteCard(ref meshBuilder, ref ctx, ref info, firstParticle + i, sortList[sortCount], camera); + } + + static void WriteQuadIndices(ref MeshBuilder meshBuilder, ref SpriteRenderInfo info) { + int offset = info.VertexOffset; + meshBuilder.FastIndex((ushort)offset); + meshBuilder.FastIndex((ushort)(offset + 1)); + meshBuilder.FastIndex((ushort)(offset + 2)); + meshBuilder.FastIndex((ushort)offset); + meshBuilder.FastIndex((ushort)(offset + 2)); + meshBuilder.FastIndex((ushort)(offset + 3)); + info.VertexOffset += 4; + } + + static ReadOnlySpan CornerIds => [0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f]; + + void RenderSpriteCard(ref MeshBuilder meshBuilder, ref Context ctx, ref SpriteRenderInfo info, int particle, in ParticleRenderData sortEntry, in Vector3 camera) { + ParticleCollection particles = info.Particles; + byte alpha = sortEntry.Alpha; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + byte r = BuiltinParticleRenderers.UnitToByte(color.X); + byte g = BuiltinParticleRenderers.UnitToByte(color.Y); + byte b = BuiltinParticleRenderers.UnitToByte(color.Z); + float rotation = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle); + float radius = sortEntry.Radius; + float yaw = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_YAW, particle); + Vector3 position = BuiltinParticleRenderers.ApplyCameraBias(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), camera, ctx.VisibilityData.CameraBias); + + ref readonly SheetSequenceSample sample = ref BuiltinParticleRenderers.DefaultSheetSequence; + if (info.Sheet != null) { + float ageScale = info.AgeScale; + int sequence = (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle); + if (AnimateInFPS) + ageScale /= particles.Sheet!.FrameSpan[sequence]; + sample = ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(info.Sheet, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle), particles.CurTime, ageScale, sequence)); + } + + ref readonly SequenceSampleTextureCoords coords0 = ref sample.TextureCoordData[0]; + ref readonly SequenceSampleTextureCoords coords1 = ref sample.TextureCoordData[1]; + ReadOnlySpan cornerIds = CornerIds; + for (int corner = 0; corner < 4; corner++) { + meshBuilder.Position3f(position.X, position.Y, position.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord4f(0, coords0.LeftU0, coords0.TopV0, coords0.RightU0, coords0.BottomV0); + meshBuilder.TexCoord4f(1, coords0.LeftU1, coords0.TopV1, coords0.RightU1, coords0.BottomV1); + meshBuilder.TexCoord4f(2, sample.BlendFactor, rotation, radius, yaw); + meshBuilder.TexCoord2f(3, cornerIds[corner * 2], cornerIds[corner * 2 + 1]); + meshBuilder.TexCoord4f(4, coords1.LeftU0, coords1.TopV0, coords1.RightU0, coords1.BottomV0); + meshBuilder.AdvanceVertex(); + } + + WriteQuadIndices(ref meshBuilder, ref info); + } + + void RenderTwoSequenceSpriteCard(ref MeshBuilder meshBuilder, ref Context ctx, ref SpriteRenderInfo info, int particle, in ParticleRenderData sortEntry, in Vector3 camera) { + ParticleCollection particles = info.Particles; + byte alpha = sortEntry.Alpha; + float radius = sortEntry.Radius; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + byte r = BuiltinParticleRenderers.UnitToByte(color.X); + byte g = BuiltinParticleRenderers.UnitToByte(color.Y); + byte b = BuiltinParticleRenderers.UnitToByte(color.Z); + float rotation = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle); + float yaw = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_YAW, particle); + Vector3 position = BuiltinParticleRenderers.ApplyCameraBias(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), camera, ctx.VisibilityData.CameraBias); + + ref readonly SheetSequenceSample sample = ref BuiltinParticleRenderers.DefaultSheetSequence; + ref readonly SheetSequenceSample sample2 = ref BuiltinParticleRenderers.DefaultSheetSequence; + if (info.Sheet != null) { + float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle); + sample = ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(info.Sheet, creationTime, particles.CurTime, info.AgeScale, (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle))); + sample2 = ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(info.Sheet, creationTime, particles.CurTime, info.AgeScale2, (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1, particle))); + } + + ref readonly SequenceSampleTextureCoords coords0 = ref sample.TextureCoordData[0]; + ref readonly SequenceSampleTextureCoords coords1 = ref sample.TextureCoordData[1]; + ref readonly SequenceSampleTextureCoords secondCoords = ref sample2.TextureCoordData[0]; + ReadOnlySpan cornerIds = CornerIds; + for (int corner = 0; corner < 4; corner++) { + meshBuilder.Position3f(position.X, position.Y, position.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord4f(0, coords0.LeftU0, coords0.TopV0, coords0.RightU0, coords0.BottomV0); + meshBuilder.TexCoord4f(1, coords0.LeftU1, coords0.TopV1, coords0.RightU1, coords0.BottomV1); + meshBuilder.TexCoord4f(2, sample.BlendFactor, rotation, radius, yaw); + meshBuilder.TexCoord2f(3, cornerIds[corner * 2], cornerIds[corner * 2 + 1]); + meshBuilder.TexCoord4f(4, coords1.LeftU0, coords1.TopV0, coords1.RightU0, coords1.BottomV0); + meshBuilder.TexCoord4f(5, secondCoords.LeftU0, secondCoords.TopV0, secondCoords.RightU0, secondCoords.BottomV0); + meshBuilder.TexCoord4f(6, secondCoords.LeftU1, secondCoords.TopV1, secondCoords.RightU1, secondCoords.BottomV1); + meshBuilder.TexCoord4f(7, sample2.BlendFactor, 0, 0, 0); + meshBuilder.AdvanceVertex(); + } + + WriteQuadIndices(ref meshBuilder, ref info); + } + + ref readonly SheetSequenceSample NonSpriteCardSample(ParticleCollection particles, Sheet? sheet, float ageScale, int particle) { + if (sheet == null) + return ref BuiltinParticleRenderers.DefaultSheetSequence; + return ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(sheet, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle), particles.CurTime, ageScale, (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle))); + } + + void RenderNonSpriteCardCameraFacing(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, IMaterial material) { + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, true, out int particleCount, ctx.VisibilityData); + int sortEnd = particleCount; + + float cameraBias = ctx.VisibilityData.CameraBias; + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + + renderContext.GetMatrix(MaterialMatrixMode.View, out Matrix4x4 tempView); + renderContext.EnableUserClipTransformOverride(true); + renderContext.UserClipTransform(tempView); + renderContext.MatrixMode(MaterialMatrixMode.View); + renderContext.PushMatrix(); + renderContext.LoadIdentity(); + + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + int maxParticlesInBatch = Math.Min(maxVertices / 4, maxIndices / 6); + Sheet? sheet = particles.Sheet; + + while (particleCount != 0) { + int particlesInBatch = Math.Min(maxParticlesInBatch, particleCount); + particleCount -= particlesInBatch; + + particles.Mgr!.TallyParticlesRendered(particlesInBatch * 4); + IMesh mesh = renderContext.GetDynamicMesh(true)!; + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Quads, particlesInBatch); + + for (int i = 0; i < particlesInBatch; i++) { + ref ParticleRenderData entry = ref sortList[--sortEnd]; + byte alpha = entry.Alpha; + if (alpha == 0) + continue; + + int particle = entry.Index; + float radius = entry.Radius; + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + Vector3 worldPosition = BuiltinParticleRenderers.ApplyCameraBias(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), camera, cameraBias); + + MathLib.Vector3DMultiplyPosition(in tempView, in worldPosition, out Vector3 viewPosition); + if (!float.IsFinite(viewPosition.X)) + continue; + + float rotation = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle); + float ca = MathF.Cos(rotation); + float sa = MathF.Sin(rotation); + + ref readonly SheetSequenceSample sample = ref BuiltinParticleRenderers.DefaultSheetSequence; + if (sheet != null) { + int sequence = (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, particle); + float ageScale; + if (FitCycleToLifetime) { + float lifetime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, particle); + ageScale = lifetime > 0.0f ? 1024.0f / lifetime : 0.0f; + } + else { + ageScale = AnimationRate * 1024.0f; + if (AnimateInFPS) + ageScale /= sheet.FrameSpan[sequence]; + } + sample = ref BuiltinParticleRenderers.SampleOrDefault(in Sheet.GetSampleForSequence(sheet, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, particle), particles.CurTime, ageScale, sequence)); + } + ref readonly SequenceSampleTextureCoords coords = ref sample.TextureCoordData[0]; + + byte r = BuiltinParticleRenderers.UnitToByte(color.X); + byte g = BuiltinParticleRenderers.UnitToByte(color.Y); + byte b = BuiltinParticleRenderers.UnitToByte(color.Z); + + meshBuilder.Position3f(viewPosition.X + (-ca + sa) * radius, viewPosition.Y + (-sa - ca) * radius, viewPosition.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.LeftU0, coords.BottomV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(viewPosition.X + (-ca - sa) * radius, viewPosition.Y + (-sa + ca) * radius, viewPosition.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.LeftU0, coords.TopV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(viewPosition.X + (ca - sa) * radius, viewPosition.Y + (sa + ca) * radius, viewPosition.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.RightU0, coords.TopV0); + meshBuilder.AdvanceVertex(); + + meshBuilder.Position3f(viewPosition.X + (ca + sa) * radius, viewPosition.Y + (sa - ca) * radius, viewPosition.Z); + meshBuilder.Color4ub(r, g, b, alpha); + meshBuilder.TexCoord2f(0, coords.RightU0, coords.BottomV0); + meshBuilder.AdvanceVertex(); + } + + meshBuilder.End(); + mesh.Draw(); + } + + renderContext.EnableUserClipTransformOverride(false); + renderContext.MatrixMode(MaterialMatrixMode.View); + renderContext.PopMatrix(); + } + + static void EmitRotatedQuad(ref MeshBuilder meshBuilder, ref SpriteRenderInfo info, in Vector3 position, in Vector3 right, in Vector3 up, float a, float b, in SequenceSampleTextureCoords coords, bool oriented, byte red, byte green, byte blue, byte alpha) { + Span corners = oriented + ? [new(a, b), new(-b, a), new(-a, -b), new(b, -a)] + : [new(a, b), new(b, -a), new(-a, -b), new(-b, a)]; + Span texCoords = oriented + ? [new(coords.RightU0, coords.BottomV0), new(coords.RightU0, coords.TopV0), new(coords.LeftU0, coords.TopV0), new(coords.LeftU0, coords.BottomV0)] + : [new(coords.LeftU0, coords.BottomV0), new(coords.LeftU0, coords.TopV0), new(coords.RightU0, coords.TopV0), new(coords.RightU0, coords.BottomV0)]; + + for (int i = 0; i < 4; i++) { + Vector3 vertex = position + right * corners[i].X + up * corners[i].Y; + meshBuilder.Position3f(vertex.X, vertex.Y, vertex.Z); + meshBuilder.Color4ub(red, green, blue, alpha); + meshBuilder.TexCoord2f(0, texCoords[i].X, texCoords[i].Y); + meshBuilder.AdvanceVertex(); + } + + WriteQuadIndices(ref meshBuilder, ref info); + } + + void RenderNonSpriteCardZRotating(ref MeshBuilder meshBuilder, ref Context ctx, ref SpriteRenderInfo info, int particle, in Vector3 camera, in ParticleRenderData sortEntry) { + byte alpha = sortEntry.Alpha; + if (alpha == 0) + return; + + ParticleCollection particles = info.Particles; + float radius = sortEntry.Radius; + Vector3 position = BuiltinParticleRenderers.ApplyCameraBias(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), camera, ctx.VisibilityData.CameraBias); + + if (Vector3.Distance(position, camera) < radius * 0.5f) + return; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + float rotation = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle); + + float invLength = 1.0f / MathF.Sqrt(camera.Y * camera.Y + camera.X * camera.X + 1e-10f); + Vector3 right = new Vector3(-camera.Y, camera.X, 0.0f) * invLength * radius; + Vector3 up = new(0.0f, 0.0f, radius); + + ref readonly SheetSequenceSample sample = ref NonSpriteCardSample(particles, info.Sheet, info.AgeScale, particle); + + float ca = MathF.Cos(rotation); + float sa = MathF.Sin(-rotation); + EmitRotatedQuad(ref meshBuilder, ref info, position, right, up, -(ca + sa), sa - ca, sample.TextureCoordData[0], false, + BuiltinParticleRenderers.UnitToByte(color.X), BuiltinParticleRenderers.UnitToByte(color.Y), BuiltinParticleRenderers.UnitToByte(color.Z), alpha); + } + + void RenderNonSpriteCardOriented(ref MeshBuilder meshBuilder, ref Context ctx, ref SpriteRenderInfo info, int particle, in Vector3 camera, in ParticleRenderData sortEntry, bool useYaw) { + byte alpha = sortEntry.Alpha; + if (alpha == 0) + return; + + ParticleCollection particles = info.Particles; + float radius = sortEntry.Radius; + Vector3 position = BuiltinParticleRenderers.ApplyCameraBias(particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, particle), camera, ctx.VisibilityData.CameraBias); + + if (Vector3.Distance(position, camera) < radius * 0.5f) + return; + + Vector3 color = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_TINT_RGB, particle); + float rotation = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ROTATION, particle); + + Vector3 right, up; + if (OrientationControlPoint < 0) { + right = new(1.0f, 0.0f, 0.0f); + up = new(0.0f, -1.0f, 0.0f); + } + else { + ref readonly ParticleControlPoint cp = ref particles.ControlPoint(OrientationControlPoint); + right = cp.ForwardVector; + up = cp.RightVector; + } + + if (useYaw) { + float yaw = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_YAW, particle); + if (yaw != 0.0f) { + MathLib.MatrixBuildRotationAboutAxis(out Matrix4x4 rotationMatrix, up, yaw * (180.0f / MathF.PI)); + MathLib.Vector3DMultiply(in rotationMatrix, in right, out right); + } + } + + ref readonly SheetSequenceSample sample = ref NonSpriteCardSample(particles, info.Sheet, info.AgeScale, particle); + + float ca = MathF.Cos(rotation); + float sa = MathF.Sin(-rotation); + EmitRotatedQuad(ref meshBuilder, ref info, position, right * radius, up * radius, ca - sa, -(ca + sa), sample.TextureCoordData[0], true, + BuiltinParticleRenderers.UnitToByte(color.X), BuiltinParticleRenderers.UnitToByte(color.Y), BuiltinParticleRenderers.UnitToByte(color.Z), alpha); + } + + void RenderNonSpriteCardBatched(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, IMaterial material, int orientation, bool useYaw) { + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + + SpriteRenderInfo info = CreateRenderInfo(particles); + info.AgeScale2 = 0.0f; + + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, true, out int particleCount, ctx.VisibilityData); + int sortEnd = particleCount; + + int maxVertices = renderContext.GetMaxVerticesToRender(material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + int maxParticlesInBatch = Math.Min(maxVertices / 4, maxIndices / 6); + + while (particleCount != 0) { + int particlesInBatch = Math.Min(maxParticlesInBatch, particleCount); + particleCount -= particlesInBatch; + + particles.Mgr!.TallyParticlesRendered(particlesInBatch * 4 * 3); + IMesh mesh = renderContext.GetDynamicMesh(true)!; + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, particlesInBatch * 4, particlesInBatch * 6); + info.VertexOffset = 0; + + for (int i = 0; i < particlesInBatch; i++) { + ref ParticleRenderData entry = ref sortList[--sortEnd]; + if (orientation == 1) + RenderNonSpriteCardZRotating(ref meshBuilder, ref ctx, ref info, entry.Index, camera, entry); + else + RenderNonSpriteCardOriented(ref meshBuilder, ref ctx, ref info, entry.Index, camera, entry, useYaw); + } + + meshBuilder.End(); + mesh.Draw(); + } + } + + void RenderNonSpriteCardZRotating(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, IMaterial material) + => RenderNonSpriteCardBatched(particles, ref ctx, renderContext, material, 1, false); + + void RenderNonSpriteCardOriented(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, IMaterial material, bool useYaw) + => RenderNonSpriteCardBatched(particles, ref ctx, renderContext, material, 2, useYaw); + + void RenderUnsortedNonSpriteCardZRotating(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + SpriteRenderInfo info = CreateRenderInfo(particles); + info.VertexOffset = vertexOffset; + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, false, out int sortCount, ctx.VisibilityData); + for (int i = 0; i < particleCount; i++) + RenderNonSpriteCardZRotating(ref meshBuilder, ref ctx, ref info, firstParticle + i, camera, sortList[sortCount]); + } + + void RenderUnsortedNonSpriteCardOriented(ParticleCollection particles, ref Context ctx, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + SpriteRenderInfo info = CreateRenderInfo(particles); + info.VertexOffset = vertexOffset; + ParticleRenderData[] sortList = particles.GetRenderList(renderContext, false, out int sortCount, ctx.VisibilityData); + for (int i = 0; i < particleCount; i++) + RenderNonSpriteCardOriented(ref meshBuilder, ref ctx, ref info, firstParticle + i, camera, sortList[sortCount], false); + } +} diff --git a/Source.Particles/DmxElementUnpack.cs b/Source.Particles/DmxElementUnpack.cs new file mode 100644 index 00000000..5b0880f8 --- /dev/null +++ b/Source.Particles/DmxElementUnpack.cs @@ -0,0 +1,151 @@ +using Datamodel; + +using System.Globalization; +using System.Numerics; + +using DmColor = Datamodel.Color; +using DmQAngle = Datamodel.QAngle; +using SourceColor = Source.Color; +using SourceQAngle = Source.Common.Mathematics.QAngle; + +namespace Source.Particles; + +public enum DmAttributeType +{ + Unknown = 0, + Element, + Int, + Float, + Bool, + String, + Void, + ObjectId, + Color, + Vector2, + Vector3, + Vector4, + QAngle, + Quaternion, + VMatrix +} + +public readonly record struct DmxElementUnpackField(string AttributeName, string? DefaultString, DmAttributeType AttributeType, int Size); + +public interface IDmxElementUnpackStructure +{ + IEnumerable Fields { get; } + void UnpackIntoStructure(Element element, object target); +} + +public static class DmxElementUnpack +{ + public static DmAttributeType GetAttributeType(object? value) => value switch { + null => DmAttributeType.Element, + Element => DmAttributeType.Element, + int => DmAttributeType.Int, + float => DmAttributeType.Float, + bool => DmAttributeType.Bool, + string => DmAttributeType.String, + byte[] => DmAttributeType.Void, + DmColor => DmAttributeType.Color, + Vector2 => DmAttributeType.Vector2, + Vector3 => DmAttributeType.Vector3, + Vector4 => DmAttributeType.Vector4, + DmQAngle => DmAttributeType.QAngle, + Quaternion => DmAttributeType.Quaternion, + Matrix4x4 => DmAttributeType.VMatrix, + _ => DmAttributeType.Unknown + }; + + public static object? ParseValue(DmAttributeType type, string text) { + string[] tokens = text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries); + int I(int i) => i < tokens.Length ? ScanInt(tokens[i]) : 0; + float F(int i) => i < tokens.Length ? ScanFloat(tokens[i]) : 0; + return type switch { + DmAttributeType.Int => I(0), + DmAttributeType.Float => F(0), + DmAttributeType.Bool => I(0) != 0, + DmAttributeType.String => text, + DmAttributeType.Color => new DmColor((byte)I(0), (byte)I(1), (byte)I(2), (byte)I(3)), + DmAttributeType.Vector2 => new Vector2(F(0), F(1)), + DmAttributeType.Vector3 => new Vector3(F(0), F(1), F(2)), + DmAttributeType.Vector4 => new Vector4(F(0), F(1), F(2), F(3)), + DmAttributeType.QAngle => new DmQAngle(F(0), F(1), F(2)), + DmAttributeType.Quaternion => new Quaternion(F(0), F(1), F(2), F(3)), + _ => null + }; + } + + static int ScanInt(string token) { + int end = 0; + if (end < token.Length && (token[end] == '-' || token[end] == '+')) + end++; + while (end < token.Length && char.IsAsciiDigit(token[end])) + end++; + return int.TryParse(token.AsSpan(0, end), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out int value) ? value : 0; + } + + static float ScanFloat(string token) => float.TryParse(token, NumberStyles.Float, CultureInfo.InvariantCulture, out float value) ? value : 0; +} + +public sealed class DmxElementUnpackStructure : IDmxElementUnpackStructure where T : class +{ + readonly List<(DmxElementUnpackField Field, Action Setter)> fields = []; + + public IEnumerable Fields => fields.Select(f => f.Field); + + DmxElementUnpackStructure Add(string name, string? defaultString, DmAttributeType type, int size, Action setter) { + fields.Add((new DmxElementUnpackField(name, defaultString, type, size), setter)); + return this; + } + + public DmxElementUnpackStructure Int(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Int, sizeof(int), (t, v) => set(t, (int)v)); + public DmxElementUnpackStructure Float(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Float, sizeof(float), (t, v) => set(t, (float)v)); + public DmxElementUnpackStructure Bool(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Bool, sizeof(bool), (t, v) => set(t, (bool)v)); + public DmxElementUnpackStructure String(string name, string? defaultString, int size, Action set) + => Add(name, defaultString, DmAttributeType.String, size, (t, v) => { + string s = (string)v; + set(t, s.Length >= size ? s[..(size - 1)] : s); + }); + public DmxElementUnpackStructure Color(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Color, 4, (t, v) => { + DmColor c = (DmColor)v; + set(t, new SourceColor(c.R, c.G, c.B, c.A)); + }); + public DmxElementUnpackStructure Vector2(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Vector2, 8, (t, v) => set(t, (Vector2)v)); + public DmxElementUnpackStructure Vector3(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Vector3, 12, (t, v) => set(t, (Vector3)v)); + public DmxElementUnpackStructure Vector4(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.Vector4, 16, (t, v) => set(t, (Vector4)v)); + public DmxElementUnpackStructure QAngle(string name, string? defaultString, Action set) + => Add(name, defaultString, DmAttributeType.QAngle, 12, (t, v) => { + DmQAngle a = (DmQAngle)v; + set(t, new SourceQAngle(a.Pitch, a.Yaw, a.Roll)); + }); + + public void UnpackIntoStructure(Element element, object target) => UnpackIntoStructure(element, (T)target); + + public void UnpackIntoStructure(Element element, T target) { + foreach ((DmxElementUnpackField field, Action setter) in fields) { + if (field.AttributeType == DmAttributeType.Void) + continue; + + if (!element.TryGetValue(field.AttributeName, out object? value)) { + if (field.DefaultString == null) + continue; + value = DmxElementUnpack.ParseValue(field.AttributeType, field.DefaultString); + } + + if (DmxElementUnpack.GetAttributeType(value) != field.AttributeType) { + Warning($"CDmxElement::UnpackIntoStructure: Mismatched attribute type in attribute \"{field.AttributeName}\"!\n"); + continue; + } + + setter(target, value!); + } + } +} diff --git a/Source.Particles/IParticleSystemQuery.cs b/Source.Particles/IParticleSystemQuery.cs new file mode 100644 index 00000000..321a48a1 --- /dev/null +++ b/Source.Particles/IParticleSystemQuery.cs @@ -0,0 +1,104 @@ +using Source.Common; +using Source.Common.Formats.BSP; +using Source.Common.Mathematics; + +using System.Numerics; + +namespace Source.Particles; + +public struct ModelHitBoxInfo +{ + public Vector3 BoxMins; + public Vector3 BoxMaxes; + public Matrix3x4 Transform; +} + +public sealed class ModelHitBoxesInfo +{ + public const int MAX_HITBOXES = 256; + + public float LastUpdateTime = -1; + public float PrevLastUpdateTime; + public int NumHitBoxes; + public int NumPrevHitBoxes; + public ModelHitBoxInfo[]? HitBoxes; + public ModelHitBoxInfo[]? PrevBoxes; + + public bool CurAndPrevValid() => NumHitBoxes != 0 && NumPrevHitBoxes == NumHitBoxes; +} + +public struct ParticleRayTraceResult +{ + public Vector3 SurfaceNormal; + public float HitDistance; + public int HitId; +} + +public interface IParticleSystemQuery +{ + void GetLightingAtPoint(in Vector3 origin, out Color tint); + void TraceLine(in Vector3 absStart, in Vector3 absEnd, Mask mask, IHandleEntity? ignore, int collisionGroup, ref GameTrace trace); + + bool MovePointInsideControllingObject(ParticleCollection particles, object? obj, ref Vector3 pnt) => true; + bool IsPointInControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, Vector3 pos, bool bboxOnly = false) => true; + int GetCollisionGroupFromName(ReadOnlySpan collisionGroupName) => 0; + int GetRayTraceEnvironmentFromName(ReadOnlySpan rtEnvName) => 0; + + void TraceAgainstRayTraceEnv(int envNumber, in Vector3 start, in Vector3 direction, float tMin, float tMax, out ParticleRayTraceResult result) { + result = default; + result.HitId = -1; + } + + void GetRandomPointsOnControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, int numPtsOut, float bboxScale, int numTrysToGetAPointInsideTheModel, + Span pntsOut, Vector3 directionBias, Span hitBoxRelativeCoordOut = default, Span hitBoxIndexOut = default, int desiredHitbox = -1, string? hitboxSetName = null) { + Vector3 position = particles.ControlPoints[controlPointNumber].Position; + for (int i = 0; i < numPtsOut; i++) { + pntsOut[i] = position; + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = Vector3.Zero; + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = -1; + } + } + + void GetClosestControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, int numPtsIn, float bboxScale, ReadOnlySpan pntsIn, + Span hitBoxRelativeCoordOut = default, Span hitBoxIndexOut = default, int desiredHitbox = -1, string? hitboxSetName = null) { + for (int i = 0; i < numPtsIn; i++) { + if (!hitBoxRelativeCoordOut.IsEmpty) + hitBoxRelativeCoordOut[i] = Vector3.Zero; + if (!hitBoxIndexOut.IsEmpty) + hitBoxIndexOut[i] = 0; + } + } + + int GetControllingObjectHitBoxInfo(ParticleCollection particles, int controlPointNumber, Span hitBoxOutputBuffer, string? hitboxSetName = null) => 0; + + Vector3 GetLocalPlayerPos() => Vector3.Zero; + void GetLocalPlayerEyeVectors(out Vector3 forward, out Vector3 right, out Vector3 up) { + forward = Vector3.Zero; + right = Vector3.Zero; + up = Vector3.Zero; + } + + float GetPixelVisibility(ref int queryHandle, in Vector3 origin, float scale); + + void SetUpLightingEnvironment(in Vector3 pos) { } + + int GetActivityNumber(object? model, ReadOnlySpan activityName) => -1; + object? GetModel(ReadOnlySpan mdlName) => null; + void DrawModel(object? model, in Matrix3x4 drawMatrix, ParticleCollection particles, int particleNumber, int bodyPart, int subModel, int skin, int animationSequence, float animationRate, float r, float g, float b, float a) { } +} + +public sealed class DefaultParticleSystemQuery : IParticleSystemQuery +{ + public void GetLightingAtPoint(in Vector3 origin, out Color tint) => tint = new Color(255, 255, 255, 255); + + public void TraceLine(in Vector3 absStart, in Vector3 absEnd, Mask mask, IHandleEntity? ignore, int collisionGroup, ref GameTrace trace) => trace.Fraction = 1.0f; + + public void GetRandomPointsOnControllingObjectHitBox(ParticleCollection particles, int controlPointNumber, int numPtsOut, float bboxScale, int numTrysToGetAPointInsideTheModel, + Span pntsOut, Vector3 directionBias, Span hitBoxRelativeCoordOut = default, Span hitBoxIndexOut = default, int desiredHitbox = -1, string? hitboxSetName = null) { + pntsOut[..numPtsOut].Clear(); + } + + public float GetPixelVisibility(ref int queryHandle, in Vector3 origin, float scale) => 0; +} diff --git a/Source.Particles/ParticleCollection.cs b/Source.Particles/ParticleCollection.cs new file mode 100644 index 00000000..923eb153 --- /dev/null +++ b/Source.Particles/ParticleCollection.cs @@ -0,0 +1,1628 @@ +using Source.Common; +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public struct ParticleControlPoint +{ + public Vector3 Position; + public Vector3 PrevPosition; + public Vector3 ForwardVector; + public Vector3 UpVector; + public Vector3 RightVector; + public Vector3 Velocity; + public float Radius; + public float Density; + public float Duration; + public object? Object; + public int Parent; +} + +public struct PathParameters +{ + public int StartControlPointNumber; + public int EndControlPointNumber; + public int BulgeControl; + public float Bulge; + public float MidPoint; + + public void ClampControlPointIndices() { + StartControlPointNumber = Math.Max(0, Math.Min(MAX_PARTICLE_CONTROL_POINTS - 1, StartControlPointNumber)); + EndControlPointNumber = Math.Max(0, Math.Min(MAX_PARTICLE_CONTROL_POINTS - 1, EndControlPointNumber)); + } +} + +public class ParticleCollection +{ + public const int NUM_COLLISION_CACHE_MODES = 4; + const int CONSTANT_FLOATS = MAX_PARTICLE_ATTRIBUTES * 12; + + static readonly float[] RandomFloats = Source.Particles.RandomFloats.Table; + + public static ReadOnlySpan RandomFloatTable => RandomFloats; + + public int PaddedActiveParticles; + public float CurTime; + public float PrevSimTime = 1.0e23f; + public int ActiveParticles; + public float Dt; + public float PreviousDt = 0.05f; + public double NextSleepTime; + public bool InEndCap; + + public ParticleSystemMgr? Mgr; + public ParticleSystemDefinition? Def; + public int AllocatedParticles; + public int MaxAllowedParticles; + public bool Dormant; + public bool EmissionStopped; + public bool RequiresOrderInvariance; + + public int LocalLightingCP = -1; + public Color LocalLighting = new(255, 255, 255, 255); + + public readonly ParticleControlPoint[] ControlPoints = new ParticleControlPoint[MAX_PARTICLE_CONTROL_POINTS]; + public readonly ModelHitBoxesInfo[] ControlPointHitBoxes = new ModelHitBoxesInfo[MAX_PARTICLE_CONTROL_POINTS]; + + public byte[]? OperatorContextData; + public ParticleCollection? Next; + public ParticleCollection? Prev; + + public readonly StrongBox?[] CollisionCacheData = new StrongBox?[NUM_COLLISION_CACHE_MODES]; + public ParticleCollection? Parent; + internal StrongBox? CollisionCache; + public ParticleCollection? Children; + public Sheet? Sheet; + + protected bool BoundsValid; + protected Vector3 MinBounds; + protected Vector3 MaxBounds; + protected int HighestCP; + protected int TargetCP; + + float[] Memory = []; + readonly int[] AttributeOffsets = new int[MAX_PARTICLE_ATTRIBUTES]; + readonly int[] InitialAttributeOffsets = new int[MAX_PARTICLE_ATTRIBUTES]; + readonly int[] ParticleFloatStrides = new int[MAX_PARTICLE_ATTRIBUTES]; + readonly int[] ParticleInitialFloatStrides = new int[MAX_PARTICLE_ATTRIBUTES]; + + int PerParticleInitializedAttributeMask; + int PerParticleUpdatedAttributeMask; + int PerParticleReadInitialAttributeMask; + + ulong ControlPointReadMask; + int ParticleFlags = PCFLAGS_FIRST_FRAME; + bool IsScrubbable; + bool IsRunningInitializers; + bool IsRunningOperators; + bool IsTranslucent_; + bool IsTwoPass_; + bool AnyUsesPowerOfTwoFrameBufferTexture; + bool AnyUsesFullFrameBufferTexture; + bool IsBatchable_; + bool UsesPowerOfTwoFrameBufferTexture_; + bool UsesFullFrameBufferTexture_; + + int DrawnFrames; + int SimulatedFrames; + + internal Vector3 Center; + + int UniqueParticleId; + + public int RandomQueryCount; + int RandomSeed; + int OperatorRandomSampleOffset_; + + internal int NumParticlesToKill; + internal int[]? ParticleKillList; + + ParticleCollection? NextDef; + ParticleCollection? PrevDef; + + public ParticleCollection() { + for (int i = 0; i < MAX_PARTICLE_CONTROL_POINTS; i++) { + ref ParticleControlPoint cp = ref ControlPoints[i]; + cp.ForwardVector = new(0, 1, 0); + cp.UpVector = new(0, 0, 1); + cp.RightVector = new(1, 0, 0); + cp.Density = 1.0f; + ControlPointHitBoxes[i] = new(); + } + Array.Fill(InitialAttributeOffsets, -1); + } + + public Vector128 CurTime4 => Vector128.Create(CurTime); + + public bool Init(ParticleSystemMgr mgr, string? particleSystemName) { + if (particleSystemName == null) + return false; + + ParticleSystemDefinition? def = mgr.FindParticleSystem(particleSystemName); + if (def == null) { + Warning($"Attempted to create unknown particle system type \"{particleSystemName}\"!\n"); + return false; + } + return Init(mgr, def); + } + + public bool Init(ParticleSystemMgr mgr, ParticleSystemDefinition? def) { + if (def == null) { + Warning("Particlelib: Missing precache for particle system type \"unknown\"!\n"); + def = mgr.FindParticleSystem("error"); + if (def == null) + return false; + } + Init(def, 0.0f, 0); + return IsValid(); + } + + internal void Init(ParticleSystemDefinition def, float delay, int randomSeed) { + Def = def; + Mgr = def.Mgr; + LinkIntoDefList(); + InitStorage(def); + Sheet = Mgr.FindOrLoadSheet(PrecachedMaterial()); + + IsScrubbable = randomSeed != 0; + if (randomSeed == 0) + RandomSeed = RuntimeHelpers.GetHashCode(this) + (int)(uint)MSTime; + else + RandomSeed = randomSeed; + + SetAttributeToConstant(PARTICLE_ATTRIBUTE_XYZ, 0.0f, 0.0f, 0.0f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_PREV_XYZ, 0.0f, 0.0f, 0.0f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_LIFE_DURATION, 1.0f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_RADIUS, def.ConstantRadius); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_ROTATION, def.ConstantRotation); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_ROTATION_SPEED, def.ConstantRotationSpeed); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_TINT_RGB, def.ConstantColor.R * 0.003921569f, def.ConstantColor.G * 0.003921569f, def.ConstantColor.B * 0.003921569f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_ALPHA, def.ConstantColor.A * 0.003921569f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_CREATION_TIME, 0.0f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, def.ConstantSequenceNumber); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1, def.ConstantSequenceNumber1); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, 0.1f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_PARTICLE_ID, 0); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_YAW, 0); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_ALPHA2, 1.0f); + SetAttributeToConstant(PARTICLE_ATTRIBUTE_NORMAL, def.ConstantNormal.X, def.ConstantNormal.Y, def.ConstantNormal.Z); + + CurTime = -delay; + + if (def.ContextDataSize != 0) + OperatorContextData = new byte[def.ContextDataSize]; + + NextSleepTime = Mgr.GetLastSimulationTime() + def.NoDrawTimeToGoToSleep; + + ReadOnlySpan> olists = [def.Operators, def.Renderers, def.Initializers, def.Emitters, def.ForceGenerators, def.Constraints]; + ReadOnlySpan> offsetLists = [def.OperatorsCtxOffsets, def.RenderersCtxOffsets, def.InitializersCtxOffsets, def.EmittersCtxOffsets, def.ForceGeneratorsCtxOffsets, def.ConstraintsCtxOffsets]; + for (int i = 0; i < olists.Length; i++) { + for (int j = 0; j < olists[i].Count; j++) + olists[i][j].InitializeContextData(this, ContextSpan(offsetLists[i][j])); + } + + ControlPointReadMask = def.ControlPointReadMask; + + foreach (ParticleChildrenInfo child in def.Children) { + if (randomSeed != 0) + randomSeed += 129; + + float childDelay = child.Delay - CurTime; + ParticleCollection? childCollection = child.UseNameBasedLookup + ? Mgr.CreateParticleCollection(child.Name, childDelay, randomSeed) + : Mgr.CreateParticleCollection(child.Id, childDelay, randomSeed); + + if (childCollection == null) + continue; + + childCollection.Parent = this; + childCollection.Next = null; + if (Children == null) + Children = childCollection; + else { + ParticleCollection tail = Children; + while (tail.Next != null) + tail = tail.Next; + tail.Next = childCollection; + childCollection.Prev = tail; + } + ControlPointReadMask |= childCollection.ControlPointReadMask; + } + + if (Def != null && Def.IsPrecached && Def.Material.Get() != null) { + IsTranslucent_ = ComputeIsTranslucent(); + IsTwoPass_ = ComputeIsTranslucent() && ContainsOpaqueCollections(); + IsBatchable_ = ComputeIsBatchable(); + LabelTextureUsage(); + AnyUsesPowerOfTwoFrameBufferTexture = ComputeUsesPowerOfTwoFrameBufferTexture(); + AnyUsesFullFrameBufferTexture = ComputeUsesFullFrameBufferTexture(); + RequiresOrderInvariance = ComputeRequiresOrderInvariance(); + } + } + + public void Destroy() { + UnlinkFromDefList(); + + ParticleCollection? child = Children; + while (child != null) { + ParticleCollection? next = child.Next; + child.Destroy(); + Children = next; + child = next; + } + + Memory = []; + OperatorContextData = null; + Sheet = null; + Array.Clear(CollisionCacheData); + foreach (ModelHitBoxesInfo info in ControlPointHitBoxes) { + info.HitBoxes = null; + info.PrevBoxes = null; + } + Def = null; + } + + void InitStorage(ParticleSystemDefinition def) { + int maxParticles = def.MaxParticles; + int allocated; + if (maxParticles < MAX_PARTICLES_IN_A_SYSTEM) + allocated = ((maxParticles + 3) / 4) * 4 + 4; + else { + allocated = MAX_PARTICLES_IN_A_SYSTEM + 4; + maxParticles = MAX_PARTICLES_IN_A_SYSTEM; + } + AllocatedParticles = allocated; + MaxAllowedParticles = maxParticles; + + PerParticleInitializedAttributeMask = def.PerParticleInitializedAttributeMask; + PerParticleUpdatedAttributeMask = def.PerParticleUpdatedAttributeMask; + int perParticleAttributeMask = PerParticleInitializedAttributeMask | PerParticleUpdatedAttributeMask; + PerParticleReadInitialAttributeMask = def.InitialAttributeReadMask & def.PerParticleUpdatedAttributeMask & def.PerParticleInitializedAttributeMask; + int constantInitialMask = def.InitialAttributeReadMask & def.PerParticleInitializedAttributeMask & ~def.PerParticleUpdatedAttributeMask; + + int floatsPerParticle = 0; + int initialFloatsPerParticle = 0; + for (int bit = 0; bit < MAX_PARTICLE_ATTRIBUTES; bit++) { + int attrSize = AttributeSize(bit); + if ((perParticleAttributeMask & (1 << bit)) != 0) + floatsPerParticle += attrSize; + if ((PerParticleReadInitialAttributeMask & (1 << bit)) != 0) + initialFloatsPerParticle += attrSize; + } + + Memory = new float[CONSTANT_FLOATS + (floatsPerParticle + initialFloatsPerParticle) * allocated]; + + int cursor = CONSTANT_FLOATS; + int initialCursor = CONSTANT_FLOATS + floatsPerParticle * allocated; + for (int bit = 0; bit < MAX_PARTICLE_ATTRIBUTES; bit++) { + int attrSize = AttributeSize(bit); + if ((perParticleAttributeMask & (1 << bit)) == 0) { + ParticleFloatStrides[bit] = 0; + AttributeOffsets[bit] = ConstantOffset(bit); + } + else { + ParticleFloatStrides[bit] = attrSize * 4; + AttributeOffsets[bit] = cursor; + cursor += allocated * attrSize; + } + + if ((def.InitialAttributeReadMask & (1 << bit)) == 0) { + InitialAttributeOffsets[bit] = -1; + ParticleInitialFloatStrides[bit] = 0; + } + else if ((PerParticleReadInitialAttributeMask & (1 << bit)) != 0) { + InitialAttributeOffsets[bit] = initialCursor; + ParticleInitialFloatStrides[bit] = attrSize * 4; + initialCursor += attrSize * allocated; + } + else if ((constantInitialMask & (1 << bit)) != 0) { + InitialAttributeOffsets[bit] = AttributeOffsets[bit]; + ParticleInitialFloatStrides[bit] = ParticleFloatStrides[bit]; + } + else { + InitialAttributeOffsets[bit] = ConstantOffset(bit); + ParticleInitialFloatStrides[bit] = 0; + } + } + } + + static int AttributeSize(int attribute) => (ATTRIBUTES_WHICH_ARE_VEC3S_MASK & (1 << attribute)) != 0 ? 3 : 1; + static int ConstantOffset(int attribute) => 12 * attribute; + + Span ContextSpan(int offset) => OperatorContextData.AsSpan(offset); + + public string GetName() => Def?.GetName() ?? ""; + public bool IsValid() => Def != null && Def.GetMaterial() != null; + public int GetGroupID() => Def!.GroupID; + + void LinkIntoDefList() { + PrevDef = null; + NextDef = Def!.FirstCollection; + Def.FirstCollection = this; + if (NextDef != null) + NextDef.PrevDef = this; + } + + public void UnlinkFromDefList() { + if (Def == null) + return; + + if (Def.FirstCollection == this) + Def.FirstCollection = NextDef; + else + PrevDef!.NextDef = NextDef; + + if (NextDef != null) + NextDef.PrevDef = PrevDef; + + NextDef = null; + PrevDef = null; + } + + public ParticleCollection? GetNextCollectionUsingSameDef() => NextDef; + + public Span AttributeMemory => Memory; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetAttributeIndex(int attribute, int particleNumber) + => AttributeOffsets[attribute] + ParticleFloatStrides[attribute] * (particleNumber / 4) + (particleNumber & 3); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetInitialAttributeIndex(int attribute, int particleNumber) + => InitialAttributeOffsets[attribute] + ParticleInitialFloatStrides[attribute] * (particleNumber / 4) + (particleNumber & 3); + + public int GetAttributeOffset(int attribute, out int floatStride) { + floatStride = ParticleFloatStrides[attribute]; + return AttributeOffsets[attribute]; + } + + public int GetInitialAttributeOffset(int attribute, out int floatStride) { + floatStride = ParticleInitialFloatStrides[attribute]; + return InitialAttributeOffsets[attribute]; + } + + public float GetFloatAttributeValue(int attribute, int particleNumber) => Memory[GetAttributeIndex(attribute, particleNumber)]; + public int GetIntAttributeValue(int attribute, int particleNumber) => BitConverter.SingleToInt32Bits(Memory[GetAttributeIndex(attribute, particleNumber)]); + + public Vector3 GetVectorAttributeValue(int attribute, int particleNumber) { + int index = GetAttributeIndex(attribute, particleNumber); + return new(Memory[index], Memory[index + 4], Memory[index + 8]); + } + + public ref float GetFloatAttributeRefForWrite(int attribute, int particleNumber) => ref Memory[GetAttributeIndex(attribute, particleNumber)]; + public ref int GetIntAttributeRefForWrite(int attribute, int particleNumber) => ref Unsafe.As(ref Memory[GetAttributeIndex(attribute, particleNumber)]); + public ref Vector128 GetM128AttributeRefForWrite(int attribute, int block) => ref Unsafe.As>(ref Memory[AttributeOffsets[attribute] + ParticleFloatStrides[attribute] * block]); + + public void SetVectorAttribute(int attribute, int particleNumber, Vector3 v) { + int index = GetAttributeIndex(attribute, particleNumber); + Memory[index] = v.X; + Memory[index + 4] = v.Y; + Memory[index + 8] = v.Z; + } + + public float GetInitialFloatAttributeValue(int attribute, int particleNumber) => Memory[GetInitialAttributeIndex(attribute, particleNumber)]; + + public Vector3 GetInitialVectorAttributeValue(int attribute, int particleNumber) { + int index = GetInitialAttributeIndex(attribute, particleNumber); + return new(Memory[index], Memory[index + 4], Memory[index + 8]); + } + + public ref float GetInitialFloatAttributeRefForWrite(int attribute, int particleNumber) => ref Memory[GetInitialAttributeIndex(attribute, particleNumber)]; + + public Span GetConstantAttributeMemory(int attribute) => Memory.AsSpan(ConstantOffset(attribute), 12); + + void SetAttributeToConstant(int attribute, float value) => Memory.AsSpan(ConstantOffset(attribute), 4).Fill(value); + + void SetAttributeToConstant(int attribute, float x, float y, float z) { + Span constant = Memory.AsSpan(ConstantOffset(attribute), 12); + constant[..4].Fill(x); + constant[4..8].Fill(y); + constant[8..].Fill(z); + } + + public void FillAttributeWithConstant(int attribute, float value) { + int offset = GetAttributeOffset(attribute, out int stride); + for (int i = 0; i < PaddedActiveParticles; i++) { + Memory.AsSpan(offset, 4).Fill(value); + offset += stride; + } + } + + public void SwapPosAndPrevPos() + => (AttributeOffsets[PARTICLE_ATTRIBUTE_XYZ], AttributeOffsets[PARTICLE_ATTRIBUTE_PREV_XYZ]) = (AttributeOffsets[PARTICLE_ATTRIBUTE_PREV_XYZ], AttributeOffsets[PARTICLE_ATTRIBUTE_XYZ]); + + public void SetNActiveParticles(int count) { + ActiveParticles = count; + PaddedActiveParticles = (count + 3) / 4; + } + + public void KillParticle(int particleIndex) => ParticleKillList![NumParticlesToKill++] = particleIndex; + + public bool HasAttachedKillList() => ParticleKillList != null; + + public void LoanKillListTo(ParticleCollection borrower) { + borrower.NumParticlesToKill = 0; + borrower.ParticleKillList = ParticleKillList; + } + + public bool ReadsControlPoint(int point) => (ControlPointReadMask & (1UL << point)) != 0; + + public void ResetControlPoints() { + HighestCP = 0; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.ResetControlPoints(); + } + + public int GetControlPointIndex() => TargetCP; + + public void SetControlPointIndex(int whichPoint) { + HighestCP = Math.Max(HighestCP, whichPoint); + TargetCP = whichPoint; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointIndex(whichPoint); + } + + public void SetControlPoint(int whichPoint, in Vector3 v) { + HighestCP = Math.Max(HighestCP, whichPoint); + ControlPoints[whichPoint].Position = v; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPoint(whichPoint, v); + } + + public void SetControlPointObject(int whichPoint, object? obj) { + ControlPoints[whichPoint].Object = obj; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointObject(whichPoint, obj); + } + + public void SetControlPointOrientation(int whichPoint, in Vector3 forward, in Vector3 right, in Vector3 up) { + if (MathF.Abs(Vector3.Dot(forward, up)) <= 0.1f && MathF.Abs(Vector3.Dot(forward, right)) <= 0.1f && MathF.Abs(Vector3.Dot(right, up)) <= 0.1f) { + ref ParticleControlPoint cp = ref ControlPoints[whichPoint]; + cp.ForwardVector = forward; + cp.UpVector = up; + cp.RightVector = right; + + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointOrientation(whichPoint, forward, right, up); + } + else + Warning($"Attempt to set particle collection {GetName()} to invalid orientation matrix\n"); + } + + public void SetControlPointOrientation(int whichPoint, in Quaternion q) { + MathLib.QuaternionMatrix(in q, out Matrix3x4 mat); + MathLib.MatrixGetColumn(in mat, 0, out Vector3 forward); + MathLib.MatrixGetColumn(in mat, 1, out Vector3 left); + MathLib.MatrixGetColumn(in mat, 2, out Vector3 up); + SetControlPointOrientation(whichPoint, forward, -left, up); + } + + public Vector3 TransformAxis(in Vector3 srcAxis, bool localSpace, int controlPointNumber = 0) { + if (!localSpace) + return srcAxis; + + ref ParticleControlPoint cp = ref ControlPoints[controlPointNumber]; + return srcAxis.X * cp.RightVector + srcAxis.Y * cp.ForwardVector + srcAxis.Z * cp.UpVector; + } + + public void SetControlPointForwardVector(int whichPoint, in Vector3 v) { + ControlPoints[whichPoint].ForwardVector = v; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointForwardVector(whichPoint, v); + } + + public void SetControlPointUpVector(int whichPoint, in Vector3 v) { + ControlPoints[whichPoint].UpVector = v; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointUpVector(whichPoint, v); + } + + public void SetControlPointRightVector(int whichPoint, in Vector3 v) { + ControlPoints[whichPoint].RightVector = v; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointRightVector(whichPoint, v); + } + + public void SetControlPointParent(int whichPoint, int n) { + ControlPoints[whichPoint].Parent = n; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointParent(whichPoint, n); + } + + public void SetControlPointVelocity(int whichPoint, Vector3 velocity) { + HighestCP = Math.Max(HighestCP, whichPoint); + ControlPoints[whichPoint].Velocity = velocity; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointVelocity(whichPoint, velocity); + } + + public void SetControlPointDensity(int whichPoint, float density) { + HighestCP = Math.Max(HighestCP, whichPoint); + ControlPoints[whichPoint].Density = density; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointDensity(whichPoint, density); + } + + public void SetControlPointDuration(int whichPoint, float duration) { + HighestCP = Math.Max(HighestCP, whichPoint); + ControlPoints[whichPoint].Duration = duration; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointDuration(whichPoint, duration); + } + + public void SetControlPointRadius(int whichPoint, float radius) { + HighestCP = Math.Max(HighestCP, whichPoint); + ControlPoints[whichPoint].Radius = radius; + for (ParticleCollection? i = Children; i != null; i = i.Next) + i.SetControlPointRadius(whichPoint, radius); + } + + public ref readonly ParticleControlPoint ControlPoint(int index) => ref ControlPoints[index]; + public ref readonly Vector3 GetControlPointAtCurrentTime(int controlPoint) => ref ControlPoints[controlPoint].Position; + + public void GetControlPointOrientationAtCurrentTime(int controlPoint, out Vector3 forward, out Vector3 right, out Vector3 up) { + ref ParticleControlPoint cp = ref ControlPoints[controlPoint]; + forward = cp.ForwardVector; + right = cp.RightVector; + up = cp.UpVector; + } + + public int GetControlPointParent(int controlPoint) => ControlPoints[controlPoint].Parent; + public float GetControlPointRadiusAtCurrentTime(int controlPoint) => ControlPoints[controlPoint].Radius; + public float GetControlPointDensityAtCurrentTime(int controlPoint) => ControlPoints[controlPoint].Density; + public float GetControlPointDurationAtCurrentTime(int controlPoint) => ControlPoints[controlPoint].Duration; + public Vector3 GetControlPointVelocityAtCurrentTime(int controlPoint) => ControlPoints[controlPoint].Velocity; + + public void GetControlPointAtTime(int controlPoint, float time, out Vector3 controlPointOut) { + if (controlPoint > HighestCP) + DevWarning(2, $"Warning : Particle system ({GetName()}) using unassigned ControlPoint {controlPoint}!\n"); + + ref ParticleControlPoint cp = ref ControlPoints[controlPoint]; + if (Dt == 0.0f) { + controlPointOut = cp.Position; + return; + } + + float t = (time + Dt - CurTime) / Dt; + if (t <= 0.0f) + t = 0.0f; + controlPointOut = new( + (cp.Position.X - cp.PrevPosition.X) * t + cp.PrevPosition.X, + (cp.Position.Y - cp.PrevPosition.Y) * t + cp.PrevPosition.Y, + t * (cp.Position.Z - cp.PrevPosition.Z) + cp.PrevPosition.Z + ); + } + + public void GetControlPointAtPrevTime(int controlPoint, out Vector3 controlPointOut) => controlPointOut = ControlPoints[controlPoint].PrevPosition; + + public void GetControlPointOrientationAtTime(int controlPoint, float time, out Vector3 forward, out Vector3 right, out Vector3 up) + => GetControlPointOrientationAtCurrentTime(controlPoint, out forward, out right, out up); + + public void GetControlPointTransformAtCurrentTime(int controlPoint, out Matrix3x4 mat) + => BuildControlPointTransform(controlPoint, ControlPoints[controlPoint].Position, out mat); + + public void GetControlPointTransformAtTime(int controlPoint, float time, out Matrix3x4 mat) { + GetControlPointAtTime(controlPoint, time, out Vector3 position); + BuildControlPointTransform(controlPoint, position, out mat); + } + + void BuildControlPointTransform(int controlPoint, in Vector3 position, out Matrix3x4 mat) { + ref ParticleControlPoint cp = ref ControlPoints[controlPoint]; + mat = new( + cp.ForwardVector.X, -cp.RightVector.X, cp.UpVector.X, position.X, + cp.ForwardVector.Y, -cp.RightVector.Y, cp.UpVector.Y, position.Y, + cp.ForwardVector.Z, -cp.RightVector.Z, cp.UpVector.Z, position.Z + ); + } + + public int GetHighestControlPoint() => HighestCP; + + public void GetBounds(out Vector3 min, out Vector3 max) { + min = MinBounds; + max = MaxBounds; + } + + public bool HasMoved() { + if (Def == null) + return false; + + for (int i = 0; i <= HighestCP; i++) { + if ((Def.ControlPointReadMask & (1UL << i)) != 0 && ControlPoints[i].PrevPosition != ControlPoints[i].Position) + return true; + } + + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.HasMoved()) + return true; + } + return false; + } + + public int OperatorRandomSampleOffset() => OperatorRandomSampleOffset_; + + public int RandomInt(int randomSampleId, int min, int max) { + float rand = RandomFloats[(RandomSeed + randomSampleId) & RANDOM_FLOAT_MASK]; + rand *= max + 1 - min; + return (int)rand + min; + } + + public float RandomFloat(int randomSampleId, float min, float max) { + float rand = RandomFloats[(RandomSeed + randomSampleId) & RANDOM_FLOAT_MASK]; + rand *= max - min; + rand += min; + return rand; + } + + public Vector128 RandomFloat(Vector128 particleId, int randomSampleOffset) { + int ofs = RandomSeed + randomSampleOffset; + return Vector128.Create( + RandomFloats[(ofs + particleId[0]) & RANDOM_FLOAT_MASK], + RandomFloats[(ofs + particleId[1]) & RANDOM_FLOAT_MASK], + RandomFloats[(ofs + particleId[2]) & RANDOM_FLOAT_MASK], + RandomFloats[(ofs + particleId[3]) & RANDOM_FLOAT_MASK] + ); + } + + public float OperatorRandomFloat(int particle, int randomOffset) + => RandomFloats[(GetIntAttributeValue(PARTICLE_ATTRIBUTE_PARTICLE_ID, particle) + RandomSeed + randomOffset) & RANDOM_FLOAT_MASK]; + + public float OperatorRandomFloat(int particle) => OperatorRandomFloat(particle, OperatorRandomSampleOffset_); + + public float RandomFloatExp(int randomSampleId, float min, float max, float exponent) { + float rand = RandomFloats[(RandomSeed + randomSampleId) & RANDOM_FLOAT_MASK]; + rand = MathF.Pow(rand, exponent); + rand *= max - min; + rand += min; + return rand; + } + + public void RandomVector(int randomSampleId, float min, float max, out Vector3 vector) { + float delta = max - min; + int baseId = RandomSeed + randomSampleId; + vector.X = RandomFloats[baseId & RANDOM_FLOAT_MASK] * delta + min; + vector.Y = RandomFloats[(baseId + 1) & RANDOM_FLOAT_MASK] * delta + min; + vector.Z = RandomFloats[(baseId + 2) & RANDOM_FLOAT_MASK] * delta + min; + } + + public void RandomVector(int randomSampleId, in Vector3 vecMin, in Vector3 vecMax, out Vector3 vector) { + int baseId = RandomSeed + randomSampleId; + vector.X = RandomFloat(baseId, vecMin.X, vecMax.X); + vector.Y = RandomFloat(baseId + 1, vecMin.Y, vecMax.Y); + vector.Z = RandomFloat(baseId + 2, vecMin.Z, vecMax.Z); + } + + public float RandomVectorInUnitSphere(int randomSampleId, out Vector3 vector) { + float r0 = RandomFloats[(randomSampleId + RandomSeed) & RANDOM_FLOAT_MASK] * 0.9999f + 0.0001f; + float r1 = RandomFloats[(RandomSeed + 1 + randomSampleId) & RANDOM_FLOAT_MASK] * 0.9999f + 0.0001f; + float r2 = RandomFloats[(RandomSeed + 2 + randomSampleId) & RANDOM_FLOAT_MASK] * 0.9999f + 0.0001f; + + (float sinPhi, float cosPhi) = MathF.SinCos(MathF.Acos(1.0f - (r0 + r0))); + (float sinTheta, float cosTheta) = MathF.SinCos(r1 * 6.2831855f); + float radius = MathF.Pow(r2, 0.33333334f); + + vector.Z = cosPhi * radius; + vector.X = sinPhi * radius * cosTheta; + vector.Y = sinPhi * radius * sinTheta; + return radius; + } + + public int RandomInt(int min, int max) => RandomInt(RandomQueryCount++, min, max); + public float RandomFloat(float min, float max) => RandomFloat(RandomQueryCount++, min, max); + public float RandomFloatExp(float min, float max, float exponent) => RandomFloatExp(RandomQueryCount++, min, max, exponent); + public void RandomVector(float min, float max, out Vector3 vector) { + RandomVector(RandomQueryCount, min, max, out vector); + RandomQueryCount += 3; + } + + public void RandomVector(in Vector3 vecMin, in Vector3 vecMax, out Vector3 vector) { + RandomVector(RandomQueryCount, vecMin, vecMax, out vector); + RandomQueryCount += 3; + } + public float RandomVectorInUnitSphere(out Vector3 vector) { + float radius = RandomVectorInUnitSphere(RandomQueryCount, out vector); + RandomQueryCount += 3; + return radius; + } + + static float FadeInOut(float fadeInStart, float fadeInEnd, float fadeOutStart, float fadeOutEnd, float curTime) { + if (fadeInStart > curTime || (fadeOutEnd > 0.0f && curTime > fadeOutEnd)) + return 0.0f; + + if (fadeInEnd <= fadeInStart) + fadeInEnd = fadeInStart; + if (fadeOutStart <= fadeInEnd) + fadeOutStart = fadeInEnd; + if (fadeOutEnd <= fadeOutStart) + fadeOutEnd = fadeOutStart; + + float strength; + if (fadeInEnd <= fadeInStart || fadeInEnd <= curTime) + strength = 1.0f; + else { + strength = (curTime - fadeInStart) / (fadeInEnd - fadeInStart); + if (strength >= 1.0f) + strength = 1.0f; + } + + if (fadeOutStart < fadeOutEnd && fadeOutStart < curTime) { + float fadeOut = (curTime - fadeOutEnd) / (fadeOutStart - fadeOutEnd); + if (fadeOut <= strength) + strength = fadeOut; + } + return strength; + } + + public bool CheckIfOperatorShouldRun(ParticleOperatorInstance op, out float curStrength, bool applyingParentKillList = false) { + curStrength = 0.0f; + if (!op.ShouldRun(applyingParentKillList)) + return false; + + if (op.StrengthFastPath) { + curStrength = 1.0f; + return true; + } + + if (op.OpEndCapState != -1 && InEndCap != (op.OpEndCapState == 1)) + return false; + + float time = CurTime; + if (op.OpTimeOffsetSeed != 0) { + time = CurTime + RandomFloat(op.OpTimeOffsetSeed, op.OpTimeOffsetMin, op.OpTimeOffsetMax); + if (time < 0.0f) + time = 0.0f; + } + + if (op.OpTimeScaleSeed != 0 && op.OpStartFadeInTime < time) { + double timeScale = Math.Max(0.0001, RandomFloat(op.OpTimeScaleSeed, op.OpTimeScaleMin, op.OpTimeScaleMax)); + time = (float)(1.0 / timeScale) * (time - op.OpStartFadeInTime) + op.OpStartFadeInTime; + } + + if (op.OpFadeOscillatePeriod > 0.0f) + time = (float)((double)(CurTime / op.OpFadeOscillatePeriod) % 1.0); + + curStrength = FadeInOut(op.OpStartFadeInTime, op.OpEndFadeInTime, op.OpStartFadeOutTime, op.OpEndFadeOutTime, time); + + if (op.OpStrengthScaleSeed != 0) + curStrength *= Math.Max(0.0f, RandomFloat(op.OpStrengthScaleSeed, op.OpStrengthMinScale, op.OpStrengthMaxScale) * curStrength); + + return curStrength > 0.0f; + } + + public void Restart() { + ParticleSystemDefinition def = Def!; + for (int i = 0; i < def.Emitters.Count; i++) + def.Emitters[i].Restart(this, ContextSpan(def.EmittersCtxOffsets[i])); + + for (ParticleCollection? child = Children; child != null; child = child.Next) + child.Restart(); + } + + void UpdatePrevControlPoints(float dt) { + PreviousDt = dt; + for (int i = 0; i <= HighestCP; i++) + ControlPoints[i].PrevPosition = ControlPoints[i].Position; + ParticleFlags |= PCFLAGS_PREV_CONTROL_POINTS_INITIALIZED; + } + + public void InitializeNewParticles(int firstParticle, int particleCount, uint inittedMask) { + ParticleSystemDefinition def = Def!; + int attrsLeftToInit = (PerParticleInitializedAttributeMask | PerParticleUpdatedAttributeMask) & ~(int)inittedMask; + + int count = def.Initializers.Count; + if (count > 0) { + for (int i = 0; i < count; i++) { + ParticleOperatorInstance op = def.Initializers[i]; + int written = (int)op.GetWrittenAttributes(); + if ((attrsLeftToInit & written) == 0 || op.InitMultipleOverride()) + continue; + + RunInitializer(op, ContextSpan(def.InitializersCtxOffsets[i]), firstParticle, particleCount, attrsLeftToInit); + attrsLeftToInit &= ~written; + } + + for (int i = 0; i < count; i++) { + ParticleOperatorInstance op = def.Initializers[i]; + int written = (int)op.GetWrittenAttributes(); + if (!op.InitMultipleOverride()) + continue; + + RunInitializer(op, ContextSpan(def.InitializersCtxOffsets[i]), firstParticle, particleCount, attrsLeftToInit); + attrsLeftToInit &= ~written; + } + } + + if (attrsLeftToInit != 0) + InitParticleAttributes(firstParticle, particleCount, attrsLeftToInit); + + if (PerParticleReadInitialAttributeMask != 0) + CopyInitialAttributeValues(firstParticle, particleCount); + } + + void RunInitializer(ParticleOperatorInstance op, Span context, int firstParticle, int particleCount, int attrsLeftToInit) { + if (IsScrubbable && !op.IsScrubSafe()) { + for (int p = firstParticle; p < firstParticle + particleCount; p++) + op.InitNewParticlesScalar(this, p, 1, attrsLeftToInit, context); + } + else + op.InitNewParticles(this, firstParticle, particleCount, attrsLeftToInit, context); + } + + void InitParticleAttributes(int startParticle, int numParticles, int attrsLeftToInit) { + for (int p = startParticle; p < startParticle + numParticles; p++) { + for (int attr = 0; attr < MAX_PARTICLE_ATTRIBUTES; attr++) { + if ((attrsLeftToInit & (1 << attr)) == 0) + continue; + + int index = GetAttributeIndex(attr, p); + if (attr == PARTICLE_ATTRIBUTE_PARTICLE_ID) { + Memory[index] = BitConverter.Int32BitsToSingle((UniqueParticleId + RandomSeed) & RANDOM_FLOAT_MASK); + UniqueParticleId++; + } + else if (attr == PARTICLE_ATTRIBUTE_CREATION_TIME) + Memory[index] = CurTime; + else { + int constant = ConstantOffset(attr); + Memory[index] = Memory[constant]; + if (ParticleFloatStrides[attr] == 12) { + Memory[index + 4] = Memory[constant + 4]; + Memory[index + 8] = Memory[constant + 8]; + } + } + } + } + } + + void CopyInitialAttributeValues(int startParticle, int numParticles) { + for (int p = startParticle; p < startParticle + numParticles; p++) { + for (int attr = 0; attr < MAX_PARTICLE_ATTRIBUTES; attr++) { + if ((PerParticleReadInitialAttributeMask & (1 << attr)) == 0) + continue; + + int src = GetAttributeIndex(attr, p); + int dst = GetInitialAttributeIndex(attr, p); + Memory[dst] = Memory[src]; + if (ParticleFloatStrides[attr] == 12) { + Memory[dst + 4] = Memory[src + 4]; + Memory[dst + 8] = Memory[src + 8]; + } + } + } + } + + public void SkipToTime(float t) { + if (t <= CurTime) + return; + + UpdatePrevControlPoints(t - CurTime); + CurTime = t; + ParticleFlags &= ~PCFLAGS_FIRST_FRAME; + + ParticleSystemDefinition def = Def!; + for (int i = 0; i < def.Emitters.Count; i++) + def.Emitters[i].SkipToTime(t, this, ContextSpan(def.EmittersCtxOffsets[i])); + + int childIndex = 0; + for (ParticleCollection? child = Children; child != null; child = child.Next) + child.SkipToTime(t - def.Children[childIndex++].Delay); + } + + void SimulateFirstFrame() { + Dt = 0.0f; + DrawnFrames = 0; + SimulatedFrames = 1; + + if ((ParticleFlags & PCFLAGS_PREV_CONTROL_POINTS_INITIALIZED) == 0) + UpdatePrevControlPoints(0.05f); + + OperatorRandomSampleOffset_ = 0; + ParticleSystemDefinition def = Def!; + for (int i = 0; i < def.Operators.Count; i++) { + ParticleOperatorInstance op = def.Operators[i]; + if (op.ShouldRunBeforeEmitters() && CheckIfOperatorShouldRun(op, out float strength)) { + op.Operate(this, strength, ContextSpan(def.OperatorsCtxOffsets[i])); + UpdatePrevControlPoints(0.05f); + } + OperatorRandomSampleOffset_ += 17; + } + + int initialParticles = Math.Min(def.InitialParticles, MaxAllowedParticles); + if (initialParticles < 1) + return; + + SetNActiveParticles(initialParticles); + InitializeNewParticles(0, initialParticles, 0); + } + + public void Simulate(float dt, bool updateBboxOnly) { + if (dt < 0.0f || Def == null) + return; + + if (CurTime < 0.0f) { + if (dt >= 1e-22f) { + CurTime += dt; + UpdatePrevControlPoints(dt); + } + return; + } + + if ((ParticleFlags & PCFLAGS_FIRST_FRAME) != 0) { + SimulateFirstFrame(); + ParticleFlags &= ~PCFLAGS_FIRST_FRAME; + } + + if (dt < 1e-22f) + return; + + bool attachedKillList = false; + if (ParticleKillList == null) { + Mgr!.AttachKillList(this); + attachedKillList = true; + } + + if (!updateBboxOnly) + RunSimulationSteps(dt); + + for (ParticleCollection? child = Children; child != null; child = child.Next) { + child.NumParticlesToKill = 0; + child.ParticleKillList = ParticleKillList; + child.Simulate(dt, updateBboxOnly); + child.ParticleKillList = null; + } + + if (attachedKillList) + Mgr!.DetachKillList(this); + + UpdatePrevControlPoints(dt); + BloatBoundsUsingControlPoint(); + } + + void RunSimulationSteps(float dt) { + ParticleSystemDefinition def = Def!; + SimulatedFrames++; + + float maxTimeStep = def.MaximumTimeStep; + float maxDt; + if (maxTimeStep <= 0.0f) { + maxTimeStep = 0.1f; + maxDt = 1.0f; + } + else + maxDt = maxTimeStep * 10.0f; + + float remaining = dt; + if (def.MaximumSimTime != 0.0f && DrawnFrames <= def.MinimumFrames) { + if (dt + CurTime > def.MaximumSimTime) { + remaining = def.MaximumSimTime - CurTime; + if (remaining < def.MinimumSimTime) + remaining = def.MinimumSimTime; + } + DrawnFrames++; + } + + if (remaining >= maxDt) + remaining = maxDt; + + while (remaining > 0.0f) { + OperatorRandomSampleOffset_ = 0; + float step = remaining <= maxTimeStep ? remaining : maxTimeStep; + remaining -= step; + PrevSimTime = 1.0e23f; + Dt = step; + CurTime += step; + + for (int i = 0; i < def.Operators.Count; i++) { + ParticleOperatorInstance op = def.Operators[i]; + if (!op.ShouldRunBeforeEmitters() || !CheckIfOperatorShouldRun(op, out float strength)) + continue; + + op.Operate(this, strength, ContextSpan(def.OperatorsCtxOffsets[i])); + if (NumParticlesToKill != 0) + ApplyKillList(); + OperatorRandomSampleOffset_ += 17; + } + + int prevActive = ActiveParticles; + for (int i = 0; i < def.Emitters.Count; i++) { + ParticleOperatorInstance emitter = def.Emitters[i]; + if (CheckIfOperatorShouldRun(emitter, out float strength)) { + uint inittedMask = emitter.Emit(this, strength, ContextSpan(def.EmittersCtxOffsets[i])); + if (ActiveParticles != prevActive) + InitializeNewParticles(prevActive, ActiveParticles - prevActive, inittedMask); + } + prevActive = ActiveParticles; + } + + OperatorRandomSampleOffset_ = 0; + if (prevActive == 0) + continue; + + for (int i = 0; i < def.Operators.Count; i++) { + ParticleOperatorInstance op = def.Operators[i]; + if (op.ShouldRunBeforeEmitters() || !CheckIfOperatorShouldRun(op, out float strength)) + continue; + + op.Operate(this, strength, ContextSpan(def.OperatorsCtxOffsets[i])); + if (NumParticlesToKill != 0) { + ApplyKillList(); + if (ActiveParticles == 0) + break; + } + OperatorRandomSampleOffset_ += 17; + } + } + } + + void MoveParticle(int initialIndex, int newIndex) { + int newVec = (newIndex & 3) + (newIndex >> 2) * 12; + int oldVec = (initialIndex & 3) + (initialIndex >> 2) * 12; + + for (int attr = 0; attr < MAX_PARTICLE_ATTRIBUTES; attr++) { + MoveAttribute(AttributeOffsets[attr], ParticleFloatStrides[attr], initialIndex, newIndex, oldVec, newVec); + MoveAttribute(InitialAttributeOffsets[attr], ParticleInitialFloatStrides[attr], initialIndex, newIndex, oldVec, newVec); + } + } + + void MoveAttribute(int offset, int stride, int initialIndex, int newIndex, int oldVec, int newVec) { + if (stride == 4) + Memory[offset + newIndex] = Memory[offset + initialIndex]; + else if (stride == 12) { + Memory[offset + newVec] = Memory[offset + oldVec]; + Memory[offset + newVec + 4] = Memory[offset + oldVec + 4]; + Memory[offset + newVec + 8] = Memory[offset + oldVec + 8]; + } + } + + void ApplyKillList() { + int leftInKillList = NumParticlesToKill; + if (leftInKillList == 0) + return; + + int activeNow = ActiveParticles; + int[] killList = ParticleKillList!; + int slot = 0; + + while (leftInKillList != 0 && killList[leftInKillList - 1] >= activeNow) + leftInKillList--; + + if (RequiresOrderInvariance) { + int remaining = leftInKillList - 1; + int finalCount = activeNow - leftInKillList; + int writeIndex = killList[slot++]; + for (int readIndex = writeIndex + 1; readIndex < activeNow; readIndex++) { + if (remaining >= 1 && killList[slot] == readIndex) { + slot++; + remaining--; + continue; + } + MoveParticle(readIndex, writeIndex++); + } + activeNow = finalCount; + } + else if (leftInKillList != 0) { + int killIndex = killList[slot]; + while (true) { + if (leftInKillList - 1 == 0) { + activeNow--; + if (killIndex != activeNow) + MoveParticle(activeNow, killIndex); + break; + } + + int last = leftInKillList - 1; + bool tailConsumed = false; + while (true) { + int previous = activeNow; + activeNow = previous - 1; + if (killList[slot + last] != activeNow) + break; + last--; + if (last == 0) { + activeNow = previous - 2; + tailConsumed = true; + break; + } + } + + if (tailConsumed) { + if (killIndex != activeNow) + MoveParticle(activeNow, killIndex); + break; + } + + if (activeNow == killIndex) + break; + + MoveParticle(activeNow, killIndex); + leftInKillList = last; + killIndex = killList[++slot]; + } + } + + ActiveParticles = activeNow; + NumParticlesToKill = 0; + PaddedActiveParticles = (activeNow + 3) / 4; + } + + public void StopEmission(bool infiniteOnly = false, bool removeAllParticles = false, bool wakeOnStop = false) { + if (Def == null) + return; + + Dormant = false; + if (wakeOnStop) + NextSleepTime = Math.Max(Mgr!.GetLastSimulationTime() + 10.0f, NextSleepTime); + + EmissionStopped = true; + for (int i = 0; i < Def.Emitters.Count; i++) + Def.Emitters[i].StopEmission(this, ContextSpan(Def.EmittersCtxOffsets[i]), infiniteOnly); + + if (removeAllParticles) { + ActiveParticles = 0; + PaddedActiveParticles = 0; + } + + for (ParticleCollection? child = Children; child != null; child = child.Next) + child.StopEmission(infiniteOnly, removeAllParticles, false); + } + + public void StartEmission(bool infiniteOnly = false) { + if (Def == null) + return; + + EmissionStopped = false; + StartEmissionInternal(infiniteOnly); + } + + void StartEmissionInternal(bool infiniteOnly) { + ParticleSystemDefinition def = Def!; + for (int i = 0; i < def.Emitters.Count; i++) + def.Emitters[i].StartEmission(this, ContextSpan(def.EmittersCtxOffsets[i]), infiniteOnly); + + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.Def != null) { + child.EmissionStopped = false; + child.StartEmissionInternal(infiniteOnly); + } + } + + NextSleepTime = Mgr!.GetLastSimulationTime() + def.NoDrawTimeToGoToSleep; + } + + public void SetDormant(bool dormant) { + if (Dormant == dormant) + return; + + if (!EmissionStopped) { + if (dormant) { + StopEmission(); + Dormant = dormant; + return; + } + } + else if (dormant) + return; + + StartEmission(); + Dormant = dormant; + } + + public bool IsFinished() { + if (Def == null) + return true; + + if ((ParticleFlags & PCFLAGS_FIRST_FRAME) != 0 || ActiveParticles != 0 || Dormant) + return false; + + for (int i = 0; i < Def.Emitters.Count; i++) { + if (Def.Emitters[i].MayCreateMoreParticles(this, ContextSpan(Def.EmittersCtxOffsets[i]))) + return false; + } + + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (!child.IsFinished()) + return false; + } + return true; + } + + public void RecomputeBounds() { + int count = ActiveParticles; + if (count == 0 || Def!.ScreenSpaceEffect) { + BoundsValid = false; + MinBounds = new(float.MaxValue); + MaxBounds = new(-float.MaxValue); + Center = Vector3.Zero; + return; + } + + const float BIG = 1e23f; + int offset = GetAttributeOffset(PARTICLE_ATTRIBUTE_XYZ, out int stride); + + Span minX = stackalloc float[4], minY = stackalloc float[4], minZ = stackalloc float[4]; + Span maxX = stackalloc float[4], maxY = stackalloc float[4], maxZ = stackalloc float[4]; + Span sumX = stackalloc float[4], sumY = stackalloc float[4], sumZ = stackalloc float[4]; + minX.Fill(BIG); minY.Fill(BIG); minZ.Fill(BIG); + maxX.Fill(-BIG); maxY.Fill(-BIG); maxZ.Fill(-BIG); + + int blocks = count / 4; + for (int b = 0; b < blocks; b++) { + for (int lane = 0; lane < 4; lane++) { + float x = Memory[offset + lane], y = Memory[offset + 4 + lane], z = Memory[offset + 8 + lane]; + minX[lane] = MinSS(minX[lane], x); maxX[lane] = MaxSS(maxX[lane], x); sumX[lane] += x; + minY[lane] = MinSS(minY[lane], y); maxY[lane] = MaxSS(maxY[lane], y); sumY[lane] += y; + minZ[lane] = MinSS(minZ[lane], z); maxZ[lane] = MaxSS(maxZ[lane], z); sumZ[lane] += z; + } + offset += stride; + } + + BoundsValid = true; + Vector3 min = new(HorizontalMin(minX), HorizontalMin(minY), HorizontalMin(minZ)); + Vector3 max = new(HorizontalMax(maxX), HorizontalMax(maxY), HorizontalMax(maxZ)); + float totalX = sumX[0] + sumX[1] + sumX[2] + sumX[3]; + float totalY = sumY[0] + sumY[1] + sumY[2] + sumY[3]; + float totalZ = sumZ[0] + sumZ[1] + sumZ[2] + sumZ[3]; + + for (int lane = 0; lane < (count & 3); lane++) { + float x = Memory[offset + lane], y = Memory[offset + 4 + lane], z = Memory[offset + 8 + lane]; + min.X = MinSS(x, min.X); + max.X = MaxSS(x, max.X); + min.Y = MinSS(y, min.Y); + max.Y = MaxSS(max.Y, y); + min.Z = MinSS(z, min.Z); + max.Z = MaxSS(z, max.Z); + totalX += x; + totalY += y; + totalZ += z; + } + + MinBounds = min + Def.BoundingBoxMin; + MaxBounds = max + Def.BoundingBoxMax; + float oneOverCount = (float)(1.0 / count); + Center = new(totalX * oneOverCount, totalY * oneOverCount, totalZ * oneOverCount); + } + + static float MinSS(float a, float b) => a < b ? a : b; + static float MaxSS(float a, float b) => a > b ? a : b; + + static float HorizontalMin(ReadOnlySpan v) => MinSS(MinSS(v[3], v[2]), MinSS(v[1], v[0])); + static float HorizontalMax(ReadOnlySpan v) => MaxSS(MaxSS(v[3], v[2]), MaxSS(v[1], v[0])); + + protected void BloatBoundsUsingControlPoint() { + RecomputeBounds(); + + if (SimulatedFrames > 2) { + for (int i = 0; i <= HighestCP; i++) { + if ((Def!.ControlPointReadMask & (1UL << i)) == 0) + continue; + + Vector3 position = ControlPoints[i].Position; + MinBounds = Vector3.Min(MinBounds, position); + MaxBounds = Vector3.Max(MaxBounds, position); + } + } + + for (ParticleCollection? child = Children; child != null; child = child.Next) { + MinBounds = Vector3.Min(MinBounds, child.MinBounds); + MaxBounds = Vector3.Max(MaxBounds, child.MaxBounds); + } + } + + public void CalculatePathValues(in PathParameters pathIn, float timeStamp, out Vector3 startPnt, out Vector3 midPnt, out Vector3 endPnt) { + GetControlPointAtTime(pathIn.StartControlPointNumber, timeStamp, out startPnt); + GetControlPointAtTime(pathIn.EndControlPointNumber, timeStamp, out endPnt); + + Vector3 delta = endPnt - startPnt; + midPnt = new(pathIn.MidPoint * delta.X + startPnt.X, pathIn.MidPoint * delta.Y + startPnt.Y, pathIn.MidPoint * delta.Z + startPnt.Z); + + if (pathIn.BulgeControl == 0) { + float bulge = pathIn.Bulge; + float bulge2 = bulge + bulge; + midPnt.X = midPnt.X + RandomFloats[RandomSeed & RANDOM_FLOAT_MASK] * bulge2 - bulge; + midPnt.Y = midPnt.Y - bulge + RandomFloats[(RandomSeed + 1) & RANDOM_FLOAT_MASK] * bulge2; + midPnt.Z = RandomFloats[(RandomSeed + 2) & RANDOM_FLOAT_MASK] * bulge2 + (midPnt.Z - bulge); + return; + } + + int controlPoint = pathIn.BulgeControl == 2 ? pathIn.EndControlPointNumber : pathIn.StartControlPointNumber; + Vector3 forward = ControlPoints[controlPoint].ForwardVector; + float deltaLength = delta.Length(); + float offset = deltaLength > 1e-6f ? 1.0f - MathF.Abs(Vector3.Dot(delta, forward) / deltaLength) : 0.0f; + + float forwardLength = forward.Length(); + if (forwardLength > 1e-6f) { + float scale = offset * pathIn.Bulge * deltaLength / forwardLength; + midPnt += forward * scale; + } + } + + public void UpdateHitBoxInfo(int controlPointNumber, string? hitboxSetName = null) { + ModelHitBoxesInfo info = ControlPointHitBoxes[controlPointNumber]; + if (CurTime == info.LastUpdateTime) + return; + + info.LastUpdateTime = CurTime; + info.HitBoxes ??= new ModelHitBoxInfo[ModelHitBoxesInfo.MAX_HITBOXES]; + info.PrevBoxes ??= new ModelHitBoxInfo[ModelHitBoxesInfo.MAX_HITBOXES]; + + info.PrevLastUpdateTime = info.LastUpdateTime; + info.NumPrevHitBoxes = info.NumHitBoxes; + (info.HitBoxes, info.PrevBoxes) = (info.PrevBoxes, info.HitBoxes); + info.NumHitBoxes = Mgr!.Query().GetControllingObjectHitBoxInfo(this, controlPointNumber, info.HitBoxes, hitboxSetName); + } + + IMaterial? PrecachedMaterial() => Def != null && Def.IsPrecached ? Def.Material.Get() : null; + + public bool IsTranslucent() => IsTranslucent_; + public bool IsTwoPass() => IsTwoPass_; + public bool IsBatchable() => IsBatchable_; + + public bool UsesPowerOfTwoFrameBufferTexture(bool thisFrame) { + if (!AnyUsesPowerOfTwoFrameBufferTexture || !thisFrame) + return AnyUsesPowerOfTwoFrameBufferTexture; + if (ActiveParticles != 0 && UsesPowerOfTwoFrameBufferTexture_) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.SystemContainsParticlesWithBoolSet(c => c.UsesPowerOfTwoFrameBufferTexture_)) + return true; + } + return false; + } + + public bool UsesFullFrameBufferTexture(bool thisFrame) { + if (!AnyUsesFullFrameBufferTexture || !thisFrame) + return AnyUsesFullFrameBufferTexture; + if (ActiveParticles != 0 && UsesFullFrameBufferTexture_) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.SystemContainsParticlesWithBoolSet(c => c.UsesFullFrameBufferTexture_)) + return true; + } + return false; + } + + bool SystemContainsParticlesWithBoolSet(Func field) { + if (ActiveParticles != 0 && field(this)) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.SystemContainsParticlesWithBoolSet(field)) + return true; + } + return false; + } + + void LabelTextureUsage() { + if (Def != null) { + IMaterial material = Def.Material.Get()!; + UsesPowerOfTwoFrameBufferTexture_ = material.NeedsPowerOfTwoFrameBufferTexture(false); + UsesFullFrameBufferTexture_ = material.NeedsFullFrameBufferTexture(false); + } + for (ParticleCollection? child = Children; child != null; child = child.Next) + child.LabelTextureUsage(); + } + + bool ComputeUsesPowerOfTwoFrameBufferTexture() { + if (Def == null) + return false; + if (Def.Material.Get()!.NeedsPowerOfTwoFrameBufferTexture(false)) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.AnyUsesPowerOfTwoFrameBufferTexture) + return true; + } + return false; + } + + bool ComputeUsesFullFrameBufferTexture() { + if (Def == null) + return false; + if (Def.Material.Get()!.NeedsFullFrameBufferTexture(false)) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.AnyUsesFullFrameBufferTexture) + return true; + } + return false; + } + + bool ContainsOpaqueCollections() { + if (Def == null) + return false; + if (PrecachedMaterial()?.IsTranslucent() != true) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.ContainsOpaqueCollections()) + return true; + } + return false; + } + + bool ComputeIsTranslucent() { + if (Def == null) + return false; + if (PrecachedMaterial()?.IsTranslucent() == true) + return true; + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.IsTranslucent_) + return true; + } + return false; + } + + bool ComputeIsBatchable() { + if (PrecachedMaterial() != null) { + foreach (ParticleOperatorInstance renderer in Def!.Renderers) { + if (!renderer.IsBatchable()) + return false; + } + } + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (!child.IsBatchable_) + return false; + } + return true; + } + + bool ComputeRequiresOrderInvariance() { + if (PrecachedMaterial() != null) { + foreach (ParticleOperatorInstance renderer in Def!.Renderers) { + if (renderer.RequiresOrderInvariance()) + return true; + } + } + for (ParticleCollection? child = Children; child != null; child = child.Next) { + if (child.RequiresOrderInvariance) + return true; + } + return false; + } + + public int GetRendererCount() => PrecachedMaterial() != null ? Def!.Renderers.Count : 0; + public ParticleOperatorInstance? GetRenderer(int i) => PrecachedMaterial() != null ? Def!.Renderers[i] : null; + public Span GetRendererContext(int i) => PrecachedMaterial() != null ? ContextSpan(Def!.RenderersCtxOffsets[i]) : default; + + public void Render(IMatRenderContext renderContext, bool translucentOnly = false, object? cameraObject = null) { + IMaterial? material = PrecachedMaterial(); + if (material == null) + return; + + NextSleepTime = Math.Max(NextSleepTime, Mgr!.GetLastSimulationTime() + Def!.NoDrawTimeToGoToSleep); + + if (ActiveParticles != 0 && (!translucentOnly || material.IsTranslucent())) { + for (int i = 0; i < Def.Renderers.Count; i++) { + ParticleOperatorInstance op = Def.Renderers[i]; + if (!CheckIfOperatorShouldRun(op, out _)) + continue; + + Span context = ContextSpan(Def.RenderersCtxOffsets[i]); + if (!Def.ScreenSpaceEffect) { + op.Render(renderContext, this, context); + continue; + } + + renderContext.MatrixMode(MaterialMatrixMode.View); + renderContext.PushMatrix(); + renderContext.LoadIdentity(); + renderContext.MatrixMode(MaterialMatrixMode.Projection); + renderContext.PushMatrix(); + renderContext.LoadIdentity(); + renderContext.Ortho(-100.0, -100.0, 100.0, 100.0, -100.0, 100.0); + op.Render(renderContext, this, context); + renderContext.MatrixMode(MaterialMatrixMode.View); + renderContext.PopMatrix(); + renderContext.MatrixMode(MaterialMatrixMode.Projection); + renderContext.PopMatrix(); + } + } + + for (ParticleCollection? child = Children; child != null; child = child.Next) + child.Render(renderContext, translucentOnly, cameraObject); + } + + static readonly ParticleRenderData[] SortBuffer = new ParticleRenderData[MAX_PARTICLES_IN_A_SYSTEM + 4]; + + public ParticleRenderData[] GetRenderList(IMatRenderContext renderContext, bool sorted, out int particleCount, in ParticleVisibilityData visibilityData) { + bool sort = sorted && Def!.ShouldSort; + renderContext.GetWorldSpaceCameraPosition(out Vector3 camera); + if (camera.X < MinBounds.X || camera.X > MaxBounds.X || camera.Y < MinBounds.Y || camera.Y > MaxBounds.Y || camera.Z < MinBounds.Z || camera.Z > MaxBounds.Z) + particleCount = GenerateSortedIndexList(camera, default, false, visibilityData, sort); + else { + renderContext.GetWorldSpaceCameraVectors(out Vector3 forward, out _, out _); + particleCount = GenerateSortedIndexList(camera, forward, true, visibilityData, sort); + } + return SortBuffer; + } + + int GenerateSortedIndexList(Vector3 camera, Vector3 forward, bool cull, in ParticleVisibilityData visibilityData, bool sorted) { + int particleCount = ActiveParticles; + int blockCount = Math.Max(1, (particleCount + 3) / 4); + ParticleRenderData[] output = SortBuffer; + + for (int i = 0; i < blockCount * 4; i++) { + Vector3 position = GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, i); + float alpha = GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA, i) * GetFloatAttributeValue(PARTICLE_ATTRIBUTE_ALPHA2, i); + float radius = GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, i); + if (visibilityData.UseVisibility) { + alpha = Math.Clamp(alpha * visibilityData.AlphaVisibility, 0.0f, 1.0f); + radius *= visibilityData.RadiusVisibility; + } + + Vector3 delta = position - camera; + byte alphaByte = (byte)((int)MathF.Round(alpha * 255.0f) & 0xFF); + if (cull && !(0.0f <= Vector3.Dot(forward, delta))) + alphaByte = 0; + + ref ParticleRenderData entry = ref output[i]; + entry.SortKey = sorted ? delta.LengthSquared() : 0.0f; + entry.Index = i; + entry.Radius = radius; + entry.Alpha = alphaByte; + } + + if (sorted) + HeapSortByKey(output, particleCount); + + return particleCount; + } + + static int SortKeyBits(in ParticleRenderData data) => BitConverter.SingleToInt32Bits(data.SortKey); + + static void HeapSortByKey(ParticleRenderData[] data, int count) { + if (count < 2) + return; + + for (int i = 1; i < count; i++) { + int node = i; + while (node != 0) { + int parent = ((node + 1) >> 1) - 1; + if (SortKeyBits(data[parent]) >= SortKeyBits(data[node])) + break; + (data[parent], data[node]) = (data[node], data[parent]); + node = parent; + } + } + + int end = count - 1; + (data[0], data[end]) = (data[end], data[0]); + while (end != 1) { + int parent = 0; + int child = 1; + while (true) { + int pick = child; + if (child + 1 < end && SortKeyBits(data[child]) < SortKeyBits(data[child + 1])) + pick = child + 1; + if (SortKeyBits(data[pick]) <= SortKeyBits(data[parent])) + break; + (data[parent], data[pick]) = (data[pick], data[parent]); + child = pick * 2 + 1; + if (child >= end) + break; + parent = pick; + } + end--; + (data[0], data[end]) = (data[end], data[0]); + } + } +} + +public struct ParticleRenderData +{ + public float SortKey; + public int Index; + public float Radius; + public byte Alpha; +} + +public struct ParticleVisibilityData +{ + public float AlphaVisibility; + public float RadiusVisibility; + public float CameraBias; + public bool UseVisibility; +} diff --git a/Source.Particles/ParticleConstants.cs b/Source.Particles/ParticleConstants.cs new file mode 100644 index 00000000..b4619f74 --- /dev/null +++ b/Source.Particles/ParticleConstants.cs @@ -0,0 +1,96 @@ +namespace Source.Particles; + +public enum ParticleFunctionType +{ + Renderer = 0, + Operator, + Initializer, + Emitter, + Children, + ForceGenerator, + Constraint, + Count +} + +public enum ParticleOperatorId +{ + Generic = -2, + Singleton = -1, + PiPosition, + PiRadius, + PiAlpha, + PiTintRGB, + PiRotation, + PiYaw, + Count +} + +public static class ParticleConstants +{ + public const int MAX_RANDOM_FLOATS = 4096; + public const int RANDOM_FLOAT_MASK = MAX_RANDOM_FLOATS - 1; + + public const int MAX_PARTICLE_ATTRIBUTES = 32; + + public const int PARTICLE_ATTRIBUTE_XYZ = 0; + public const int PARTICLE_ATTRIBUTE_LIFE_DURATION = 1; + public const int PARTICLE_ATTRIBUTE_PREV_XYZ = 2; + public const int PARTICLE_ATTRIBUTE_RADIUS = 3; + public const int PARTICLE_ATTRIBUTE_ROTATION = 4; + public const int PARTICLE_ATTRIBUTE_ROTATION_SPEED = 5; + public const int PARTICLE_ATTRIBUTE_TINT_RGB = 6; + public const int PARTICLE_ATTRIBUTE_ALPHA = 7; + public const int PARTICLE_ATTRIBUTE_CREATION_TIME = 8; + public const int PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER = 9; + public const int PARTICLE_ATTRIBUTE_TRAIL_LENGTH = 10; + public const int PARTICLE_ATTRIBUTE_PARTICLE_ID = 11; + public const int PARTICLE_ATTRIBUTE_YAW = 12; + public const int PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1 = 13; + public const int PARTICLE_ATTRIBUTE_HITBOX_INDEX = 14; + public const int PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ = 15; + public const int PARTICLE_ATTRIBUTE_ALPHA2 = 16; + public const int PARTICLE_ATTRIBUTE_SCRATCH_VEC = 17; + public const int PARTICLE_ATTRIBUTE_SCRATCH_FLOAT = 18; + public const int PARTICLE_ATTRIBUTE_UNUSED = 19; + public const int PARTICLE_ATTRIBUTE_PITCH = 20; + public const int PARTICLE_ATTRIBUTE_NORMAL = 21; + + public const int PARTICLE_ATTRIBUTE_XYZ_MASK = 1 << PARTICLE_ATTRIBUTE_XYZ; + public const int PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK = 1 << PARTICLE_ATTRIBUTE_LIFE_DURATION; + public const int PARTICLE_ATTRIBUTE_PREV_XYZ_MASK = 1 << PARTICLE_ATTRIBUTE_PREV_XYZ; + public const int PARTICLE_ATTRIBUTE_RADIUS_MASK = 1 << PARTICLE_ATTRIBUTE_RADIUS; + public const int PARTICLE_ATTRIBUTE_ROTATION_MASK = 1 << PARTICLE_ATTRIBUTE_ROTATION; + public const int PARTICLE_ATTRIBUTE_ROTATION_SPEED_MASK = 1 << PARTICLE_ATTRIBUTE_ROTATION_SPEED; + public const int PARTICLE_ATTRIBUTE_TINT_RGB_MASK = 1 << PARTICLE_ATTRIBUTE_TINT_RGB; + public const int PARTICLE_ATTRIBUTE_ALPHA_MASK = 1 << PARTICLE_ATTRIBUTE_ALPHA; + public const int PARTICLE_ATTRIBUTE_CREATION_TIME_MASK = 1 << PARTICLE_ATTRIBUTE_CREATION_TIME; + public const int PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK = 1 << PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER; + public const int PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK = 1 << PARTICLE_ATTRIBUTE_TRAIL_LENGTH; + public const int PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK = 1 << PARTICLE_ATTRIBUTE_PARTICLE_ID; + public const int PARTICLE_ATTRIBUTE_YAW_MASK = 1 << PARTICLE_ATTRIBUTE_YAW; + public const int PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1_MASK = 1 << PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1; + public const int PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK = 1 << PARTICLE_ATTRIBUTE_HITBOX_INDEX; + public const int PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK = 1 << PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ; + public const int PARTICLE_ATTRIBUTE_ALPHA2_MASK = 1 << PARTICLE_ATTRIBUTE_ALPHA2; + public const int PARTICLE_ATTRIBUTE_SCRATCH_VEC_MASK = 1 << PARTICLE_ATTRIBUTE_SCRATCH_VEC; + public const int PARTICLE_ATTRIBUTE_SCRATCH_FLOAT_MASK = 1 << PARTICLE_ATTRIBUTE_SCRATCH_FLOAT; + public const int PARTICLE_ATTRIBUTE_UNUSED_MASK = 1 << PARTICLE_ATTRIBUTE_UNUSED; + public const int PARTICLE_ATTRIBUTE_PITCH_MASK = 1 << PARTICLE_ATTRIBUTE_PITCH; + public const int PARTICLE_ATTRIBUTE_NORMAL_MASK = 1 << PARTICLE_ATTRIBUTE_NORMAL; + + public const int MAX_PARTICLE_CONTROL_POINTS = 64; + + public const int ATTRIBUTES_WHICH_ARE_VEC3S_MASK = PARTICLE_ATTRIBUTE_SCRATCH_VEC_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK | + PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_TINT_RGB_MASK | + PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK | PARTICLE_ATTRIBUTE_NORMAL_MASK; + public const int ATTRIBUTES_WHICH_ARE_0_TO_1 = PARTICLE_ATTRIBUTE_ALPHA_MASK | PARTICLE_ATTRIBUTE_ALPHA2_MASK; + public const int ATTRIBUTES_WHICH_ARE_ANGLES = PARTICLE_ATTRIBUTE_ROTATION_MASK | PARTICLE_ATTRIBUTE_YAW_MASK | PARTICLE_ATTRIBUTE_PITCH_MASK; + public const int ATTRIBUTES_WHICH_ARE_INTS = PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK | PARTICLE_ATTRIBUTE_HITBOX_INDEX_MASK; + + public const int MAX_PARTICLES_IN_A_SYSTEM = 5000; + + public const int PCFLAGS_FIRST_FRAME = 0x1; + public const int PCFLAGS_PREV_CONTROL_POINTS_INITIALIZED = 0x2; + + public const int INVALID_PARTICLE_SYSTEM_HANDLE = 0xFFFF; +} diff --git a/Source.Particles/ParticleOperator.cs b/Source.Particles/ParticleOperator.cs new file mode 100644 index 00000000..23907383 --- /dev/null +++ b/Source.Particles/ParticleOperator.cs @@ -0,0 +1,241 @@ +using Datamodel; + +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using System.Runtime.Intrinsics; + +namespace Source.Particles; + +public interface IParticleOperatorDefinition +{ + string? GetName(); + ParticleOperatorInstance? CreateInstance(Guid id); + IDmxElementUnpackStructure? GetUnpackStructure(); + ParticleOperatorId GetId(); + bool IsObsolete(); +} + +public sealed class ParticleOperatorDefinition(string factoryName, ParticleOperatorId id, bool isObsolete, IDmxElementUnpackStructure? unpackParams) : IParticleOperatorDefinition + where T : ParticleOperatorInstance, new() +{ + public string GetName() => factoryName; + public ParticleOperatorId GetId() => id; + public IDmxElementUnpackStructure? GetUnpackStructure() => unpackParams; + public bool IsObsolete() => isObsolete; + + public ParticleOperatorInstance? CreateInstance(Guid instanceId) { + T op = new(); + op.SetDefinition(this, instanceId); + return op; + } +} + +public struct ParticleVisibilityInputs +{ + public float CameraBias; + public float InputMin; + public float InputMax; + public float AlphaScaleMin; + public float AlphaScaleMax; + public float RadiusScaleMin; + public float RadiusScaleMax; + public float ProxyRadius; + public float BBoxScale; + public bool UseBBox; + public int CPin; +} + +public abstract class ParticleOperatorInstance +{ + public float OpStartFadeInTime; + public float OpEndFadeInTime; + public float OpStartFadeOutTime; + public float OpEndFadeOutTime; + public float OpFadeOscillatePeriod; + public float OpTimeOffsetMin; + public float OpTimeOffsetMax; + public int OpTimeOffsetSeed; + public int OpStrengthScaleSeed; + public float OpStrengthMinScale; + public float OpStrengthMaxScale; + public int OpTimeScaleSeed; + public float OpTimeScaleMin; + public float OpTimeScaleMax; + public int OpEndCapState; + public bool StrengthFastPath; + + IParticleOperatorDefinition? Def; + Guid Id; + + internal void SetDefinition(IParticleOperatorDefinition def, Guid id) { + Def = def; + Id = id; + } + + public IParticleOperatorDefinition? GetDefinition() => Def; + public Guid GetId() => Id; + + public virtual void InitParams(ParticleSystemDefinition def, Element element) { } + public virtual int GetRequiredContextBytes() => 0; + public virtual void InitializeContextData(ParticleCollection particles, Span context) { } + public virtual void Precache(ParticleSystemDefinition def) { } + + public abstract uint GetWrittenAttributes(); + public abstract uint GetReadAttributes(); + public virtual ulong GetReadControlPointMask() => 0; + public virtual uint GetReadInitialAttributes() => 0; + + public virtual void Operate(ParticleCollection particles, float opStrength, Span context) { } + + public virtual uint Emit(ParticleCollection particles, float opCurStrength, Span context) => 0; + public virtual void StopEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { } + public virtual void StartEmission(ParticleCollection particles, Span context, bool infiniteOnly = false) { } + public virtual void Restart(ParticleCollection particles, Span context) { } + public virtual bool MayCreateMoreParticles(ParticleCollection particles, Span context) => false; + public virtual void SkipToTime(float time, ParticleCollection particles, Span context) { } + + public virtual void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) { } + public virtual void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) + => InitNewParticlesScalar(particles, 4 * startBlock, 4 * numBlocks, attributeWriteMask, context); + + public void InitNewParticles(ParticleCollection particles, int firstParticle, int particleCount, int attributeWriteMask, Span context) { + if (particleCount == 0) + return; + + if (particleCount < 16) { + InitNewParticlesScalar(particles, firstParticle, particleCount, attributeWriteMask, context); + return; + } + + if ((firstParticle & 3) != 0) { + int head = 4 - (firstParticle & 3); + InitNewParticlesScalar(particles, firstParticle, head, attributeWriteMask, context); + particleCount -= head; + firstParticle += head; + } + + InitNewParticlesBlock(particles, firstParticle / 4, particleCount / 4, attributeWriteMask, context); + + if ((particleCount & 3) != 0) + InitNewParticlesScalar(particles, firstParticle + (particleCount & ~3), particleCount & 3, attributeWriteMask, context); + } + + public virtual void AddForces(Span accumulatedForces, ParticleCollection particles, int blocks, float strength, Span context) { } + + public virtual void SetupConstraintPerFrameData(ParticleCollection particles, Span context) { } + public virtual bool EnforceConstraint(int startBlock, int endBlock, ParticleCollection particles, Span context, int activeParticles) => false; + + public virtual void Render(IMatRenderContext renderContext, ParticleCollection particles, Span context) { } + public virtual int GetParticlesToRender(ParticleCollection particles, Span context, int firstParticle, int remainingVertices, int remainingIndices, out int vertsUsed, out int indicesUsed) { + vertsUsed = 0; + indicesUsed = 0; + return 0; + } + public virtual void RenderUnsorted(ParticleCollection particles, Span context, IMatRenderContext renderContext, ref MeshBuilder meshBuilder, int vertexOffset, int firstParticle, int particleCount) { } + + internal void ComputeStrengthFastPath() + => StrengthFastPath = OpStartFadeInTime == 0.0f && OpEndFadeOutTime == 0.0f && OpStartFadeOutTime == 0.0f + && OpTimeOffsetMin == 0.0f && OpTimeOffsetMax == 0.0f && OpTimeScaleMin == 1.0f && OpTimeScaleMax == 1.0f + && OpStrengthMaxScale == 1.0f && OpStrengthMinScale == 1.0f && OpEndCapState == -1; + + public virtual bool ShouldRun(bool applyingParentKillList) => !applyingParentKillList; + + protected void InitScalarAttributeRandomRangeScalar(int attribute, float min, float max, float exponent, ParticleCollection particles, int startParticle, int particleCount) { + if (!StrengthFastPath) { + particles.CheckIfOperatorShouldRun(this, out float strength); + min *= strength; + max *= strength; + } + + for (int i = 0; i < particleCount; i++) + particles.GetFloatAttributeRefForWrite(attribute, startParticle + i) = exponent == 1.0f ? particles.RandomFloat(min, max) : particles.RandomFloatExp(min, max, exponent); + } + + protected void InitScalarAttributeRandomRangeBlock(int attribute, float min, float max, float exponent, ParticleCollection particles, int startBlock, int blockCount, bool randomlyInvert) { + if (!StrengthFastPath) { + particles.CheckIfOperatorShouldRun(this, out float strength); + min *= strength; + max *= strength; + } + + Vector128 vMin = Vector128.Create(min); + Vector128 vRange = Vector128.Create(max - min); + Vector128 half = Vector128.Create(0.5f); + int intExponent = (int)exponent; + int context = RandSIMD.GetContext(); + for (int b = 0; b < blockCount; b++) { + ref Vector128 attr = ref particles.GetM128AttributeRefForWrite(attribute, startBlock + b); + Vector128 rand = RandSIMD.Next(context); + if (exponent != 1.0f) + rand = RandSIMD.PowFixedPointExponent(rand, intExponent); + Vector128 value = rand * vRange + vMin; + if (randomlyInvert) { + Vector128 mask = Vector128.GreaterThanOrEqual(RandSIMD.Next(context), half); + value *= Vector128.ConditionalSelect(mask, MathLib.Four_Ones, -MathLib.Four_Ones); + } + attr = value; + } + RandSIMD.ReleaseContext(context); + } + + public virtual bool IsBatchable() => true; + public virtual bool IsFinalConstraint() => false; + public virtual bool InitMultipleOverride() => false; + public virtual bool IsScrubSafe() => false; + public virtual bool ShouldRunBeforeEmitters() => false; + public virtual bool RequiresOrderInvariance() => false; +} + +public abstract class ParticleRenderOperatorInstance : ParticleOperatorInstance +{ + public ParticleVisibilityInputs VisibilityInputs; +} + +public static class ParticleOperatorUnpack +{ + public static DmxElementUnpackStructure Begin() where T : ParticleOperatorInstance + => new DmxElementUnpackStructure() + .Float("operator start fadein", "0", (o, v) => o.OpStartFadeInTime = v) + .Float("operator end fadein", "0", (o, v) => o.OpEndFadeInTime = v) + .Float("operator start fadeout", "0", (o, v) => o.OpStartFadeOutTime = v) + .Float("operator end fadeout", "0", (o, v) => o.OpEndFadeOutTime = v) + .Float("operator fade oscillate", "0", (o, v) => o.OpFadeOscillatePeriod = v) + .Int("operator time offset seed", "0", (o, v) => o.OpTimeOffsetSeed = v) + .Float("operator time offset min", "0", (o, v) => o.OpTimeOffsetMin = v) + .Float("operator time offset max", "0", (o, v) => o.OpTimeOffsetMax = v) + .Int("operator time scale seed", "0", (o, v) => o.OpTimeScaleSeed = v) + .Float("operator time scale min", "1", (o, v) => o.OpTimeScaleMin = v) + .Float("operator time scale max", "1", (o, v) => o.OpTimeScaleMax = v) + .Float("operator time strength random scale max", "1", (o, v) => o.OpStrengthMaxScale = v) + .Int("operator strength scale seed", "0", (o, v) => o.OpStrengthScaleSeed = v) + .Float("operator strength random scale min", "1", (o, v) => o.OpStrengthMinScale = v) + .Float("operator strength random scale max", "1", (o, v) => o.OpStrengthMaxScale = v) + .Int("operator end cap state", "-1", (o, v) => o.OpEndCapState = v); + + public static DmxElementUnpackStructure BeginRender() where T : ParticleRenderOperatorInstance + => Begin() + .Int("Visibility Proxy Input Control Point Number", "-1", (o, v) => o.VisibilityInputs.CPin = v) + .Float("Visibility Proxy Radius", "1.0", (o, v) => o.VisibilityInputs.ProxyRadius = v) + .Float("Visibility input minimum", "0", (o, v) => o.VisibilityInputs.InputMin = v) + .Float("Visibility input maximum", "1", (o, v) => o.VisibilityInputs.InputMax = v) + .Float("Visibility Alpha Scale minimum", "0", (o, v) => o.VisibilityInputs.AlphaScaleMin = v) + .Float("Visibility Alpha Scale maximum", "1", (o, v) => o.VisibilityInputs.AlphaScaleMax = v) + .Float("Visibility Radius Scale minimum", "1", (o, v) => o.VisibilityInputs.RadiusScaleMin = v) + .Float("Visibility Radius Scale maximum", "1", (o, v) => o.VisibilityInputs.RadiusScaleMax = v) + .Float("Visibility Camera Depth Bias", "0", (o, v) => o.VisibilityInputs.CameraBias = v); +} + +public sealed class ChildOperatorDefinition : IParticleOperatorDefinition +{ + public static readonly ChildOperatorDefinition Instance = new(); + + public static readonly DmxElementUnpackStructure ChildrenInfoUnpack = new DmxElementUnpackStructure() + .Float("delay", "0.0", (c, v) => c.Delay = v); + + public string? GetName() => null; + public ParticleOperatorInstance? CreateInstance(Guid id) => null; + public IDmxElementUnpackStructure? GetUnpackStructure() => ChildrenInfoUnpack; + public ParticleOperatorId GetId() => ParticleOperatorId.Generic; + public bool IsObsolete() => false; +} diff --git a/Source.Particles/ParticleSystemDefinition.cs b/Source.Particles/ParticleSystemDefinition.cs new file mode 100644 index 00000000..e4bc1dc5 --- /dev/null +++ b/Source.Particles/ParticleSystemDefinition.cs @@ -0,0 +1,353 @@ +using Datamodel; + +using Source.Common.MaterialSystem; + +using System.Numerics; + +using static Source.MaterialDefines; +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public class ParticleChildrenInfo +{ + public Guid Id; + public string? Name; + public bool UseNameBasedLookup; + public float Delay; +} + +public sealed class ParticleSystemDefinition(ParticleSystemMgr mgr) +{ + public const string DmeParticleSystemDefinition = "DmeParticleSystemDefinition"; + + static readonly string[] RemapOperatorNameTable = [ + "alpha_fade", "Alpha Fade and Decay", + "alpha_fade_in_random", "Alpha Fade In Random", + "alpha_fade_out_random", "Alpha Fade Out Random", + "basic_movement", "Movement Basic", + "color_fade", "Color Fade", + "controlpoint_light", "Color Light From Control Point", + "Dampen Movement Relative to Control Point", "Movement Dampen Relative to Control Point", + "Distance Between Control Points Scale", "Remap Distance Between Two Control Points to Scalar", + "Distance to Control Points Scale", "Remap Distance to Control Point to Scalar", + "lifespan_decay", "Lifespan Decay", + "lock to bone", "Movement Lock to Bone", + "postion_lock_to_controlpoint", "Movement Lock to Control Point", + "maintain position along path", "Movement Maintain Position Along Path", + "lock to saved position along path", "Movement Lock to Saved Position Along Path", + "Match Particle Velocities", "Movement Match Particle Velocities", + "Max Velocity", "Movement Max Velocity", + "noise", "Noise Scalar", + "vector noise", "Noise Vector", + "oscillate_scalar", "Oscillate Scalar", + "oscillate_vector", "Oscillate Vector", + "Orient Rotation to 2D Direction", "Rotation Orient to 2D Direction", + "radius_scale", "Radius Scale", + "Random Cull", "Cull Random", + "remap_scalar", "Remap Scalar", + "rotation_movement", "Rotation Basic", + "rotation_spin", "Rotation Spin Roll", + "rotation_spin yaw", "Rotation Spin Yaw", + "alpha_random", "Alpha Random", + "color_random", "Color Random", + "create from parent particles", "Position From Parent Particles", + "Create In Hierarchy", "Position In CP Hierarchy", + "random position along path", "Position Along Path Random", + "random position on model", "Position on Model Random", + "sequential position along path", "Position Along Path Sequential", + "position_offset_random", "Position Modify Offset Random", + "position_warp_random", "Position Modify Warp Random", + "position_within_box", "Position Within Box Random", + "position_within_sphere", "Position Within Sphere Random", + "Inherit Velocity", "Velocity Inherit from Control Point", + "Initial Repulsion Velocity", "Velocity Repulse from World", + "Initial Velocity Noise", "Velocity Noise", + "Initial Scalar Noise", "Remap Noise to Scalar", + "Lifespan from distance to world", "Lifetime from Time to Impact", + "Pre-Age Noise", "Lifetime Pre-Age Noise", + "lifetime_random", "Lifetime Random", + "radius_random", "Radius Random", + "random yaw", "Rotation Yaw Random", + "Randomly Flip Yaw", "Rotation Yaw Flip Random", + "rotation_random", "Rotation Random", + "rotation_speed_random", "Rotation Speed Random", + "sequence_random", "Sequence Random", + "second_sequence_random", "Sequence Two Random", + "trail_length_random", "Trail Length Random", + "velocity_random", "Velocity Random", + ]; + + static readonly DmxElementUnpackStructure UnpackStructure = new DmxElementUnpackStructure() + .Int("max_particles", "1000", (d, v) => d.MaxParticles = v) + .Int("initial_particles", "0", (d, v) => d.InitialParticles = v) + .String("material", "vgui/white", MAX_PATH, (d, v) => d.MaterialName = v) + .Vector3("bounding_box_min", "-10 -10 -10", (d, v) => d.BoundingBoxMin = v) + .Vector3("bounding_box_max", "10 10 10", (d, v) => d.BoundingBoxMax = v) + .Float("cull_radius", "0", (d, v) => d.CullRadius = v) + .Float("cull_cost", "1", (d, v) => d.CullFillCost = v) + .Int("cull_control_point", "0", (d, v) => d.CullControlPoint = v) + .String("cull_replacement_definition", "", 128, (d, v) => d.CullReplacementName = v) + .Float("radius", "5", (d, v) => d.ConstantRadius = v) + .Color("color", "255 255 255 255", (d, v) => d.ConstantColor = v) + .Float("rotation", "0", (d, v) => d.ConstantRotation = v) + .Float("rotation_speed", "0", (d, v) => d.ConstantRotationSpeed = v) + .Vector3("normal", "0 0 1", (d, v) => d.ConstantNormal = v) + .Int("sequence_number", "0", (d, v) => d.ConstantSequenceNumber = v) + .Int("sequence_number 1", "0", (d, v) => d.ConstantSequenceNumber1 = v) + .Int("group id", "0", (d, v) => d.GroupID = v) + .Float("maximum time step", "0.1", (d, v) => d.MaximumTimeStep = v) + .Float("maximum sim tick rate", "0.0", (d, v) => d.MaximumSimTime = v) + .Float("minimum sim tick rate", "0.0", (d, v) => d.MinimumSimTime = v) + .Int("minimum rendered frames", "0", (d, v) => d.MinimumFrames = v) + .Int("control point to disable rendering if it is the camera", "-1", (d, v) => d.SkipRenderControlPoint = v) + .Float("maximum draw distance", "100000.0", (d, v) => d.MaxDrawDistance = v) + .Float("time to sleep when not drawn", "8", (d, v) => d.NoDrawTimeToGoToSleep = v) + .Bool("Sort particles", "1", (d, v) => d.ShouldSort = v) + .Bool("batch particle systems", "0", (d, v) => d.ShouldBatch = v) + .Bool("view model effect", "0", (d, v) => d.ViewModelEffect = v) + .Bool("screen space effect", "0", (d, v) => d.ScreenSpaceEffect = v); + + public static IDmxElementUnpackStructure GetUnpackStructure() => UnpackStructure; + + internal readonly ParticleSystemMgr Mgr = mgr; + + public int InitialParticles; + public int PerParticleUpdatedAttributeMask; + public int PerParticleInitializedAttributeMask; + public int InitialAttributeReadMask; + public int AttributeReadMask; + public ulong ControlPointReadMask; + public Vector3 BoundingBoxMin; + public Vector3 BoundingBoxMax; + public string MaterialName = ""; + public readonly MaterialReference Material = new(); + public ParticleCollection? FirstCollection; + public string CullReplacementName = ""; + public float CullRadius; + public float CullFillCost = 1.0f; + public int CullControlPoint; + public int RetireCheckFrame; + + public Color ConstantColor = new(0, 0, 0, 0); + public float ConstantRadius; + public float ConstantRotation; + public float ConstantRotationSpeed; + public Vector3 ConstantNormal; + public int ConstantSequenceNumber; + public int ConstantSequenceNumber1; + public int GroupID; + public float MaximumTimeStep; + public float MaximumSimTime; + public float MinimumSimTime; + public int MinimumFrames; + public bool ViewModelEffect; + public bool ScreenSpaceEffect; + + public int ContextDataSize; + public Guid Id; + + public float MaxDrawDistance; + public float NoDrawTimeToGoToSleep; + public int MaxParticles; + public int SkipRenderControlPoint; + public string Name = ""; + + public readonly List Operators = []; + public readonly List Renderers = []; + public readonly List Initializers = []; + public readonly List Emitters = []; + public readonly List ForceGenerators = []; + public readonly List Constraints = []; + public readonly List Children = []; + + public readonly List OperatorsCtxOffsets = []; + public readonly List RenderersCtxOffsets = []; + public readonly List InitializersCtxOffsets = []; + public readonly List EmittersCtxOffsets = []; + public readonly List ForceGeneratorsCtxOffsets = []; + public readonly List ConstraintsCtxOffsets = []; + + public float TotalSimTime; + public float UncomittedTotalSimTime; + public float MaxMeasuredSimTime; + public int MaximumActiveParticles; + public bool ShouldSort = true; + public bool ShouldBatch; + public bool IsPrecached; + public bool AlwaysPrecache; + + public string GetName() => Name; + public Guid GetId() => Id; + public IMaterial? GetMaterial() => Material.Get(); + public bool ShouldAlwaysPrecache() => AlwaysPrecache; + public bool IsViewModelEffect() => ViewModelEffect; + public bool IsScreenSpaceEffect() => ScreenSpaceEffect; + public float GetCullRadius() => CullRadius; + public float GetCullFillCost() => CullFillCost; + public int GetCullControlPoint() => CullControlPoint; + public string GetCullReplacementDefinition() => CullReplacementName; + public bool HasRetirementBeenChecked(int frame) => RetireCheckFrame == frame; + public void MarkRetirementCheck(int frame) => RetireCheckFrame = frame; + public void MarkReadsControlPoint(int point) => ControlPointReadMask |= 1UL << point; + public bool ReadsControlPoint(int point) => (ControlPointReadMask & (1UL << point)) != 0; + + public void Read(Element element) { + Name = element.Name; + Id = element.ID; + UnpackStructure.UnpackIntoStructure(element, this); + + if (InitialParticles < 0) + InitialParticles = 0; + + MaxParticles = Math.Min(Math.Max(MaxParticles, 1) * ParticleSystemMgr.g_nParticle_Multiplier, MAX_PARTICLES_IN_A_SYSTEM); + + if (CullRadius > 0) + ControlPointReadMask |= 1UL << (CullControlPoint & 0x3F); + + ParseOperators("renderers", ParticleFunctionType.Renderer, element, Renderers); + ParseOperators("operators", ParticleFunctionType.Operator, element, Operators); + ParseOperators("initializers", ParticleFunctionType.Initializer, element, Initializers); + ParseOperators("emitters", ParticleFunctionType.Emitter, element, Emitters); + ParseChildren(element); + ParseOperators("forces", ParticleFunctionType.ForceGenerator, element, ForceGenerators); + ParseOperators("constraints", ParticleFunctionType.Constraint, element, Constraints); + SetupContextData(); + } + + static string RemapOperatorName(string name) { + for (int i = 0; i < RemapOperatorNameTable.Length; i += 2) { + if (string.Equals(name, RemapOperatorNameTable[i], StringComparison.OrdinalIgnoreCase)) + return RemapOperatorNameTable[i + 1]; + } + return name; + } + + void ParseOperators(string opKey, ParticleFunctionType functionType, Element element, List outList) { + if (!element.TryGetValue(opKey, out object? attribute) || attribute is not ElementArray ops) + return; + + List flist = Mgr.GetAvailableParticleOperatorList(functionType); + foreach (Element? op in ops) { + if (op == null) + continue; + + string functionName = op.TryGetValue("functionName", out object? fn) && fn is string s ? s : ""; + functionName = RemapOperatorName(functionName); + + IParticleOperatorDefinition? opDef = null; + foreach (IParticleOperatorDefinition candidate in flist) { + if (string.Equals(functionName, candidate.GetName(), StringComparison.OrdinalIgnoreCase)) { + opDef = candidate; + break; + } + } + + if (opDef == null) { + if (flist.Count != 0) + Warning($"Didn't find particle function {functionName}\n"); + continue; + } + + ParticleOperatorInstance op2 = opDef.CreateInstance(op.ID)!; + opDef.GetUnpackStructure()?.UnpackIntoStructure(op, op2); + op2.InitParams(this, element); + op2.ComputeStrengthFastPath(); + + AttributeReadMask |= (int)op2.GetReadAttributes(); + ControlPointReadMask |= op2.GetReadControlPointMask(); + + switch (functionType) { + case ParticleFunctionType.Renderer: + case ParticleFunctionType.Operator: + case ParticleFunctionType.ForceGenerator: + case ParticleFunctionType.Constraint: + PerParticleUpdatedAttributeMask |= (int)op2.GetWrittenAttributes(); + InitialAttributeReadMask |= (int)op2.GetReadInitialAttributes(); + break; + case ParticleFunctionType.Initializer: + case ParticleFunctionType.Emitter: + PerParticleInitializedAttributeMask |= (int)op2.GetWrittenAttributes(); + break; + } + + if (((op2.GetReadAttributes() | op2.GetReadInitialAttributes()) & PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK) != 0) { + PerParticleInitializedAttributeMask |= PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + InitialAttributeReadMask |= PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK; + } + + outList.Add(op2); + } + } + + void ParseChildren(Element element) { + if (!element.TryGetValue("children", out object? attribute) || attribute is not ElementArray children) + return; + + foreach (Element? childRef in children) { + if (childRef == null) + continue; + if (!childRef.TryGetValue("child", out object? childValue) || childValue is not Element particleSystem) + continue; + if (!string.Equals(particleSystem.ClassName, DmeParticleSystemDefinition, StringComparison.OrdinalIgnoreCase)) + continue; + + ParticleChildrenInfo info = new(); + Children.Add(info); + ChildOperatorDefinition.ChildrenInfoUnpack.UnpackIntoStructure(childRef, info); + info.UseNameBasedLookup = !(particleSystem.TryGetValue("preventNameBasedLookup", out object? prevent) && prevent is true); + if (info.UseNameBasedLookup) + info.Name = particleSystem.Name; + else + info.Id = particleSystem.ID; + + Mgr.Dictionary!.AddParticleSystem(particleSystem); + } + } + + void SetupContextData() { + ContextDataSize = 0; + ReadOnlySpan> olists = [Operators, Renderers, Initializers, Emitters, ForceGenerators, Constraints]; + ReadOnlySpan> offsetLists = [OperatorsCtxOffsets, RenderersCtxOffsets, InitializersCtxOffsets, EmittersCtxOffsets, ForceGeneratorsCtxOffsets, ConstraintsCtxOffsets]; + for (int i = 0; i < olists.Length; i++) { + foreach (ParticleOperatorInstance op in olists[i]) { + offsetLists[i].Add(ContextDataSize); + ContextDataSize = (ContextDataSize + op.GetRequiredContextBytes() + 15) & ~15; + } + } + } + + ParticleSystemDefinition? FindChild(ParticleChildrenInfo child) + => child.UseNameBasedLookup ? Mgr.Dictionary!.FindParticleSystem(child.Name) : Mgr.Dictionary!.FindParticleSystem(child.Id); + + public void Precache() { + if (IsPrecached) + return; + + IsPrecached = true; + Material.Init(MaterialName, TEXTURE_GROUP_OTHER, true); + + foreach (ParticleOperatorInstance renderer in Renderers) + renderer.Precache(this); + + foreach (ParticleChildrenInfo child in Children) { + ParticleSystemDefinition? childDef = FindChild(child); + if (childDef != null && !childDef.IsPrecached) + childDef.Precache(); + } + } + + public void Uncache() { + if (!IsPrecached) + return; + + IsPrecached = false; + Material.Shutdown(); + + foreach (ParticleChildrenInfo child in Children) { + ParticleSystemDefinition? childDef = FindChild(child); + if (childDef != null && childDef.IsPrecached) + childDef.Uncache(); + } + } +} diff --git a/Source.Particles/ParticleSystemDictionary.cs b/Source.Particles/ParticleSystemDictionary.cs new file mode 100644 index 00000000..98ff50cc --- /dev/null +++ b/Source.Particles/ParticleSystemDictionary.cs @@ -0,0 +1,93 @@ +using Datamodel; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class ParticleSystemDictionary(ParticleSystemMgr mgr) +{ + readonly Dictionary NameSymbols = new(StringComparer.OrdinalIgnoreCase); + readonly List SymbolNames = []; + readonly List ParticleNameMap = []; + readonly List ParticleIdMap = []; + + public int NameCount() => SymbolNames.Count; + public int Count() => ParticleIdMap.Count; + public ParticleSystemDefinition GetParticleSystem(int index) => ParticleIdMap[index]; + + public IEnumerable AllDefinitions() { + foreach (ParticleSystemDefinition def in ParticleIdMap) + yield return def; + foreach (ParticleSystemDefinition? def in ParticleNameMap) + if (def != null) + yield return def; + } + + int FindSymbol(string? name) => name != null && NameSymbols.TryGetValue(name, out int symbol) ? symbol : INVALID_PARTICLE_SYSTEM_HANDLE; + + int AddSymbol(string name) { + if (NameSymbols.TryGetValue(name, out int symbol)) + return symbol; + symbol = SymbolNames.Count; + NameSymbols[name] = symbol; + SymbolNames.Add(name); + return symbol; + } + + public int FindParticleSystemHandle(string? name) => FindSymbol(name); + + public string? GetSymbolName(int handle) => handle >= 0 && handle < SymbolNames.Count ? SymbolNames[handle] : null; + + public ParticleSystemDefinition? FindParticleSystem(int handle) + => handle != INVALID_PARTICLE_SYSTEM_HANDLE && handle >= 0 && handle < ParticleNameMap.Count ? ParticleNameMap[handle] : null; + + public ParticleSystemDefinition? FindParticleSystem(string? name) => FindParticleSystem(FindSymbol(name)); + + public ParticleSystemDefinition? FindParticleSystem(Guid id) { + foreach (ParticleSystemDefinition def in ParticleIdMap) + if (def.GetId() == id) + return def; + return null; + } + + static bool PreventNameBasedLookup(Element element) + => element.TryGetValue("preventNameBasedLookup", out object? value) && value is true; + + void SetNameMap(int symbol, ParticleSystemDefinition? def) { + while (ParticleNameMap.Count <= symbol) + ParticleNameMap.Add(null); + ParticleNameMap[symbol] = def; + } + + void DestroyExistingElement(Element element) { + if (PreventNameBasedLookup(element)) { + int index = ParticleIdMap.FindIndex(d => d.GetId() == element.ID); + if (index < 0) + return; + ParticleIdMap[index] = ParticleIdMap[^1]; + ParticleIdMap.RemoveAt(ParticleIdMap.Count - 1); + return; + } + + int symbol = FindSymbol(element.Name); + if (symbol == INVALID_PARTICLE_SYSTEM_HANDLE) + return; + SetNameMap(symbol, null); + } + + public ParticleSystemDefinition? AddParticleSystem(Element particleSystem) { + if (!string.Equals(particleSystem.ClassName, ParticleSystemDefinition.DmeParticleSystemDefinition, StringComparison.OrdinalIgnoreCase)) + return null; + + DestroyExistingElement(particleSystem); + + ParticleSystemDefinition def = new(mgr); + if (PreventNameBasedLookup(particleSystem)) + ParticleIdMap.Add(def); + else + SetNameMap(AddSymbol(particleSystem.Name), def); + + def.Read(particleSystem); + return def; + } +} diff --git a/Source.Particles/ParticleSystemMgr.cs b/Source.Particles/ParticleSystemMgr.cs new file mode 100644 index 00000000..229ed9df --- /dev/null +++ b/Source.Particles/ParticleSystemMgr.cs @@ -0,0 +1,484 @@ +using Datamodel; + +using Source.Common.Filesystem; +using Source.Common.Formats.Keyvalues; +using Source.Common.MaterialSystem; +using Source.Common.Mathematics; + +using DM = Datamodel.Datamodel; + +using static Source.Particles.ParticleConstants; + +namespace Source.Particles; + +public sealed class ParticleSystemMgr +{ + public static int g_nParticle_Multiplier = 1; + + readonly List[] ParticleOperators = new List[(int)ParticleFunctionType.Count]; + + public ParticleSystemDictionary? Dictionary { get; private set; } + + IParticleSystemQuery Query_ = new DefaultParticleSystemQuery(); + IFileSystem? FileSystem; + IMaterial? ShadowDepthMaterial; + double LastSimulationTime; + bool DidInit; + bool UsingDefaultQuery = true; + bool ShouldLoadSheets_ = true; + + public ParticleSystemMgr() { + for (int i = 0; i < ParticleOperators.Length; i++) + ParticleOperators[i] = []; + } + + public IParticleSystemQuery Query() => Query_; + + public bool Init(IParticleSystemQuery? query, IFileSystem fileSystem) { + FileSystem = fileSystem; + + if (UsingDefaultQuery && query != null) { + Query_ = query; + UsingDefaultQuery = false; + } + + if (DidInit) + return true; + + Dictionary = new ParticleSystemDictionary(this); + ParticleOperators[(int)ParticleFunctionType.Children].Add(ChildOperatorDefinition.Instance); + + ShadowDepthMaterial = null; + if (Singleton().GetDXSupportLevel() >= 90) { + KeyValues vmtKeyValues = new("DepthWrite"); + vmtKeyValues.SetInt("$no_fullbright", 1); + vmtKeyValues.SetInt("$model", 0); + vmtKeyValues.SetInt("$alphatest", 0); + ShadowDepthMaterial = Singleton().CreateMaterial("__particlesDepthWrite", vmtKeyValues); + } + + RandSIMD.Seed(12345678); + DidInit = true; + return true; + } + + public void AddParticleOperator(ParticleFunctionType opType, IParticleOperatorDefinition opFactory) + => ParticleOperators[(int)opType].Add(opFactory); + + public List GetAvailableParticleOperatorList(ParticleFunctionType whichList) => ParticleOperators[(int)whichList]; + + public IDmxElementUnpackStructure GetParticleSystemDefinitionUnpackStructure() => ParticleSystemDefinition.GetUnpackStructure(); + + public void ShouldLoadSheets(bool loadSheets) => ShouldLoadSheets_ = loadSheets; + public bool GetShouldLoadSheets() => ShouldLoadSheets_; + + public void DecommitTempMemory() { } + + public void SetLastSimulationTime(double time) => LastSimulationTime = time; + public double GetLastSimulationTime() => LastSimulationTime; + + public bool ReadParticleConfigFile(string fileName, bool precache, bool decommitTempMemory = true) { + if (fileName.StartsWith('!')) { + fileName = fileName[1..]; + precache = true; + } + + IMaterialSystemHardwareConfig hardwareConfig = Singleton(); + string? fallbackFormat = null; + if (hardwareConfig.GetDXSupportLevel() < 90) + fallbackFormat = "{0}_dx80.{1}"; + else if (hardwareConfig.GetDXSupportLevel() == 90 && hardwareConfig.PreferReducedFillrate()) + fallbackFormat = "{0}_dx90_slow.{1}"; + + if (fallbackFormat != null) { + int dot = fileName.LastIndexOfAny(['.', '/', '\\']); + bool hasExtension = dot >= 0 && fileName[dot] == '.'; + string stripped = hasExtension ? fileName[..dot] : fileName; + string extension = hasExtension ? fileName[(dot + 1)..] : "pcf"; + string fallback = string.Format(fallbackFormat, stripped, extension); + if (FileSystem!.FileExists(fallback)) + fileName = fallback; + } + + using IFileHandle? handle = FileSystem!.Open(fileName, FileOpenOptions.Read | FileOpenOptions.Binary, "GAME"); + if (handle == null || !handle.IsOK()) { + Warning($"Particles: Missing '{fileName}'\n"); + return false; + } + + using MemoryStream buffer = new(); + handle.Stream.CopyTo(buffer); + buffer.Position = 0; + return ReadParticleDefinitions(buffer, fileName, precache, decommitTempMemory); + } + + public bool ReadParticleConfigFile(Stream buf, bool precache, bool decommitTempMemory = true, string? fileName = null) + => ReadParticleDefinitions(buf, fileName, precache, decommitTempMemory); + + bool ReadParticleDefinitions(Stream buf, string? fileName, bool precache, bool decommitTempMemory) { + DM dm; + try { + dm = DM.Load(buf, Datamodel.Codecs.DeferredMode.Disabled); + } + catch (Exception) { + Warning($"Unable to read particle definition {fileName}! UtlBuffer is probably the wrong type!\n"); + return false; + } + + using (dm) { + Element? root = dm.Root; + if (root == null) { + Warning($"Unable to read particle definition {fileName}! UtlBuffer is probably the wrong type!\n"); + return false; + } + + if (string.Equals(root.ClassName, ParticleSystemDefinition.DmeParticleSystemDefinition, StringComparison.OrdinalIgnoreCase)) { + AddParticleSystem(root, precache); + return true; + } + + if (!root.TryGetValue("particleSystemDefinitions", out object? attribute) || attribute is not ElementArray definitions) + return false; + + foreach (Element? definition in definitions) + if (definition != null) + AddParticleSystem(definition, precache); + return true; + } + } + + void AddParticleSystem(Element element, bool precache) { + ParticleSystemDefinition? def = Dictionary!.AddParticleSystem(element); + if (def != null && precache) { + def.AlwaysPrecache = true; + if (!def.IsPrecached) + def.Precache(); + } + } + + public bool IsParticleSystemDefined(string? name) { + if (string.IsNullOrEmpty(name)) + return false; + return Dictionary!.FindParticleSystem(name) != null; + } + + public bool IsParticleSystemDefined(Guid id) => id != Guid.Empty && Dictionary!.FindParticleSystem(id) != null; + + public int GetParticleSystemIndex(string? name) => name == null ? INVALID_PARTICLE_SYSTEM_HANDLE : Dictionary!.FindParticleSystemHandle(name); + + public string GetParticleSystemNameFromIndex(int index) { + if (index == INVALID_PARTICLE_SYSTEM_HANDLE || index >= Dictionary!.NameCount()) + return "Unknown"; + ParticleSystemDefinition? def = Dictionary.FindParticleSystem(index); + return def == null ? "Unknown" : def.Name; + } + + public int GetParticleSystemCount() => Dictionary!.NameCount(); + + public ParticleSystemDefinition? FindParticleSystem(string? name) => Dictionary!.FindParticleSystem(name); + public ParticleSystemDefinition? FindParticleSystem(Guid id) => Dictionary!.FindParticleSystem(id); + + public ParticleCollection? CreateParticleCollection(string? name, float delay = 0.0f, int randomSeed = 0) { + if (name == null) + return null; + + ParticleSystemDefinition? def = Dictionary!.FindParticleSystem(name); + if (def == null) { + Warning($"Attempted to create unknown particle system type {name}\n"); + return null; + } + + ParticleCollection collection = new(); + collection.Init(def, delay, randomSeed); + return collection; + } + + public ParticleCollection? CreateParticleCollection(Guid id, float delay = 0.0f, int randomSeed = 0) { + if (id == Guid.Empty) + return null; + + ParticleSystemDefinition? def = Dictionary!.FindParticleSystem(id); + if (def == null) { + Warning($"Attempted to create unknown particle system id {id}\n"); + return null; + } + + ParticleCollection collection = new(); + collection.Init(def, delay, randomSeed); + return collection; + } + + const int NUM_KILL_LISTS = 16; + readonly int[]?[] FreeKillLists = new int[]?[NUM_KILL_LISTS]; + int NumFreeKillLists = -1; + readonly Lock KillListLock = new(); + + internal void AttachKillList(ParticleCollection particles) { + lock (KillListLock) { + if (NumFreeKillLists < 0) { + for (int i = 0; i < NUM_KILL_LISTS; i++) + FreeKillLists[i] = new int[MAX_PARTICLES_IN_A_SYSTEM]; + NumFreeKillLists = NUM_KILL_LISTS; + } + + if (NumFreeKillLists == 0) + Error("Out of particle kill lists!\n"); + + particles.NumParticlesToKill = 0; + particles.ParticleKillList = FreeKillLists[--NumFreeKillLists]; + FreeKillLists[NumFreeKillLists] = null; + } + } + + internal void DetachKillList(ParticleCollection particles) { + lock (KillListLock) { + FreeKillLists[NumFreeKillLists++] = particles.ParticleKillList; + particles.ParticleKillList = null; + } + } + + public void PrecacheParticleSystem(string? name) { + if (string.IsNullOrEmpty(name)) + return; + + ParticleSystemDefinition? def = Dictionary!.FindParticleSystem(name); + if (def == null) { + Warning($"Attemped to precache unknown particle system \"{name}\"!\n"); + return; + } + + if (!def.IsPrecached) + def.Precache(); + } + + public void UncacheAllParticleSystems() { + if (Dictionary == null) + return; + + foreach (ParticleSystemDefinition def in Dictionary.AllDefinitions().ToArray()) + def.Uncache(); + } + + public void RecreateDictionary() => Dictionary = new ParticleSystemDictionary(this); + + readonly Dictionary SheetList = new(StringComparer.OrdinalIgnoreCase); + + public Sheet? FindOrLoadSheet(string fileName, ITexture texture) { + if (!ShouldLoadSheets_) + return null; + + if (SheetList.TryGetValue(fileName, out Sheet? sheet)) + return sheet; + + Span data = texture.GetResourceData(VTF_RSRC_SHEET); + sheet = data.IsEmpty ? null : new Sheet(data); + SheetList[fileName] = sheet; + return sheet; + } + + public Sheet? FindOrLoadSheet(IMaterial? material) { + if (material == null) + return null; + + IMaterialVar var = material.FindVar("$basetexture", out bool found, true); + if (!found || var == null || !var.IsTexture()) + return null; + + ITexture? texture = var.GetTextureValue(); + if (texture == null || texture.IsError()) + return null; + + return FindOrLoadSheet(new string(texture.GetName()), texture); + } + + public void FlushAllSheets() => SheetList.Clear(); + + const uint VTF_RSRC_SHEET = 0x10; + + static bool DidAddSimulationOperators; + static bool DidAddRenderingOperators; + + public void AddBuiltinSimulationOperators() { + if (DidAddSimulationOperators) + return; + DidAddSimulationOperators = true; + BuiltinParticleOperators.AddBuiltInParticleOperators(this); + BuiltinParticleInitializers.AddBuiltInParticleInitializers(this); + BuiltinParticleEmitters.AddBuiltInParticleEmitters(this); + BuiltinParticleForces.AddBuiltInParticleForceGenerators(this); + BuiltinParticleConstraints.AddBuiltInParticleConstraints(this); + } + + public void AddBuiltinRenderingOperators() { + if (DidAddRenderingOperators) + return; + DidAddRenderingOperators = true; + BuiltinParticleRenderers.AddBuiltInParticleRenderers(this); + } + + int ParticleVertexCount; + int ParticleIndexCount; + bool FrameWarningNeeded; + + public void TallyParticlesRendered(int vertexCount, int indexCount = 0) { + int previous = ParticleVertexCount; + ParticleIndexCount += indexCount; + ParticleVertexCount += vertexCount; + if (previous + vertexCount > 50000) + FrameWarningNeeded = true; + } + + sealed class RenderCacheEntry + { + public IMaterial? Material; + public readonly List Collections = []; + } + + struct BatchStep + { + public ParticleCollection Particles; + public int RendererIndex; + public int FirstParticle; + public int ParticleCount; + public int VertCount; + } + + sealed class RenderCacheBatch + { + public readonly List Steps = []; + public int VertCount; + public int IndexCount; + } + + readonly List RenderCache = []; + readonly List Batches = []; + + public void ResetRenderCache() { + foreach (RenderCacheEntry entry in RenderCache) + entry.Collections.Clear(); + } + + public void AddToRenderCache(ParticleCollection particles) { + if (!particles.IsValid()) + return; + + IMaterial material = particles.Def!.GetMaterial()!; + if (material.IsTranslucent()) + return; + + particles.NextSleepTime = Math.Max(particles.NextSleepTime, GetLastSimulationTime() + particles.Def.NoDrawTimeToGoToSleep); + + RenderCacheEntry? cache = null; + foreach (RenderCacheEntry entry in RenderCache) { + if (entry.Material == material) { + cache = entry; + break; + } + } + + if (cache == null) { + cache = new() { Material = material }; + RenderCache.Add(cache); + } + + cache.Collections.Add(particles); + + for (ParticleCollection? child = particles.Children; child != null; child = child.Next) + AddToRenderCache(child); + } + + void BuildBatchList(RenderCacheEntry cache, IMatRenderContext renderContext) { + Batches.Clear(); + + int maxVertices = renderContext.GetMaxVerticesToRender(cache.Material); + int maxIndices = renderContext.GetMaxIndicesToRender(); + + RenderCacheBatch batch = new(); + Batches.Add(batch); + + foreach (ParticleCollection particles in cache.Collections) { + int rendererCount = particles.GetRendererCount(); + if (!particles.IsValid() || rendererCount <= 0) + continue; + + for (int i = 0; i < rendererCount; i++) { + ParticleOperatorInstance renderer = particles.GetRenderer(i)!; + int firstParticle = 0; + while (firstParticle < particles.ActiveParticles) { + int count = renderer.GetParticlesToRender(particles, particles.GetRendererContext(i), firstParticle, maxVertices, maxIndices, out int vertCount, out int indexCount); + int stepFirst = firstParticle; + firstParticle += count; + + if (count < 1) { + if (batch.VertCount == 0) + break; + batch = new(); + Batches.Add(batch); + if (firstParticle >= particles.ActiveParticles) + break; + continue; + } + + batch.Steps.Add(new() { + Particles = particles, + RendererIndex = i, + FirstParticle = stepFirst, + ParticleCount = count, + VertCount = vertCount + }); + batch.VertCount += vertCount; + batch.IndexCount += indexCount; + } + } + } + + RenderCacheBatch last = Batches[^1]; + if (last.VertCount <= 0 || last.IndexCount <= 0) + Batches.RemoveAt(Batches.Count - 1); + } + + public void DrawRenderCache(bool shadowDepth) { + if (RenderCache.Count == 0) + return; + + using MatRenderContextPtr renderContext = new(Singleton()); + + renderContext.MatrixMode(MaterialMatrixMode.Model); + renderContext.PushMatrix(); + renderContext.LoadIdentity(); + + foreach (RenderCacheEntry cache in RenderCache) { + if (cache.Collections.Count == 0) + continue; + + IMaterial? material = shadowDepth ? ShadowDepthMaterial : cache.Material; + BuildBatchList(cache, renderContext.Context); + if (Batches.Count == 0) + continue; + + renderContext.Bind(material); + IMesh mesh = renderContext.GetDynamicMesh(true)!; + foreach (RenderCacheBatch batch in Batches) { + TallyParticlesRendered(batch.VertCount * 3, batch.IndexCount * 3); + + MeshBuilder meshBuilder = new(); + meshBuilder.Begin(mesh, MaterialPrimitiveType.Triangles, batch.VertCount, batch.IndexCount); + + int vertexOffset = 0; + foreach (BatchStep step in batch.Steps) { + ParticleOperatorInstance renderer = step.Particles.GetRenderer(step.RendererIndex)!; + renderer.RenderUnsorted(step.Particles, step.Particles.GetRendererContext(step.RendererIndex), renderContext.Context, ref meshBuilder, vertexOffset, step.FirstParticle, step.ParticleCount); + vertexOffset += step.VertCount; + } + + meshBuilder.End(); + mesh.Draw(); + } + } + + ResetRenderCache(); + + renderContext.MatrixMode(MaterialMatrixMode.Model); + renderContext.PopMatrix(); + } +} diff --git a/Source.Particles/RandomFloats.cs b/Source.Particles/RandomFloats.cs new file mode 100644 index 00000000..fcc8acb9 --- /dev/null +++ b/Source.Particles/RandomFloats.cs @@ -0,0 +1,263 @@ +namespace Source.Particles; + +public static class RandomFloats +{ + public static readonly float[] Table = [ + 0.336914f, 0.671387f, 0.539307f, 0.165039f, 0.258301f, 0.146973f, 0.475342f, 0.993408f, 0.88208f, 0.733887f, 0.152588f, 0.192871f, 0.873291f, 0.637939f, 0.859131f, 0.836914f, + 0.277344f, 0.026367f, 0.864502f, 0.327393f, 0.428711f, 0.684082f, 0.916992f, 0.935547f, 0.643311f, 0.082764f, 0.033447f, 0.086182f, 0.575684f, 0.121826f, 0.342285f, 0.419189f, + 0.409424f, 0.17749f, 0.049072f, 0.25293f, 0.459717f, 0.561035f, 0.581543f, 0.470703f, 0.662842f, 0.936035f, 0.912354f, 0.965332f, 0.523682f, 0.661865f, 0.484131f, 0.030029f, + 0.958984f, 0.370605f, 0.626709f, 0.736084f, 0.241943f, 0.307129f, 0.969482f, 0.269287f, 0.21582f, 0.995605f, 0.300781f, 0.984375f, 0.621338f, 0.785645f, 0.432373f, 0.895264f, + 0.098389f, 0.857178f, 0.220947f, 0.981689f, 0.667969f, 0.898682f, 0.603027f, 0.588623f, 0.206055f, 0.536133f, 0.245361f, 0.999023f, 0.758545f, 0.1521f, 0.015869f, 0.546387f, + 0.101563f, 0.92041f, 0.56665f, 0.793457f, 0.077148f, 0.675049f, 0.032715f, 0.645264f, 0.654053f, 0.536377f, 0.599121f, 0.300537f, 0.404053f, 0.115967f, 0.646484f, 0.162842f, + 0.88623f, 0.412109f, 0.55249f, 0.63208f, 0.623291f, 0.846436f, 0.313965f, 0.505859f, 0.487305f, 0.644287f, 0.517578f, 0.89209f, 0.14624f, 0.21875f, 0.484619f, 0.904785f, + 0.551758f, 0.809814f, 0.721191f, 0.871582f, 0.847656f, 0.062256f, 0.647949f, 0.708252f, 0.690186f, 0.59375f, 0.061768f, 0.406982f, 0.169434f, 0.874756f, 0.139893f, 0.792236f, + 0.783691f, 0.855957f, 0.198975f, 0.706299f, 0.594971f, 0.739746f, 0.307373f, 0.123291f, 0.480713f, 0.0271f, 0.697266f, 0.534424f, 0.070068f, 0.641602f, 0.4729f, 0.598145f, + 0.21167f, 0.977051f, 0.145264f, 0.311279f, 0.975098f, 0.904297f, 0.999268f, 0.725586f, 0.039307f, 0.669434f, 0.578369f, 0.285889f, 0.867188f, 0.982666f, 0.797119f, 0.755371f, + 0.950195f, 0.383789f, 0.42627f, 0.337402f, 0.075439f, 0.841553f, 0.794678f, 0.074707f, 0.02124f, 0.627686f, 0.036377f, 0.921143f, 0.229248f, 0.20874f, 0.69873f, 0.622803f, + 0.943848f, 0.673828f, 0.826416f, 0.10791f, 0.366943f, 0.352539f, 0.256592f, 0.930176f, 0.556885f, 0.378418f, 0.205566f, 0.286133f, 0.623047f, 0.986328f, 0.781494f, 0.974609f, + 0.239014f, 0.883789f, 0.859375f, 0.884277f, 0.856445f, 0.521484f, 0.332764f, 0.489746f, 0.880615f, 0.553955f, 0.961182f, 0.360352f, 0.48999f, 0.175781f, 0.777832f, 0.02002f, + 0.346436f, 0.250732f, 0.094482f, 0.900146f, 0.185547f, 0.317139f, 0.686768f, 0.517334f, 0.350342f, 0.774902f, 0.978027f, 0.81958f, 0.967773f, 0.811523f, 0.038574f, 0.791504f, + 0.196045f, 0.543701f, 0.705566f, 0.586426f, 0.585449f, 0.016846f, 0.413086f, 0.583496f, 0.772461f, 0.728271f, 0.289307f, 0.482666f, 0.389404f, 0.302002f, 0.331055f, 0.759277f, + 0.885742f, 0.745605f, 0.444092f, 0.341797f, 0.607422f, 0.436279f, 0.102783f, 0.874023f, 0.868408f, 0.662109f, 0.287354f, 0.918701f, 0.892334f, 0.685791f, 0.500244f, 0.433594f, + 0.664795f, 0.734863f, 0.93335f, 0.078369f, 0.808105f, 0.790039f, 0.404541f, 0.005371f, 0.976318f, 0.800537f, 0.482178f, 0.472412f, 0.656494f, 0.835449f, 0.713135f, 0.629395f, + 0.468506f, 0.03833f, 0.143555f, 0.375f, 0.140381f, 0.427734f, 0.822754f, 0.26709f, 0.253662f, 0.68335f, 0.788818f, 0.531738f, 0.2146f, 0.87793f, 0.659668f, 0.640381f, + 0.954346f, 0.227539f, 0.167969f, 0.491211f, 0.084473f, 0.272949f, 0.96167f, 0.06543f, 0.696045f, 0.625732f, 0.177734f, 0.782715f, 0.934814f, 0.385742f, 0.401611f, 0.018555f, + 0.686279f, 0.749023f, 0.114014f, 0.106689f, 0.501709f, 0.471924f, 0.151855f, 0.088623f, 0.677734f, 0.425293f, 0.910645f, 0.483398f, 0.872314f, 0.782471f, 0.16333f, 0.574463f, + 0.119385f, 0.80957f, 0.94751f, 0.19751f, 0.887207f, 0.577637f, 0.021484f, 0.020508f, 0.641846f, 0.321533f, 0.95752f, 0.893555f, 0.625488f, 0.424072f, 0.612793f, 0.003906f, + 0.060059f, 0.388184f, 0.724365f, 0.195068f, 0.263184f, 0.919434f, 0.094971f, 0.550781f, 0.997559f, 0.763916f, 0.300293f, 0.530029f, 0.583984f, 0.767578f, 0.745361f, 0.69165f, + 0.17041f, 0.762695f, 0.949463f, 0.349365f, 0.757324f, 0.30249f, 0.498047f, 0.397217f, 0.213379f, 0.019775f, 0.587402f, 0.562988f, 0.573975f, 0.36084f, 0.320313f, 0.258545f, + 0.948486f, 0.186279f, 0.976563f, 0.19043f, 0.865723f, 0.162598f, 0.547607f, 0.339111f, 0.39209f, 0.273193f, 0.714844f, 0.797363f, 0.403564f, 0.449219f, 0.747314f, 0.844238f, + 0.835205f, 0.110596f, 0.134033f, 0.214355f, 0.766113f, 0.109131f, 0.013184f, 0.875f, 0.737061f, 0.320801f, 0.639893f, 0.744141f, 0.751465f, 0.127197f, 0.011963f, 0.353027f, + 0.693359f, 0.440674f, 0.26416f, 0.780029f, 0.529785f, 0.800781f, 0.671143f, 0.332031f, 0.400635f, 0.981445f, 0.770264f, 0.435059f, 0.29834f, 0.437988f, 0.163574f, 0.271973f, + 0.039551f, 0.043457f, 0.866943f, 0.009766f, 0.651123f, 0.84668f, 0.653076f, 0.125732f, 0.530762f, 0.868896f, 0.268799f, 0.958008f, 0.142578f, 0.461914f, 0.303955f, 0.010986f, + 0.62085f, 0.522217f, 0.510986f, 0.338135f, 0.914551f, 0.411865f, 0.604004f, 0.706543f, 0.238525f, 0.510254f, 0.103271f, 0.632324f, 0.422119f, 0.440186f, 0.265137f, 0.2771f, + 0.221924f, 0.201172f, 0.599365f, 0.244629f, 0.177002f, 0.293945f, 0.368652f, 0.649902f, 0.100586f, 0.622559f, 0.905762f, 0.209961f, 0.257324f, 0.249512f, 0.428467f, 0.369141f, + 0.166016f, 0.635986f, 0.79834f, 0.940918f, 0.993896f, 0.803467f, 0.320068f, 0.929443f, 0.650146f, 0.058594f, 0.065918f, 0.609375f, 0.616943f, 0.379639f, 0.221191f, 0.200684f, + 0.486084f, 0.4375f, 0.871338f, 0.795898f, 0.863037f, 0.700684f, 0.51709f, 0.821533f, 0.319092f, 0.397461f, 0.852295f, 0.864014f, 0.591797f, 0.514404f, 0.925049f, 0.71582f, + 0.384766f, 0.734131f, 0.89917f, 0.703125f, 0.210938f, 0.783203f, 0.687012f, 0.850586f, 0.532471f, 0.025635f, 0.975342f, 0.852051f, 0.612305f, 0.910889f, 0.159668f, 0.407227f, + 0.669678f, 0.096924f, 0.733398f, 0.304688f, 0.015625f, 0.372803f, 0.32959f, 0.858398f, 0.033203f, 0.830811f, 0.914307f, 0.022949f, 0.451416f, 0.106201f, 0.664551f, 0.895752f, + 0.366455f, 0.230225f, 0.595459f, 0.296631f, 0.291992f, 0.375488f, 0.952393f, 0.052734f, 0.132813f, 0.549805f, 0.828125f, 0.065674f, 0.318848f, 0.031494f, 0.605713f, 0.534912f, + 0.611328f, 0.259766f, 0.445068f, 0.660156f, 0.848633f, 0.055176f, 0.32373f, 0.122803f, 0.69751f, 0.097412f, 0.989014f, 0.348877f, 0.536865f, 0.442139f, 0.269043f, 0.762451f, + 0.92627f, 0.118896f, 0.45874f, 0.496094f, 0.253906f, 0.084717f, 0.648926f, 0.754639f, 0.648438f, 0.488281f, 0.533691f, 0.048828f, 0.050781f, 0.847168f, 0.431152f, 0.638184f, + 0.938232f, 0.092285f, 0.970215f, 0.037354f, 0.852539f, 0.58667f, 0.729248f, 0.227295f, 0.48291f, 0.051025f, 0.135254f, 0.08252f, 0.8125f, 0.391602f, 0.598389f, 0.605957f, + 0.949707f, 0.4646f, 0.86377f, 0.024902f, 0.989502f, 0.937012f, 0.435547f, 0.565186f, 0.37085f, 0.801758f, 0.143311f, 0.354492f, 0.715088f, 0.423828f, 0.796387f, 0.384033f, + 0.093018f, 0.813965f, 0.356201f, 0.535889f, 0.229492f, 0.553711f, 0.080811f, 0.711426f, 0.082275f, 0.713623f, 0.097168f, 0.8479f, 0.197754f, 0.057617f, 0.970703f, 0.282959f, + 0.252686f, 0.082031f, 0.847412f, 0.274658f, 0.806641f, 0.027588f, 0.844727f, 0.748535f, 0.66748f, 0.200195f, 0.814941f, 0.912598f, 0.463379f, 0.304199f, 0.815918f, 0.481445f, + 0.345947f, 0.936279f, 0.851318f, 0.796631f, 0.119141f, 0.328369f, 0.185303f, 0.911621f, 0.5271f, 0.342529f, 0.6521f, 0.435303f, 0.537354f, 0.051758f, 0.998535f, 0.597168f, + 0.031006f, 0.056396f, 0.003174f, 0.702637f, 0.262207f, 0.433838f, 0.052002f, 0.776367f, 0.993652f, 0.836182f, 0.055908f, 0.694092f, 0.768311f, 0.073242f, 0.908203f, 0.548584f, + 0.873535f, 0.205078f, 0.551514f, 0.726074f, 0.302979f, 0.136475f, 0.381348f, 0.702393f, 0.054932f, 0.796143f, 0.079346f, 0.049561f, 0.539795f, 0.731201f, 0.175049f, 0.570068f, + 0.171631f, 0.899902f, 0.467041f, 0.623779f, 0.913086f, 0.38623f, 0.451904f, 0.878418f, 0.880371f, 0.316406f, 0.468994f, 0.145752f, 0.920166f, 0.162354f, 0.944092f, 0.816162f, + 0.887695f, 0.802246f, 0.546631f, 0.803955f, 0.491455f, 0.064453f, 0.284424f, 0.153564f, 0.29126f, 0.730713f, 0.173584f, 0.942383f, 0.640137f, 0.480469f, 0.552979f, 0.413818f, + 0.222656f, 0.364502f, 0.736816f, 0.351074f, 0.245605f, 0.183105f, 0.697754f, 0.30835f, 0.467285f, 0.33374f, 0.400391f, 0.301514f, 0.601074f, 0.874512f, 0.571289f, 0.994873f, + 0.438721f, 0.865234f, 0.79541f, 0.476807f, 0.409912f, 0.651855f, 0.375244f, 0.139404f, 0.776611f, 0.713379f, 0.406494f, 0.359619f, 0.635742f, 0.261963f, 0.210449f, 0.669922f, + 0.612061f, 0.363281f, 0.013916f, 0.504639f, 0.11377f, 0.814697f, 0.82666f, 0.016602f, 0.079834f, 0.668945f, 0.453125f, 0.591553f, 0.258789f, 0.345703f, 0.27124f, 0.198486f, + 0.239258f, 0.97583f, 0.203613f, 0.974121f, 0.408691f, 0.775391f, 0.071777f, 0.503418f, 0.483887f, 0.223877f, 0.80542f, 0.813721f, 0.32666f, 0.327148f, 0.616455f, 0.615479f, + 0.430176f, 0.153076f, 0.979736f, 0.611572f, 0.543457f, 0.095459f, 0.897461f, 0.40625f, 0.657471f, 0.108887f, 0.00293f, 0.959961f, 0.396973f, 0.901367f, 0.572998f, 0.056152f, + 0.630371f, 0.762939f, 0.910156f, 0.96582f, 0.397705f, 0.171143f, 0.401367f, 0.453857f, 0.493896f, 0.837158f, 0.636719f, 0.596436f, 0.645752f, 0.894043f, 0.990479f, 0.885254f, + 0.863525f, 0.650391f, 0.761963f, 0.947266f, 0.57373f, 0.94165f, 0.212891f, 0.805664f, 0.153809f, 0.957275f, 0.044678f, 0.743408f, 0.57959f, 0.240967f, 0.172363f, 0.056641f, + 0.327637f, 0.787842f, 0.431885f, 0.652344f, 0.616699f, 0.62915f, 0.893311f, 0.691406f, 0.054199f, 0.840088f, 0.930664f, 0.708008f, 0.398193f, 0.98877f, 0.959717f, 0.666992f, + 0.000244f, 0.696777f, 0.365967f, 0.547119f, 0.12793f, 0.141113f, 0.348633f, 0.531494f, 0.584961f, 0.398926f, 0.728516f, 0.709229f, 0.391113f, 0.265869f, 0.244141f, 0.9729f, + 0.663086f, 0.258057f, 0.317871f, 0.740723f, 0.704834f, 0.138672f, 0.819092f, 0.802002f, 0.563232f, 0.072754f, 0.085938f, 0.868652f, 0.52124f, 0.206543f, 0.696533f, 0.420654f, + 0.897705f, 0.783936f, 0.067627f, 0.686035f, 0.537598f, 0.6604f, 0.78418f, 0.292725f, 0.444336f, 0.128662f, 0.862793f, 0.260742f, 0.789551f, 0.820557f, 0.319824f, 0.045166f, + 0.483154f, 0.533203f, 0.022705f, 0.249756f, 0.20166f, 0.124023f, 0.966064f, 0.11792f, 0.129395f, 0.241699f, 0.585205f, 0.481201f, 0.904053f, 0.627441f, 0.979004f, 0.041992f, + 0.619141f, 0.525879f, 0.682373f, 0.497803f, 0.907471f, 0.303711f, 0.562012f, 0.495117f, 0.500488f, 0.674072f, 0.552734f, 0.249023f, 0.088867f, 0.293213f, 0.22168f, 0.457031f, + 0.187988f, 0.950439f, 0.453369f, 0.01416f, 0.881348f, 0.050049f, 0.686523f, 0.476318f, 0.52417f, 0.552246f, 0.077393f, 0.621826f, 0.829834f, 0.030518f, 0.295654f, 0.215088f, + 0.438965f, 0.271729f, 0.384277f, 0.580322f, 0.191895f, 0.09668f, 0.281982f, 0.984131f, 0.675537f, 0.638672f, 0.329834f, 0.426025f, 0.768799f, 0.484375f, 0.287598f, 0.694824f, + 0.82251f, 0.351563f, 0.736328f, 0.905029f, 0.755127f, 0.661377f, 0.138916f, 0.236572f, 0.662354f, 0.299316f, 0.90625f, 0.77124f, 0.68042f, 0.039063f, 0.029297f, 0.246338f, + 0.876221f, 0.506348f, 0.474365f, 0.476074f, 0.289063f, 0.514648f, 0.751221f, 0.909424f, 0.921631f, 0.121094f, 0.628174f, 0.171875f, 0.881836f, 0.819824f, 0.002441f, 0.955811f, + 0.407715f, 0.288818f, 0.690918f, 0.193359f, 0.090088f, 0.46167f, 0.057861f, 0.597412f, 0.247559f, 0.479492f, 0.2229f, 0.106934f, 0.147705f, 0.750977f, 0.322754f, 0.435791f, + 0.672852f, 0.795654f, 0.036621f, 0.125488f, 0.036865f, 0.224854f, 0.012695f, 0.023438f, 0.19165f, 0.81665f, 0.381592f, 0.448975f, 0.112305f, 0.944336f, 0.017822f, 0.64502f, + 0.113037f, 0.881104f, 0.157715f, 0.692383f, 0.331299f, 0.177979f, 0.771729f, 0.223145f, 0.854004f, 0.698242f, 0.821777f, 0.341553f, 0.638428f, 0.161133f, 0.040039f, 0.592529f, + 0.679932f, 0.55835f, 0.36377f, 0.423584f, 0.710938f, 0.219482f, 0.738037f, 0.339844f, 0.433105f, 0.104736f, 0.65332f, 0.688965f, 0.087402f, 0.593994f, 0.387451f, 0.111328f, + 0.254639f, 0.34668f, 0.615234f, 0.588379f, 0.273682f, 0.141602f, 0.418701f, 0.294678f, 0.569336f, 0.442383f, 0.598877f, 0.075684f, 0.677979f, 0.76123f, 0.919189f, 0.861572f, + 0.320557f, 0.790771f, 0.064697f, 0.144531f, 0.93457f, 0.721436f, 0.684814f, 0.251465f, 0.762207f, 0.76709f, 0.528076f, 0.385498f, 0.269531f, 0.879639f, 0.576416f, 0.419434f, + 0.875732f, 0.672607f, 0.823242f, 0.785156f, 0.877686f, 0.432861f, 0.41626f, 0.066406f, 0.233643f, 0.703857f, 0.719482f, 0.352783f, 0.837646f, 0.615967f, 0.593018f, 0.137451f, + 0.199951f, 0.712891f, 0.885498f, 0.923828f, 0.777588f, 0.669189f, 0.546875f, 0.400146f, 0.374023f, 0.455322f, 0.577881f, 0.328125f, 0.95459f, 0.680908f, 0.836426f, 0.699219f, + 0.803711f, 0.350586f, 0.259277f, 0.878174f, 0.798096f, 0.904541f, 0.314453f, 0.820313f, 0.949951f, 0.125f, 0.782227f, 0.008057f, 0.303467f, 0.976074f, 0.189941f, 0.216064f, + 0.069092f, 0.070557f, 0.680176f, 0.983643f, 0.182861f, 0.65625f, 0.133545f, 0.389893f, 0.277588f, 0.229004f, 0.148438f, 0.193115f, 0.5625f, 0.835938f, 0.172607f, 0.550293f, + 0.290527f, 0.146729f, 0.334229f, 0.334717f, 0.707031f, 0.023193f, 0.969727f, 0.593262f, 0.708496f, 0.884766f, 0.329346f, 0.362305f, 0.305176f, 0.072021f, 0.591309f, 0.13501f, + 0.43457f, 0.394287f, 0.239746f, 0.532715f, 0.751709f, 0.760986f, 0.08374f, 0.763184f, 0.765381f, 0.230713f, 0.312988f, 0.819336f, 0.338623f, 0.619385f, 0.152832f, 0.971436f, + 0.656982f, 0.585693f, 0.089844f, 0.513184f, 0.732178f, 0.548828f, 0.980469f, 0.022461f, 0.34082f, 0.411377f, 0.829346f, 0.644531f, 0.804443f, 0.086914f, 0.468018f, 0.368164f, + 0.243408f, 0.824463f, 0.35083f, 0.416748f, 0.025879f, 0.156494f, 0.98999f, 0.12915f, 0.814453f, 0.574707f, 0.790527f, 0.296387f, 0.510498f, 0.990234f, 0.480957f, 0.56543f, + 0.550537f, 0.461182f, 0.359863f, 0.966553f, 0.31665f, 0.1875f, 0.032959f, 0.460693f, 0.692871f, 0.294434f, 0.857666f, 0.217041f, 0.128174f, 0.207764f, 0.309814f, 0.846924f, + 0.531982f, 0.047607f, 0.555664f, 0.19873f, 0.049316f, 0.576904f, 0.709473f, 0.518799f, 0.069336f, 0.601563f, 0.228516f, 0.048096f, 0.47998f, 0.108643f, 0.080566f, 0.386719f, + 0.5354f, 0.465088f, 0.472168f, 0.105957f, 0.310059f, 0.489014f, 0.987549f, 0.406006f, 0.673096f, 0.366211f, 0.681885f, 0.509766f, 0.600342f, 0.506592f, 0.558594f, 0.875488f, + 0.413574f, 0.083984f, 0.015137f, 0.559082f, 0.09375f, 0.805176f, 0.933838f, 0.775635f, 0.826172f, 0.45166f, 0.779785f, 0.158691f, 0.346191f, 0.601318f, 0.407471f, 0.54541f, + 0.712646f, 0.845947f, 0.741211f, 0.337891f, 0.393799f, 0.407959f, 0.095703f, 0.817139f, 0.198242f, 0.818359f, 0.272461f, 0.05127f, 0.350098f, 0.445557f, 0.485352f, 0.168945f, + 0.855469f, 0.427246f, 0.189453f, 0.646973f, 0.648193f, 0.717041f, 0.737305f, 0.222168f, 0.704346f, 0.235352f, 0.126221f, 0.617676f, 0.108154f, 0.287842f, 0.237549f, 0.544678f, + 0.761719f, 0.832764f, 0.78125f, 0.501221f, 0.168213f, 0.262451f, 0.325684f, 0.39624f, 0.970459f, 0.631348f, 0.134277f, 0.337158f, 0.006592f, 0.217529f, 0.333496f, 0.698486f, + 0.810059f, 0.391846f, 0.361572f, 0.265625f, 0.919922f, 0.408447f, 0.299561f, 0.524414f, 0.07666f, 0.233887f, 0.147217f, 0.247803f, 0.720459f, 0.655273f, 0.178711f, 0.642822f, + 0.076904f, 0.408936f, 0.113281f, 0.201416f, 0.730957f, 0.200439f, 0.88501f, 0.100342f, 0.369385f, 0.395264f, 0.54248f, 0.94043f, 0.684326f, 0.666504f, 0.22876f, 0.699463f, + 0.127441f, 0.212646f, 0.835693f, 0.029785f, 0.656006f, 0.354736f, 0.278564f, 0.3396f, 0.549561f, 0.149658f, 0.593506f, 0.298096f, 0.492432f, 0.447754f, 0.264648f, 0.634766f, + 0.166992f, 0.515137f, 0.382568f, 0.142822f, 0.783447f, 0.953125f, 0.439697f, 0.267822f, 0.121338f, 0.73584f, 0.087891f, 0.507568f, 0.595703f, 0.655518f, 0.610107f, 0.541748f, + 0.645508f, 0.057373f, 0.624512f, 0.191406f, 0.832031f, 0.702148f, 0.330566f, 0.087646f, 0.242188f, 0.099854f, 0.307861f, 0.430908f, 0.68457f, 0.939453f, 0.03125f, 0.924805f, + 0.462646f, 0.120361f, 0.545654f, 0.789063f, 0.719971f, 0.072266f, 0.353271f, 0.996826f, 0.62793f, 0.093994f, 0.920654f, 0.058105f, 0.430664f, 0.403076f, 0.448486f, 0.589111f, + 0.524658f, 0.148682f, 0.671875f, 0.470947f, 0.851807f, 0.367188f, 0.749268f, 0.746582f, 0.429199f, 0.466064f, 0.519531f, 0.645996f, 0.125977f, 0.549072f, 0.547363f, 0.294189f, + 0.254883f, 0.634277f, 0.66333f, 0.52832f, 0.178955f, 0.730225f, 0.063232f, 0.979248f, 0.733154f, 0.543945f, 0.668213f, 0.228027f, 0.896729f, 0.16748f, 0.55127f, 0.174316f, + 0.271484f, 0.519043f, 0.310791f, 0.664307f, 0.984619f, 0.534668f, 0.541992f, 0.604492f, 0.946045f, 0.870117f, 0.161865f, 0.660889f, 0.587646f, 0.770996f, 0.573486f, 0.035156f, + 0.895996f, 0.812988f, 0.452881f, 0.854248f, 0.404297f, 0.371094f, 0.561768f, 0.132324f, 0.009033f, 0.954834f, 0.522461f, 0.134521f, 0.538574f, 0.145996f, 0.968994f, 0.620117f, + 0.582275f, 0.609863f, 0.325195f, 0.620361f, 0.070801f, 0.633301f, 0.116455f, 0.236084f, 0.48584f, 0.519287f, 0.264404f, 0.008301f, 0.632568f, 0.091553f, 0.142334f, 0.050537f, + 0.358154f, 0.126953f, 0.572021f, 0.471436f, 0.017334f, 0.754883f, 0.735596f, 0.313232f, 0.780518f, 0.903809f, 0.314209f, 0.324951f, 0.188721f, 0.586182f, 0.421875f, 0.565918f, + 0.179443f, 0.723389f, 0.242676f, 0.592773f, 0.818604f, 0.501465f, 0.092529f, 0.126709f, 0.250244f, 0.787354f, 0.104248f, 0.758301f, 0.395508f, 0.804932f, 0.09082f, 0.828857f, + 0.014893f, 0.899414f, 0.716797f, 0.942871f, 0.839111f, 0.493164f, 0.625244f, 0.867432f, 0.50415f, 0.71875f, 0.725098f, 0.365479f, 0.256104f, 0.653564f, 0.355469f, 0.808838f, + 0.933594f, 0.525146f, 0.80835f, 0.454346f, 0.775879f, 0.184326f, 0.052979f, 0.658936f, 0.243896f, 0.799072f, 0.603516f, 0.85498f, 0.947021f, 0.004639f, 0.503174f, 0.003418f, + 0.682617f, 0.49292f, 0.887451f, 0.924316f, 0.475098f, 0.766602f, 0.91748f, 0.964111f, 0.971191f, 0.14502f, 0.071289f, 0.7229f, 0.144775f, 0.335205f, 0.61377f, 0.643066f, + 0.186035f, 0.081299f, 0.393311f, 0.123047f, 0.261719f, 0.196533f, 0.43335f, 0.263916f, 0.935303f, 0.278076f, 0.732422f, 0.328613f, 0.937988f, 0.706787f, 0.467529f, 0.203857f, + 0.279541f, 0.957764f, 0.600586f, 0.226074f, 0.213867f, 0.563721f, 0.132568f, 0.80249f, 0.318359f, 0.0354f, 0.606201f, 0.72168f, 0.735352f, 0.917725f, 0.045898f, 0.173828f, + 0.486328f, 0.241211f, 0.243164f, 0.181152f, 0.637695f, 0.670166f, 0.964844f, 0.367676f, 0.826904f, 0.903076f, 0.457764f, 0.04126f, 0.161377f, 0.955322f, 0.752197f, 0.769043f, + 0.163818f, 0.117188f, 0.971924f, 0.611084f, 0.560303f, 0.31958f, 0.194824f, 0.325928f, 0.477051f, 0.264893f, 0.043213f, 0.002686f, 0.69043f, 0.89624f, 0.40918f, 0.765137f, + 0.741455f, 0.689941f, 0.860107f, 0.70459f, 0.983887f, 0.869629f, 0.452637f, 0.376953f, 0.839355f, 0.951416f, 0.378906f, 0.042969f, 0.287109f, 0.064209f, 0.195801f, 0.494385f, + 0.720947f, 0.139648f, 0.570313f, 0.25f, 0.181396f, 0.461426f, 0.921875f, 0.939209f, 0.690674f, 0.393555f, 0.693115f, 0.614502f, 0.322266f, 0.720215f, 0.636475f, 0.84082f, + 0.958496f, 0.931641f, 0.063965f, 0.77002f, 0.298828f, 0.606445f, 0.886719f, 0.506104f, 0.95874f, 0.525635f, 0.297119f, 0.567871f, 0.358643f, 0.365234f, 0.187012f, 0.570801f, + 0.116211f, 0.786621f, 0.336182f, 0.388428f, 0.91333f, 0.494141f, 0.696289f, 0.848145f, 0.699951f, 0.59668f, 0.276123f, 0.015381f, 0.685303f, 0.67749f, 0.463623f, 0.866699f, + 0.283447f, 0.909912f, 0.215332f, 0.062012f, 0.495361f, 0.307617f, 0.46582f, 0.005127f, 0.937256f, 0.606934f, 0.465332f, 0.37915f, 0.685547f, 0.111084f, 0.753662f, 0.516113f, + 0.412354f, 0.05835f, 0.553223f, 0.181885f, 0.963867f, 0.639648f, 0.50293f, 0.018799f, 0.588867f, 0.974365f, 0.657227f, 0.122559f, 0.773926f, 0.526367f, 0.243652f, 0.25415f, + 0.618408f, 0.589355f, 0.657959f, 0.209229f, 0.670898f, 0.621582f, 0.523926f, 0.57251f, 0.053223f, 0.093262f, 0.187744f, 0.291504f, 0.083496f, 0.22998f, 0.109375f, 0.340332f, + 0.496582f, 0.659424f, 0.626221f, 0.18335f, 0.059814f, 0.711914f, 0.526611f, 0.425781f, 0.995361f, 0.784424f, 0.170654f, 0.275146f, 0.402344f, 0.972656f, 0.624268f, 0.923584f, + 0.744385f, 0.9021f, 0.361816f, 0.682861f, 0.97168f, 0.441895f, 0.186768f, 0.144043f, 0.80127f, 0.85376f, 0.099121f, 0.584717f, 0.443604f, 0.423096f, 0.855225f, 0.976807f, + 0.326904f, 0.614014f, 0.337646f, 0.821289f, 0.109863f, 0.405762f, 0.000732f, 0.157471f, 0.377441f, 0.987793f, 0.766846f, 0.05957f, 0.434814f, 0.186523f, 0.332275f, 0.214844f, + 0.07251f, 0.640625f, 0.280029f, 0.105469f, 0.280762f, 0.946533f, 0.845703f, 0.02832f, 0.044922f, 0.60376f, 0.059082f, 0.255371f, 0.143799f, 0.678711f, 0.182129f, 0.085205f, + 0.915771f, 0.610352f, 0.457275f, 0.617188f, 0.060547f, 0.774658f, 0.82959f, 0.854492f, 0.313721f, 0.592041f, 0.156006f, 0.469482f, 0.743896f, 0.750732f, 0.00415f, 0.352051f, + 0.853271f, 0.313477f, 0.456543f, 0.841797f, 0.00708f, 0.389648f, 0.849365f, 0.942627f, 0.561279f, 0.391357f, 0.214111f, 0.164551f, 0.554199f, 0.246582f, 0.012939f, 0.364746f, + 0.10498f, 0.046387f, 0.002197f, 0.42041f, 0.802979f, 0.156738f, 0.028076f, 0.115479f, 0.405029f, 0.708984f, 0.782959f, 0.851074f, 0.748291f, 0.088135f, 0.681152f, 0.099365f, + 0.624756f, 0.338379f, 0.64209f, 0.221436f, 0.997314f, 0.54834f, 0.259521f, 0.464111f, 0.016113f, 0.793945f, 0.773193f, 0.930908f, 0.316895f, 0.522705f, 0.755615f, 0.361328f, + 0.923096f, 0.323242f, 0.487061f, 0.474854f, 0.800293f, 0.025391f, 0.417236f, 0.89502f, 0.700195f, 0.508789f, 0.031982f, 0.467773f, 0.890137f, 0.450684f, 0.710693f, 0.204834f, + 0.724121f, 0.707764f, 0.425537f, 0.233154f, 0.716064f, 0.668701f, 0.255615f, 0.388672f, 0.893799f, 0.224609f, 0.978516f, 0.195557f, 0.145508f, 0.499268f, 0.890625f, 0.49585f, + 0.362793f, 0.900879f, 0.902344f, 0.882324f, 0.811279f, 0.579346f, 0.128418f, 0.126465f, 0.283936f, 0.406738f, 0.588135f, 0.281738f, 0.358887f, 0.946289f, 0.641357f, 0.616211f, + 0.747559f, 0.651611f, 0.87207f, 0.858887f, 0.834717f, 0.694336f, 0.005615f, 0.744873f, 0.83667f, 0.643799f, 0.602539f, 0.020996f, 0.107422f, 0.055664f, 0.961426f, 0.900391f, + 0.867676f, 0.133057f, 0.99585f, 0.737549f, 0.807617f, 0.289795f, 0.354004f, 0.972168f, 0.13916f, 0.58252f, 0.497314f, 0.514893f, 0.759033f, 0.778564f, 0.128906f, 0.862549f, + 0.60083f, 0.070313f, 0.966797f, 0.0979f, 0.252197f, 0.758789f, 0.529541f, 0.840576f, 0.373291f, 0.268066f, 0.72876f, 0.376221f, 0.394775f, 0.434082f, 0.840332f, 0.729004f, + 0.759521f, 0.908691f, 0.884521f, 0.504883f, 0.460449f, 0.288086f, 0.983398f, 0.213623f, 0.816406f, 0.716553f, 0.629883f, 0.414307f, 0.158936f, 0.828369f, 0.008545f, 0.780762f, + 0.364014f, 0.204102f, 0.465576f, 0.675781f, 0.66626f, 0.503906f, 0.299072f, 0.171387f, 0.511475f, 0.072998f, 0.809326f, 0.248291f, 0.182373f, 0.853516f, 0.364258f, 0.466797f, + 0.399902f, 0.001465f, 0.722412f, 0.830566f, 0.115234f, 0.740967f, 0.566406f, 0.068115f, 0.140869f, 0.107178f, 0.242432f, 0.290039f, 0.07959f, 0.591064f, 0.620605f, 0.515381f, + 0.229736f, 0.770752f, 0.707275f, 0.455811f, 0.114502f, 0.485596f, 0.628418f, 0.590088f, 0.175293f, 0.289551f, 0.077637f, 0.787109f, 0.04248f, 0.357666f, 0.790283f, 0.512451f, + 0.447998f, 0.825195f, 0.724609f, 0.893066f, 0.769287f, 0.739014f, 0.101318f, 0.152344f, 0.096436f, 0.752441f, 0.494873f, 0.020752f, 0.297852f, 0.036133f, 0.907227f, 0.477295f, + 0.869385f, 0.74292f, 0.952148f, 0.7146f, 0.053711f, 0.687744f, 0.660645f, 0.633545f, 0.439453f, 0.888428f, 0.908936f, 0.443848f, 0.030273f, 0.885986f, 0.284912f, 0.238281f, + 0.933105f, 0.34375f, 0.963623f, 0.19458f, 0.996338f, 0.473877f, 0.545166f, 0.931885f, 0.399658f, 0.871826f, 0.398438f, 0.4104f, 0.344482f, 0.921387f, 0.85083f, 0.94458f, + 0.250977f, 0.150879f, 0.834229f, 0.267578f, 0.734375f, 0.939697f, 0.913574f, 0.63623f, 0.283691f, 0.94873f, 0.306885f, 0.557861f, 0.764648f, 0.253418f, 0.582764f, 0.505615f, + 0.340088f, 0.26123f, 0.727783f, 0.016357f, 0.658447f, 0.559326f, 0.102051f, 0.714111f, 0.535645f, 0.650635f, 0.622314f, 0.383545f, 0.916748f, 0.955566f, 0.116943f, 0.018311f, + 0.750244f, 0.208252f, 0.773438f, 0.281006f, 0.095215f, 0.928467f, 0.426514f, 0.177246f, 0.219727f, 0.36792f, 0.495605f, 0.443115f, 0.380127f, 0.175537f, 0.452148f, 0.641113f, + 0.786133f, 0.602295f, 0.784668f, 0.034912f, 0.061523f, 0.962891f, 0.715332f, 0.580078f, 0.363525f, 0.533936f, 0.009277f, 0.740479f, 0.285156f, 0.402832f, 0.821045f, 0.441406f, + 0.568848f, 0.33667f, 0.185791f, 0.211182f, 0.218994f, 0.492676f, 0.205811f, 0.655029f, 0.784912f, 0.67627f, 0.709717f, 0.335449f, 0.081787f, 0.529053f, 0.794434f, 0.30127f, + 0.449951f, 0.929932f, 0.232178f, 0.717773f, 0.548096f, 0.644775f, 0.59082f, 0.77417f, 0.458252f, 0.560059f, 0.117432f, 0.007324f, 0.630859f, 0.096191f, 0.182617f, 0.905273f, + 0.848389f, 0.587158f, 0.699707f, 0.390137f, 0.618896f, 0.597656f, 0.812744f, 0.998291f, 0.590576f, 0.991699f, 0.838379f, 0.331543f, 0.166504f, 0.993164f, 0.525391f, 0.811768f, + 0.629639f, 0.312744f, 0.2854f, 0.608643f, 0.512939f, 0.621094f, 0.953369f, 0.965576f, 0.223633f, 0.29541f, 0.133301f, 0.267334f, 0.678223f, 0.439941f, 0.01001f, 0.693604f, + 0.619629f, 0.306641f, 0.47583f, 0.952637f, 0.074951f, 0.218262f, 0.873047f, 0.469238f, 0.236328f, 0.791992f, 0.310303f, 0.355957f, 0.450928f, 0.27417f, 0.509033f, 0.421143f, + 0.683105f, 0.8396f, 0.466309f, 0.986084f, 0.516602f, 0.691895f, 0.105713f, 0.724854f, 0.695068f, 0.026123f, 0.579834f, 0.617432f, 0.107666f, 0.208984f, 0.496338f, 0.673584f, + 0.448242f, 0.940674f, 0.999756f, 0.384521f, 0.053955f, 0.807373f, 0.165283f, 0.906006f, 0.838623f, 0.844482f, 0.335693f, 0.483643f, 0.133789f, 0.437012f, 0.778809f, 0.544434f, + 0.755859f, 0.508301f, 0.712402f, 0.705322f, 0.634033f, 0.129883f, 0.013672f, 0.377686f, 0.661133f, 0.456787f, 0.888672f, 0.947998f, 0.043701f, 0.356445f, 0.366699f, 0.470215f, + 0.17627f, 0.63916f, 0.239502f, 0.557373f, 0.342773f, 0.968506f, 0.185059f, 0.518311f, 0.378174f, 0.279053f, 0.663818f, 0.67334f, 0.001221f, 0.437744f, 0.188232f, 0.317383f, + 0.203369f, 0.252441f, 0.226318f, 0.188477f, 0.1604f, 0.703613f, 0.265381f, 0.940186f, 0.833252f, 0.636963f, 0.429932f, 0.638916f, 0.208008f, 0.968262f, 0.343262f, 0.130127f, + 0.650879f, 0.563965f, 0.689697f, 0.044434f, 0.387207f, 0.447021f, 0.773682f, 0.151611f, 0.463867f, 0.210693f, 0.889893f, 0.674316f, 0.261475f, 0.927734f, 0.90332f, 0.124268f, + 0.713867f, 0.234619f, 0.992432f, 0.119629f, 0.606689f, 0.183838f, 0.555176f, 0.266113f, 0.618652f, 0.4021f, 0.20459f, 0.083008f, 0.995117f, 0.226563f, 0.417725f, 0.633789f, + 0.581299f, 0.906494f, 0.948975f, 0.561523f, 0.679443f, 0.768555f, 0.095947f, 0.667725f, 0.376709f, 0.075928f, 0.827637f, 0.118164f, 0.502197f, 0.057129f, 0.871094f, 0.602051f, + 0.891113f, 0.206299f, 0.890381f, 0.581787f, 0.35376f, 0.371338f, 0.653809f, 0.834473f, 0.917236f, 0.856201f, 0.939941f, 0.273926f, 0.834961f, 0.322021f, 0.38208f, 0.990967f, + 0.28125f, 0.564453f, 0.633057f, 0.001709f, 0.61499f, 0.502686f, 0.838867f, 0.219238f, 0.266846f, 0.355225f, 0.0625f, 0.075195f, 0.703369f, 0.071045f, 0.907715f, 0.260254f, + 0.160645f, 0.216553f, 0.863281f, 0.277832f, 0.623535f, 0.883301f, 0.099609f, 0.197998f, 0.000977f, 0.590332f, 0.488037f, 0.259033f, 0.918213f, 0.427979f, 0.599854f, 0.263428f, + 0.913818f, 0.365723f, 0.327881f, 0.912842f, 0.837891f, 0.815186f, 0.255127f, 0.764893f, 0.760254f, 0.093506f, 0.73999f, 0.830322f, 0.067383f, 0.138428f, 0.535156f, 0.680664f, + 0.103516f, 0.817871f, 0.200928f, 0.929688f, 0.248535f, 0.180664f, 0.781982f, 0.966309f, 0.86084f, 0.469727f, 0.57666f, 0.436035f, 0.167236f, 0.975586f, 0.450439f, 0.027832f, + 0.897217f, 0.679688f, 0.666748f, 0.060303f, 0.131592f, 0.400879f, 0.125244f, 0.14209f, 0.706055f, 0.402588f, 0.963379f, 0.711182f, 0.831299f, 0.697998f, 0.898193f, 0.532959f, + 0.530273f, 0.356689f, 0.244873f, 0.837402f, 0.300049f, 0.440918f, 0.157227f, 0.911377f, 0.625f, 0.151367f, 0.917969f, 0.962646f, 0.179932f, 0.471191f, 0.286377f, 0.475586f, + 0.034668f, 0.748779f, 0.208496f, 0.124512f, 0.47168f, 0.742432f, 0.7771f, 0.812012f, 0.991943f, 0.344727f, 0.822021f, 0.729736f, 0.55957f, 0.276367f, 0.906982f, 0.449707f, + 0.06665f, 0.383301f, 0.769775f, 0.416504f, 0.654297f, 0.988525f, 0.358398f, 0.538086f, 0.401855f, 0.385986f, 0.225586f, 0.698975f, 0.90918f, 0.662598f, 0.061035f, 0.098145f, + 0.13623f, 0.244385f, 0.542969f, 0.827881f, 0.978271f, 0.723145f, 0.922607f, 0.008789f, 0.571533f, 0.491699f, 0.498535f, 0.687256f, 0.884033f, 0.311768f, 0.042236f, 0.958252f, + 0.60498f, 0.237061f, 0.122314f, 0.37793f, 0.575195f, 0.727295f, 0.950684f, 0.608398f, 0.231445f, 0.091064f, 0.630127f, 0.347168f, 0.973389f, 0.123779f, 0.817627f, 0.27832f, + 0.150391f, 0.765869f, 0.368408f, 0.793701f, 0.615723f, 0.012451f, 0.956299f, 0.749512f, 0.509521f, 0.529297f, 0.64917f, 0.291016f, 0.956543f, 0.33252f, 0.513672f, 0.916504f, + 0.012207f, 0.374512f, 0.932129f, 0.418945f, 0.607178f, 0.347656f, 0.825439f, 0.392578f, 0.667236f, 0.777344f, 0.123535f, 0.357422f, 0.967041f, 0.439209f, 0.248047f, 0.446289f, + 0.218506f, 0.445801f, 0.135742f, 0.905518f, 0.915283f, 0.515869f, 0.063477f, 0.740234f, 0.9104f, 0.462158f, 0.614746f, 0.996582f, 0.250488f, 0.368896f, 0.55542f, 0.51416f, + 0.102539f, 0.876953f, 0.464355f, 0.315186f, 0.333984f, 0.114258f, 0.110352f, 0.527832f, 0.296143f, 0.786377f, 0.605469f, 0.331787f, 0.377197f, 0.085449f, 0.549316f, 0.796875f, + 0.11084f, 0.204346f, 0.419678f, 0.105225f, 0.521973f, 0.772705f, 0.670654f, 0.84375f, 0.830078f, 0.635254f, 0.280518f, 0.886963f, 0.293701f, 0.473389f, 0.507813f, 0.775146f, + 0.813232f, 0.986572f, 0.042725f, 0.011475f, 0.134766f, 0.199463f, 0.906738f, 0.256836f, 0.044189f, 0.419922f, 0.815674f, 0.822998f, 0.977783f, 0.760498f, 0.541016f, 0.895508f, + 0.681641f, 0.528564f, 0.632813f, 0.813477f, 0.513428f, 0.373535f, 0.305664f, 0.299805f, 0.659912f, 0.460205f, 0.047363f, 0.333252f, 0.372314f, 0.073486f, 0.505127f, 0.771484f, + 0.336426f, 0.997803f, 0.158447f, 0.960938f, 0.3479f, 0.449463f, 0.502441f, 0.594238f, 0.13208f, 0.749756f, 0.941895f, 0.005859f, 0.304443f, 0.149902f, 0.564209f, 0.968018f, + 0.371826f, 0.199219f, 0.260498f, 0.609619f, 0.089355f, 0.019287f, 0.359131f, 0.41333f, 0.817383f, 0.32251f, 0.806152f, 0.176025f, 0.041748f, 0.555908f, 0.950928f, 0.20752f, + 0.898926f, 0.308594f, 0.367432f, 0.799805f, 0.792969f, 0.842041f, 0.742188f, 0.927979f, 0.952881f, 0.370361f, 0.53418f, 0.683594f, 0.380859f, 0.116699f, 0.827148f, 0.665771f, + 0.29248f, 0.270508f, 0.676514f, 0.230957f, 0.474609f, 0.600098f, 0.428955f, 0.901855f, 0.199707f, 0.315674f, 0.349854f, 0.93042f, 0.811035f, 0.077881f, 0.064941f, 0.527344f, + 0.427002f, 0.459961f, 0.308105f, 0.120605f, 0.46875f, 0.22583f, 0.944824f, 0.010498f, 0.718994f, 0.99707f, 0.726563f, 0.715576f, 0.493652f, 0.894287f, 0.338867f, 0.251221f, + 0.789795f, 0.197021f, 0.11499f, 0.603271f, 0.213135f, 0.357178f, 0.902832f, 0.658691f, 0.459229f, 0.224121f, 0.687988f, 0.595947f, 0.862061f, 0.085693f, 0.092041f, 0.360107f, + 0.347412f, 0.656738f, 0.379395f, 0.218018f, 0.753906f, 0.170166f, 0.390381f, 0.455566f, 0.858154f, 0.831787f, 0.779297f, 0.76001f, 0.027344f, 0.553467f, 0.328857f, 0.695801f, + 0.572266f, 0.443359f, 0.500977f, 0.189209f, 0.424316f, 0.178467f, 0.094238f, 0.013428f, 0.79248f, 0.181641f, 0.998047f, 0.501953f, 0.383057f, 0.079102f, 0.721924f, 0.12207f, + 0.870361f, 0.532227f, 0.424561f, 0.674805f, 0.192139f, 0.482422f, 0.306152f, 0.756836f, 0.493408f, 0.843506f, 0.765625f, 0.710449f, 0.321777f, 0.676025f, 0.164307f, 0.567627f, + 0.081543f, 0.490479f, 0.571045f, 0.943115f, 0.161621f, 0.330322f, 0.537842f, 0.114746f, 0.450195f, 0.006836f, 0.392334f, 0.053467f, 0.598633f, 0.977539f, 0.111572f, 0.098633f, + 0.511963f, 0.06958f, 0.387695f, 0.546143f, 0.941162f, 0.727051f, 0.490234f, 0.861084f, 0.928955f, 0.520508f, 0.115723f, 0.649658f, 0.642578f, 0.295166f, 0.965088f, 0.918457f, + 0.918945f, 0.163086f, 0.312012f, 0.462891f, 0.44751f, 0.420166f, 0.665527f, 0.211914f, 0.520996f, 0.846191f, 0.473633f, 0.77832f, 0.736572f, 0.091797f, 0.988281f, 0.436523f, + 0.040527f, 0.717529f, 0.318604f, 0.432617f, 0.01123f, 0.614258f, 0.810791f, 0.648682f, 0.56958f, 0.324707f, 0.75f, 0.947754f, 0.155273f, 0.788086f, 0.010742f, 0.249268f, + 0.144287f, 0.349609f, 0.520752f, 0.72998f, 0.806396f, 0.059326f, 0.303223f, 0.067139f, 0.421387f, 0.843994f, 0.637207f, 0.858643f, 0.814209f, 0.554932f, 0.251709f, 0.730469f, + 0.109619f, 0.630615f, 0.379883f, 0.456055f, 0.274902f, 0.349121f, 0.580811f, 0.723633f, 0.018066f, 0.54126f, 0.387939f, 0.039795f, 0.040771f, 0.960205f, 0.458984f, 0.343994f, + 0.141846f, 0.231934f, 0.01709f, 0.791748f, 0.931152f, 0.797852f, 0.731934f, 0.69458f, 0.691162f, 0.276855f, 0.785889f, 0.74585f, 0.942139f, 0.487793f, 0.228271f, 0.807861f, + 0.023926f, 0.88916f, 0.140625f, 0.232666f, 0.110107f, 0.315918f, 0.37207f, 0.582031f, 0.121582f, 0.180176f, 0.386475f, 0.058838f, 0.038086f, 0.731445f, 0.202637f, 0.574951f, + 0.446533f, 0.050293f, 0.542236f, 0.227051f, 0.194336f, 0.850098f, 0.857422f, 0.937744f, 0.886475f, 0.232422f, 0.542725f, 0.316162f, 0.880859f, 0.797607f, 0.575439f, 0.953613f, + 0.066895f, 0.657715f, 0.753174f, 0.283203f, 0.705811f, 0.541504f, 0.220703f, 0.701172f, 0.454102f, 0.032471f, 0.452393f, 0.409668f, 0.926514f, 0.903564f, 0.263672f, 0.7854f, + 0.422363f, 0.841064f, 0.410889f, 0.613281f, 0.004883f, 0.426758f, 0.106445f, 0.73877f, 0.291748f, 0.508545f, 0.578125f, 0.565674f, 0.480225f, 0.581055f, 0.415527f, 0.849854f, + 0.104004f, 0.184814f, 0.418213f, 0.628662f, 0.324219f, 0.348145f, 0.831543f, 0.63501f, 0.986816f, 0.583008f, 0.124756f, 0.710205f, 0.382813f, 0.545898f, 0.727539f, 0.890869f, + 0.869141f, 0.260986f, 0.170898f, 0.654785f, 0.801025f, 0.429443f, 0.442871f, 0.245117f, 0.756104f, 0.772949f, 0.577393f, 0.000488f, 0.631592f, 0.65918f, 0.048584f, 0.956787f, + 0.850342f, 0.15332f, 0.627197f, 0.026611f, 0.025146f, 0.522949f, 0.928711f, 0.507324f, 0.028809f, 0.518066f, 0.512207f, 0.031738f, 0.945068f, 0.369873f, 0.692139f, 0.10083f, + 0.752686f, 0.190674f, 0.51001f, 0.294922f, 0.741943f, 0.478271f, 0.757568f, 0.953857f, 0.23291f, 0f, 0.746094f, 0.831055f, 0.915039f, 0.738525f, 0.275391f, 0.069824f, + 0.35498f, 0.799561f, 0.611816f, 0.363037f, 0.101807f, 0.42334f, 0.934082f, 0.284668f, 0.859863f, 0.351807f, 0.652588f, 0.596191f, 0.519775f, 0.286865f, 0.451172f, 0.962158f, + 0.612549f, 0.587891f, 0.887939f, 0.431641f, 0.169922f, 0.302246f, 0.117676f, 0.725342f, 0.049805f, 0.869873f, 0.127686f, 0.677246f, 0.429688f, 0.458008f, 0.172852f, 0.804688f, + 0.308838f, 0.248779f, 0.491943f, 0.061279f, 0.037842f, 0.864746f, 0.326172f, 0.520264f, 0.925781f, 0.268311f, 0.412598f, 0.414551f, 0.352295f, 0.701904f, 0.866455f, 0.574219f, + 0.074463f, 0.718018f, 0.375732f, 0.704102f, 0.592285f, 0.397949f, 0.23999f, 0.341309f, 0.768066f, 0.019531f, 0.174805f, 0.945313f, 0.290283f, 0.865967f, 0.877441f, 0.029541f, + 0.478516f, 0.38916f, 0.827393f, 0.98291f, 0.868164f, 0.608154f, 0.18042f, 0.10376f, 0.257813f, 0.103027f, 0.902588f, 0.67041f, 0.100098f, 0.538818f, 0.045654f, 0.899658f, + 0.405518f, 0.220215f, 0.381836f, 0.187256f, 0.321045f, 0.987061f, 0.411133f, 0.761475f, 0.150146f, 0.809082f, 0.44043f, 0.45459f, 0.155762f, 0.800049f, 0.666016f, 0.084229f, + 0.810547f, 0.25708f, 0.278809f, 0.410645f, 0.949219f, 0.969971f, 0.948242f, 0.943604f, 0.298584f, 0.092773f, 0.370117f, 0.506836f, 0.499023f, 0.237793f, 0.739258f, 0.168701f, + 0.510742f, 0.900635f, 0.460938f, 0.908447f, 0.539063f, 0.531006f, 0.380615f, 0.230469f, 0.159912f, 0.014648f, 0.82373f, 0.931396f, 0.824951f, 0.166748f, 0.324463f, 0.517822f, + 0.536621f, 0.490723f, 0.279785f, 0.985352f, 0.165527f, 0.586914f, 0.226807f, 0.326416f, 0.604248f, 0.119873f, 0.148926f, 0.026855f, 0.689453f, 0.282471f, 0.631836f, 0.235596f, + 0.828613f, 0.225342f, 0.394531f, 0.877197f, 0.901123f, 0.169678f, 0.39917f, 0.646729f, 0.737793f, 0.021729f, 0.135498f, 0.011719f, 0.911133f, 0.554688f, 0.810303f, 0.954102f, + 0.339355f, 0.605225f, 0.361084f, 0.872803f, 0.360596f, 0.5f, 0.15918f, 0.162109f, 0.108398f, 0.47876f, 0.227783f, 0.343018f, 0.486816f, 0.916016f, 0.861816f, 0.938965f, + 0.174561f, 0.53833f, 0.078125f, 0.763428f, 0.75708f, 0.071533f, 0.45752f, 0.665039f, 0.194092f, 0.567383f, 0.270752f, 0.859619f, 0.79126f, 0.61792f, 0.888916f, 0.165771f, + 0.202881f, 0.515625f, 0.486572f, 0.746826f, 0.470459f, 0.412842f, 0.714355f, 0.017578f, 0.396484f, 0.312256f, 0.311035f, 0.458496f, 0.41748f, 0.922363f, 0.64624f, 0.889648f, + 0.607666f, 0.946777f, 0.321289f, 0.445313f, 0.479004f, 0.825684f, 0.272217f, 0.301758f, 0.274414f, 0.212402f, 0.503662f, 0.484863f, 0.36499f, 0.112061f, 0.302734f, 0.097656f, + 0.499512f, 0.557617f, 0.742676f, 0.154541f, 0.280273f, 0.595215f, 0.689209f, 0.234375f, 0.24707f, 0.839844f, 0.215576f, 0.362061f, 0.853027f, 0.891846f, 0.262695f, 0.424805f, + 0.193604f, 0.856689f, 0.487549f, 0.190186f, 0.881592f, 0.155029f, 0.076172f, 0.201904f, 0.712158f, 0.296875f, 0.314697f, 0.223389f, 0.951904f, 0.416992f, 0.060791f, 0.310547f, + 0.981201f, 0.702881f, 0.540283f, 0.385254f, 0.297607f, 0.547852f, 0.168457f, 0.184082f, 0.87085f, 0.178223f, 0.685059f, 0.268555f, 0.088379f, 0.922852f, 0.418457f, 0.340576f, + 0.179688f, 0.808594f, 0.041504f, 0.380371f, 0.874268f, 0.131104f, 0.855713f, 0.934326f, 0.747803f, 0.820801f, 0.101074f, 0.920898f, 0.774414f, 0.963135f, 0.73291f, 0.746338f, + 0.728027f, 0.540039f, 0.207031f, 0.972412f, 0.983154f, 0.589844f, 0.5896f, 0.664063f, 0.919678f, 0.594482f, 0.174072f, 0.860596f, 0.551025f, 0.479736f, 0.889404f, 0.994629f, + 0.562256f, 0.188965f, 0.189697f, 0.007568f, 0.43042f, 0.780273f, 0.038818f, 0.148193f, 0.743164f, 0.579102f, 0.404785f, 0.354248f, 0.150635f, 0.362549f, 0.982178f, 0.345215f, + 0.619873f, 0.078857f, 0.212158f, 0.720703f, 0.233398f, 0.257568f, 0.697021f, 0.678955f, 0.748047f, 0.915527f, 0.497559f, 0.505371f, 0.160889f, 0.240479f, 0.718262f, 0.992676f, + 0.021973f, 0.05249f, 0.83374f, 0.851563f, 0.138184f, 0.42749f, 0.104492f, 0.644043f, 0.584229f, 0.001953f, 0.991211f, 0.489502f, 0.932373f, 0.511719f, 0.862305f, 0.30957f, + 0.068604f, 0.843018f, 0.959229f, 0.046875f, 0.823486f, 0.754395f, 0.560547f, 0.672363f, 0.028564f, 0.07373f, 0.346924f, 0.860352f, 0.731689f, 0.596924f, 0.539551f, 0.982422f, + 0.945801f, 0.679199f, 0.481934f, 0.348389f, 0.477539f, 0.991455f, 0.794922f, 0.663574f, 0.490967f, 0.812256f, 0.476563f, 0.047119f, 0.892578f, 0.888184f, 0.793213f, 0.033691f, + 0.3125f, 0.523193f, 0.883057f, 0.334473f, 0.492188f, 0.006348f, 0.990723f, 0.084961f, 0.757813f, 0.49707f, 0.172119f, 0.202148f, 0.709961f, 0.624023f, 0.275635f, 0.432129f, + 0.75293f, 0.974854f, 0.438232f, 0.164063f, 0.388916f, 0.960693f, 0.878662f, 0.802734f, 0.192383f, 0.824707f, 0.977295f, 0.309082f, 0.513916f, 0.5979f, 0.305908f, 0.390869f, + 0.447266f, 0.35791f, 0.75415f, 0.120117f, 0.203125f, 0.113525f, 0.0896f, 0.688477f, 0.335938f, 0.537109f, 0.572754f, 0.091309f, 0.098877f, 0.235107f, 0.956055f, 0.833008f, + 0.196777f, 0.010254f, 0.955078f, 0.080322f, 0.390625f, 0.668457f, 0.701416f, 0.643555f, 0.601807f, 0.772217f, 0.035645f, 0.292236f, 0.196289f, 0.375977f, 0.967529f, 0.398682f, + 0.732666f, 0.225098f, 0.393066f, 0.682129f, 0.938721f, 0.722168f, 0.907959f, 0.719727f, 0.681396f, 0.980957f, 0.594727f, 0.454834f, 0.53125f, 0.222412f, 0.717285f, 0.845459f, + 0.892822f, 0.642334f, 0.479248f, 0.936523f, 0.083252f, 0.879395f, 0.856934f, 0.422852f, 0.442627f, 0.15625f, 0.849609f, 0.076416f, 0.550049f, 0.86499f, 0.926025f, 0.568115f, + 0.989258f, 0.70874f, 0.578613f, 0.896484f, 0.805908f, 0.941406f, 0.778076f, 0.745117f, 0.688232f, 0.416016f, 0.24585f, 0.652832f, 0.169189f, 0.571777f, 0.459473f, 0.02417f, + 0.879883f, 0.861328f, 0.319336f, 0.146484f, 0.700928f, 0.240234f, 0.154297f, 0.197266f, 0.472656f, 0.651367f, 0.716309f, 0.854736f, 0.544189f, 0.052246f, 0.981934f, 0.372559f, + 0.266357f, 0.272705f, 0.035889f, 0.290771f, 0.741699f, 0.359375f, 0.566162f, 0.293457f, 0.431396f, 0.167725f, 0.970947f, 0.266602f, 0.875977f, 0.425049f, 0.743652f, 0.935059f, + 0.173096f, 0.634521f, 0.677002f, 0.92749f, 0.988037f, 0.112793f, 0.494629f, 0.70752f, 0.08667f, 0.089111f, 0.943359f, 0.613037f, 0.776123f, 0.832275f, 0.04541f, 0.824219f, + 0.062744f, 0.415771f, 0.206787f, 0.569824f, 0.50708f, 0.473145f, 0.401123f, 0.438477f, 0.345459f, 0.217773f, 0.033936f, 0.865479f, 0.376465f, 0.676758f, 0.330078f, 0.973145f, + 0.516357f, 0.39502f, 0.464844f, 0.240723f, 0.967285f, 0.231689f, 0.022217f, 0.766357f, 0.776855f, 0.216309f, 0.30542f, 0.158203f, 0.019043f, 0.841309f, 0.054688f, 0.131348f, + 0.270264f, 0.51123f, 0.073975f, 0.671631f, 0.718506f, 0.70166f, 0.009521f, 0.980713f, 0.355713f, 0.822266f, 0.023682f, 0.781006f, 0.973877f, 0.509277f, 0.288574f, 0.03418f, + 0.500732f, 0.176514f, 0.96875f, 0.678467f, 0.334961f, 0.779541f, 0.985596f, 0.726807f, 0.006104f, 0.647705f, 0.928223f, 0.979492f, 0.477783f, 0.130371f, 0.209473f, 0.695313f, + 0.311523f, 0.382324f, 0.504395f, 0.521729f, 0.147461f, 0.909668f, 0.585938f, 0.674561f, 0.74707f, 0.041016f, 0.207275f, 0.323486f, 0.558838f, 0.891357f, 0.526123f, 0.722656f, + 0.98584f, 0.48877f, 0.961914f, 0.481689f, 0.801514f, 0.180908f, 0.78833f, 0.758057f, 0.891602f, 0.563477f, 0.466553f, 0.552002f, 0.760742f, 0.577148f, 0.705078f, 0.314941f, + 0.852783f, 0.323975f, 0.738281f, 0.297363f, 0.136963f, 0.512695f, 0.356934f, 0.210205f, 0.378662f, 0.848877f, 0.411621f, 0.97876f, 0.723877f, 0.14917f, 0.635498f, 0.734619f, + 0.779053f, 0.533447f, 0.610596f, 0.396729f, 0.24292f, 0.44873f, 0.251953f, 0.838135f, 0.695557f, 0.499756f, 0.935791f, 0.788574f, 0.247314f, 0.530518f, 0.524902f, 0.137695f, + 0.231201f, 0.216797f, 0.130615f, 0.436768f, 0.980225f, 0.556641f, 0.807129f, 0.927246f, 0.927002f, 0.446777f, 0.599609f, 0.86792f, 0.969238f, 0.217285f, 0.792725f, 0.219971f, + 0.444824f, 0.878906f, 0.996094f, 0.540527f, 0.341064f, 0.04834f, 0.688721f, 0.744629f, 0.604736f, 0.584473f, 0.700439f, 0.44458f, 0.037109f, 0.136719f, 0.131836f, 0.237305f, + 0.756348f, 0.422607f, 0.901611f, 0.735107f, 0.568359f, 0.756592f, 0.410156f, 0.649414f, 0.875244f, 0.090576f, 0.876465f, 0.191162f, 0.626953f, 0.373779f, 0.864258f, 0.051514f, + 0.999512f, 0.763672f, 0.994141f, 0.374756f, 0.911865f, 0.179199f, 0.415283f, 0.046143f, 0.381104f, 0.518555f, 0.675293f, 0.926758f, 0.26001f, 0.95166f, 0.608887f, 0.488525f, + 0.580566f, 0.932861f, 0.87915f, 0.318115f, 0.613525f, 0.043945f, 0.040283f, 0.719238f, 0.353516f, 0.647461f, 0.570557f, 0.994385f, 0.602783f, 0.825928f, 0.394043f, 0.003662f, + 0.951172f, 0.818848f, 0.786865f, 0.528809f, 0.750488f, 0.255859f, 0.154053f, 0.876709f, 0.154785f, 0.485107f, 0.007813f, 0.453613f, 0.034424f, 0.932617f, 0.897949f, 0.558105f, + 0.030762f, 0.17334f, 0.753418f, 0.403809f, 0.434326f, 0.137207f, 0.282227f, 0.080078f, 0.849121f, 0.71167f, 0.065186f, 0.090332f, 0.925293f, 0.883545f, 0.456299f, 0.573242f, + 0.583252f, 0.325439f, 0.074219f, 0.047852f, 0.392822f, 0.984863f, 0.330811f, 0.560791f, 0.44165f, 0.23584f, 0.559814f, 0.395752f, 0.234131f, 0.733643f, 0.52002f, 0.833984f, + 0.76416f, 0.129639f, 0.446045f, 0.639404f, 0.068848f, 0.024414f, 0.478027f, 0.112549f, 0.276611f, 0.27002f, 0.844971f, 0.527588f, 0.566895f, 0.804199f, 0.896973f, 0.183594f, + 0.631104f, 0.924072f, 0.246826f, 0.094727f, 0.304932f, 0.781738f, 0.118408f, 0.842529f, 0.269775f, 0.014404f, 0.626465f, 0.767822f, 0.729492f, 0.190918f, 0.544922f, 0.564697f, + 0.99292f, 0.317627f, 0.024658f, 0.925537f, 0.414063f, 0.58374f, 0.569092f, 0.143066f, 0.655762f, 0.759766f, 0.799316f, 0.056885f, 0.273438f, 0.882813f, 0.281494f, 0.795166f, + 0.020264f, 0.066162f, 0.523438f, 0.238037f, 0.880127f, 0.157959f, 0.236816f, 0.992188f, 0.924561f, 0.578857f, 0.498291f, 0.130859f, 0.344238f, 0.9646f, 0.798584f, 0.672119f, + 0.62207f, 0.794189f, 0.661621f, 0.474121f, 0.399414f, 0.842285f, 0.16626f, 0.220459f, 0.640869f, 0.351318f, 0.764404f, 0.202393f, 0.726318f, 0.498779f, 0.959473f, 0.395996f, + 0.929199f, 0.415039f, 0.246094f, 0.301025f, 0.516846f, 0.164795f, 0.141357f, 0.789307f, 0.286621f, 0.343506f, 0.625977f, 0.147949f, 0.654541f, 0.279297f, 0.770508f, 0.9375f, + 0.282715f, 0.205322f, 0.833496f, 0.665283f, 0.751953f, 0.964355f, 0.462402f, 0.18457f, 0.195313f, 0.557129f, 0.791016f, 0.882568f, 0.61084f, 0.004395f, 0.787598f, 0.556396f, + 0.209717f, 0.408203f, 0.816895f, 0.373047f, 0.369629f, 0.344971f, 0.870605f, 0.12085f, 0.987305f, 0.118652f, 0.658203f, 0.873779f, 0.292969f, 0.692627f, 0.568604f, 0.922119f, + 0.469971f, 0.575928f, 0.985107f, 0.28833f, 0.192627f, 0.437256f, 0.414795f, 0.628906f, 0.647217f, 0.540771f, 0.111816f, 0.342041f, 0.420898f, 0.767334f, 0.224365f, 0.739502f, + 0.843262f, 0.894531f, 0.91626f, 0.820068f, 0.564941f, 0.256348f, 0.23877f, 0.386963f, 0.960449f, 0.28418f, 0.38501f, 0.6875f, 0.683838f, 0.275879f, 0.945557f, 0.936768f, + 0.032227f, 0.60791f, 0.062988f, 0.322998f, 0.241455f, 0.818115f, 0.567139f, 0.973633f, 0.829102f, 0.938477f, 0.046631f, 0.962402f, 0.576172f, 0.309326f, 0.97998f, 0.176758f, + 0.421631f, 0.329102f, 0.31543f, 0.333008f, 0.160156f, 0.455078f, 0.562744f, 0.417969f, 0.898438f, 0.771973f, 0.72583f, 0.159424f, 0.254395f, 0.441162f, 0.371582f, 0.102295f, + 0.151123f, 0.468262f, 0.637451f, 0.087158f, 0.405273f, 0.063721f, 0.155518f, 0.40332f, 0.989746f, 0.957031f, 0.137939f, 0.543213f, 0.428223f, 0.054443f, 0.872559f, 0.823975f, + 0.81543f, 0.609131f, 0.912109f, 0.806885f, 0.067871f, 0.556152f, 0.92334f, 0.769531f, 0.618164f, 0.05542f, 0.803223f, 0.156982f, 0.262939f, 0.693848f, 0.894775f, 0.270996f, + 0.463135f, 0.998779f, 0.845215f, 0.149414f, 0.081055f, 0.253174f, 0.037598f, 0.842773f, 0.526855f, 0.306396f, 0.068359f, 0.078613f, 0.211426f, 0.508057f, 0.295898f, 0.496826f, + 0.374268f, 0.234863f, 0.83252f, 0.489258f, 0.140137f, 0.193848f, 0.029053f, 0.798828f, 0.914063f, 0.086426f, 0.866211f, 0.85791f, 0.914795f, 0.554443f, 0.285645f, 0.135986f, + ]; +} diff --git a/Source.Particles/Sheet.cs b/Source.Particles/Sheet.cs new file mode 100644 index 00000000..e1d9c7a3 --- /dev/null +++ b/Source.Particles/Sheet.cs @@ -0,0 +1,231 @@ +using System.Buffers.Binary; +using System.Runtime.CompilerServices; + +namespace Source.Particles; + +public struct SequenceSampleTextureCoords +{ + public float LeftU0; + public float TopV0; + public float RightU0; + public float BottomV0; + + public float LeftU1; + public float TopV1; + public float RightU1; + public float BottomV1; +} + +[InlineArray(Sheet.MAX_IMAGES_PER_FRAME_IN_MEMORY)] +public struct SequenceSampleTextureCoordsArray +{ + SequenceSampleTextureCoords Element; +} + +public struct SheetSequenceSample +{ + public SequenceSampleTextureCoordsArray TextureCoordData; + public float BlendFactor; +} + +public sealed class Sheet +{ + public const int MAX_SEQUENCES = 64; + public const int SEQUENCE_SAMPLE_COUNT = 1024; + public const int MAX_IMAGES_PER_FRAME_ON_DISK = 4; + public const int MAX_IMAGES_PER_FRAME_IN_MEMORY = 2; + + public readonly SheetSequenceSample[]?[] Samples = new SheetSequenceSample[]?[MAX_SEQUENCES]; + public readonly bool[] Clamp = new bool[MAX_SEQUENCES]; + public readonly bool[] SequenceIsCopyOfAnotherSequence = new bool[MAX_SEQUENCES]; + public readonly int[] NumFrames = new int[MAX_SEQUENCES]; + public readonly float[] FrameSpan = new float[MAX_SEQUENCES]; + + ref struct Reader(ReadOnlySpan data) + { + readonly ReadOnlySpan Data = data; + int Position; + + public int GetInt() { + if (Position + 4 > Data.Length) + return 0; + int value = BinaryPrimitives.ReadInt32LittleEndian(Data[Position..]); + Position += 4; + return value; + } + + public float GetFloat() { + if (Position + 4 > Data.Length) + return 0; + float value = BinaryPrimitives.ReadSingleLittleEndian(Data[Position..]); + Position += 4; + return value; + } + } + + public Sheet(ReadOnlySpan data) { + Reader buf = new(data); + + int version = buf.GetInt(); + int numCoordsPerFrame = version != 0 ? MAX_IMAGES_PER_FRAME_ON_DISK : 1; + + int numSequences = buf.GetInt(); + + float[] interpKnot = new float[SEQUENCE_SAMPLE_COUNT]; + float[] interpValue = new float[SEQUENCE_SAMPLE_COUNT]; + SheetSequenceSample[] samples = new SheetSequenceSample[SEQUENCE_SAMPLE_COUNT]; + + while (numSequences-- != 0) { + int sequenceNumber = buf.GetInt(); + if ((uint)sequenceNumber >= MAX_SEQUENCES) { + Warning($"sequence number {sequenceNumber} too high in sheet file!!!\n"); + return; + } + + Clamp[sequenceNumber] = buf.GetInt() != 0; + int frameCount = buf.GetInt(); + NumFrames[sequenceNumber] = frameCount; + + int timeSamples = frameCount == 1 ? 1 : SEQUENCE_SAMPLE_COUNT; + SheetSequenceSample[] outSamples = new SheetSequenceSample[timeSamples]; + Samples[sequenceNumber] = outSamples; + + int totalSequenceTime = (int)buf.GetFloat(); + float curTime = 0.0f; + for (int frame = 0; frame < frameCount && frame < SEQUENCE_SAMPLE_COUNT; frame++) { + float thisDuration = buf.GetFloat(); + interpValue[frame] = frame; + interpKnot[frame] = SEQUENCE_SAMPLE_COUNT / (float)totalSequenceTime * curTime; + + ref SheetSequenceSample seq = ref samples[frame]; + seq.BlendFactor = 0.0f; + for (int image = 0; image < numCoordsPerFrame; image++) { + float left = buf.GetFloat(); + float top = buf.GetFloat(); + float right = buf.GetFloat(); + float bottom = buf.GetFloat(); + if (image >= MAX_IMAGES_PER_FRAME_IN_MEMORY) + continue; + + ref SequenceSampleTextureCoords s = ref seq.TextureCoordData[image]; + s.LeftU0 = left; + s.TopV0 = top; + s.RightU0 = right; + s.BottomV0 = bottom; + } + + if (numCoordsPerFrame == 1) + seq.TextureCoordData[1] = seq.TextureCoordData[0]; + + curTime += thisDuration; + FrameSpan[sequenceNumber] = curTime; + } + + if (frameCount <= 0) + continue; + + int knots = Math.Min(frameCount, SEQUENCE_SAMPLE_COUNT); + for (int idx = 0; idx < timeSamples; idx++) { + GetInterpolationData(interpKnot, interpValue, knots, SEQUENCE_SAMPLE_COUNT, idx, !Clamp[sequenceNumber], out float idxA, out float idxB, out float interp); + ref SheetSequenceSample sA = ref samples[(int)idxA]; + ref SheetSequenceSample sB = ref samples[(int)idxB]; + ref SheetSequenceSample oseq = ref outSamples[idx]; + + oseq.BlendFactor = interp; + for (int image = 0; image < MAX_IMAGES_PER_FRAME_IN_MEMORY; image++) { + ref SequenceSampleTextureCoords src0 = ref sA.TextureCoordData[image]; + ref SequenceSampleTextureCoords src1 = ref sB.TextureCoordData[image]; + ref SequenceSampleTextureCoords o = ref oseq.TextureCoordData[image]; + o.LeftU0 = src0.LeftU0; + o.TopV0 = src0.TopV0; + o.RightU0 = src0.RightU0; + o.BottomV0 = src0.BottomV0; + o.LeftU1 = src1.LeftU0; + o.TopV1 = src1.TopV0; + o.RightU1 = src1.RightU0; + o.BottomV1 = src1.BottomV0; + } + } + } + + for (int first = 0; first < MAX_SEQUENCES; first++) { + if (Samples[first] == null) + continue; + + for (int i = 0; i < MAX_SEQUENCES; i++) { + if (Samples[i] != null) + continue; + + Samples[i] = Samples[first]; + Clamp[i] = Clamp[first]; + NumFrames[i] = NumFrames[first]; + SequenceIsCopyOfAnotherSequence[i] = true; + } + break; + } + } + + static void GetInterpolationData(ReadOnlySpan knotPositions, ReadOnlySpan knotValues, int numValuesInList, int interpolationRange, float positionToInterpolateAt, bool wrap, out float valueA, out float valueB, out float interpolationValue) { + int idx; + for (idx = 0; idx < numValuesInList; idx++) { + if (knotPositions[idx] >= positionToInterpolateAt) + break; + } + + int knot1, knot2; + float offsetFromStartOfGap, sizeOfGap; + if (idx == 0) { + if (wrap) { + knot1 = numValuesInList - 1; + knot2 = 0; + sizeOfGap = knotPositions[knot2] + (interpolationRange - knotPositions[knot1]); + offsetFromStartOfGap = positionToInterpolateAt + (interpolationRange - knotPositions[knot1]); + } + else { + valueA = valueB = knotValues[0]; + interpolationValue = 1.0f; + return; + } + } + else if (idx == numValuesInList) { + if (wrap) { + knot1 = numValuesInList - 1; + knot2 = 0; + sizeOfGap = knotPositions[knot2] + (interpolationRange - knotPositions[knot1]); + offsetFromStartOfGap = positionToInterpolateAt - knotPositions[knot1]; + } + else { + valueA = valueB = knotValues[numValuesInList - 1]; + interpolationValue = 1.0f; + return; + } + } + else { + knot1 = idx - 1; + knot2 = idx; + sizeOfGap = knotPositions[knot2] - knotPositions[knot1]; + offsetFromStartOfGap = positionToInterpolateAt - knotPositions[knot1]; + } + + valueA = knotValues[knot1]; + valueB = knotValues[knot2]; + interpolationValue = offsetFromStartOfGap / sizeOfGap; + } + + public static ref readonly SheetSequenceSample GetSampleForSequence(Sheet? sheet, float creationTime, float curTime, float ageScale, int sequence) { + if (sheet == null) + return ref Unsafe.NullRef(); + + SheetSequenceSample[]? samples = sheet.Samples[sequence]; + if (samples == null) + return ref Unsafe.NullRef(); + if (sheet.NumFrames[sequence] == 1) + return ref samples[0]; + + uint frame = (uint)(long)((curTime - creationTime) * ageScale); + uint index = frame & 0x3FF; + if (sheet.Clamp[sequence]) + index = frame < 0x400 ? frame : 0x3FF; + return ref samples[index]; + } +} diff --git a/Source.Particles/Source.Particles.csproj b/Source.Particles/Source.Particles.csproj new file mode 100644 index 00000000..fa070bcd --- /dev/null +++ b/Source.Particles/Source.Particles.csproj @@ -0,0 +1,14 @@ + + + true + + + + + + + + + + + diff --git a/Source.StdShader.Gl46/Spritecard.cs b/Source.StdShader.Gl46/Spritecard.cs new file mode 100644 index 00000000..0cc518e1 --- /dev/null +++ b/Source.StdShader.Gl46/Spritecard.cs @@ -0,0 +1,252 @@ +using Source.Common; +using Source.Common.Commands; +using Source.Common.MaterialSystem; +using Source.Common.ShaderAPI; +using Source.Common.ShaderLib; + +namespace Source.StdShader.Gl46; + +public class Spritecard : BaseVSShader +{ + public static string HelpString = "Help for Spritecard"; + public static ShaderFlags Flags = ShaderFlags.NotEditable; + public static List ShaderParams = []; + public static ShaderParam[] ShaderParamOverrides = new ShaderParam[(int)ShaderMaterialVars.Count]; + + public class ShaderParam + { + public readonly ShaderParamInfo Info; + public readonly int Index; + public ShaderParam(string name, ShaderParamType type, ReadOnlySpan defaultParam, ReadOnlySpan help, ShaderParamFlags flags = 0) { + Info.Name = name; + Info.Type = type; + Info.DefaultValue = new(defaultParam); + Info.Help = new(help); + Info.Flags = flags; + Index = (int)ShaderMaterialVars.Count + ShaderParams.Count; + ShaderParams.Add(this); + } + public static implicit operator int(ShaderParam param) => param.Index; + public ReadOnlySpan GetName() => Info.Name; + public ShaderParamType GetType() => Info.Type; + public ReadOnlySpan GetDefaultValue() => Info.DefaultValue; + public ShaderParamFlags GetFlags() => Info.Flags; + public ReadOnlySpan GetHelp() => Info.Help; + } + + public static readonly ShaderParam DEPTHBLEND = new($"${nameof(DEPTHBLEND)}", ShaderParamType.Integer, "0", "fade at intersection boundaries"); + public static readonly ShaderParam DEPTHBLENDSCALE = new($"${nameof(DEPTHBLENDSCALE)}", ShaderParamType.Float, "50.0", "Amplify or reduce DEPTHBLEND fading. Lower values make harder edges."); + public static readonly ShaderParam ORIENTATION = new($"${nameof(ORIENTATION)}", ShaderParamType.Integer, "0", "0 = always face camera, 1 = rotate around z, 2= parallel to ground"); + public static readonly ShaderParam ADDBASETEXTURE2 = new($"${nameof(ADDBASETEXTURE2)}", ShaderParamType.Float, "0.0", "amount to blend second texture into frame by"); + public static readonly ShaderParam OVERBRIGHTFACTOR = new($"${nameof(OVERBRIGHTFACTOR)}", ShaderParamType.Float, "1.0", "overbright factor for texture. For HDR effects."); + public static readonly ShaderParam DUALSEQUENCE = new($"${nameof(DUALSEQUENCE)}", ShaderParamType.Integer, "0", "blend two separate animated sequences."); + public static readonly ShaderParam SEQUENCE_BLEND_MODE = new($"${nameof(SEQUENCE_BLEND_MODE)}", ShaderParamType.Integer, "0", "defines the blend mode between the images un dual sequence particles. 0 = avg, 1=alpha from first, rgb from 2nd, 2= first over second"); + public static readonly ShaderParam MAXLUMFRAMEBLEND1 = new($"${nameof(MAXLUMFRAMEBLEND1)}", ShaderParamType.Integer, "0", "instead of blending between animation frames for the first sequence, select pixels based upon max luminance"); + public static readonly ShaderParam MAXLUMFRAMEBLEND2 = new($"${nameof(MAXLUMFRAMEBLEND2)}", ShaderParamType.Integer, "0", "instead of blending between animation frames for the 2nd sequence, select pixels based upon max luminance"); + public static readonly ShaderParam RAMPTEXTURE = new($"${nameof(RAMPTEXTURE)}", ShaderParamType.Texture, "", "if specified, then the red value of the image is used to index this ramp to produce the output color"); + public static readonly ShaderParam ZOOMANIMATESEQ2 = new($"${nameof(ZOOMANIMATESEQ2)}", ShaderParamType.Float, "1.0", "amount to gradually zoom between frames on the second sequence. 2.0 will double the size of a frame over its lifetime."); + public static readonly ShaderParam EXTRACTGREENALPHA = new($"${nameof(EXTRACTGREENALPHA)}", ShaderParamType.Integer, "0", "grayscale data sitting in green/alpha channels"); + public static readonly ShaderParam ADDOVERBLEND = new($"${nameof(ADDOVERBLEND)}", ShaderParamType.Integer, "0", "use ONE:INVSRCALPHA blending"); + public static readonly ShaderParam ADDSELF = new($"${nameof(ADDSELF)}", ShaderParamType.Float, "0.0", "amount of base texture to additively blend in"); + public static readonly ShaderParam BLENDFRAMES = new($"${nameof(BLENDFRAMES)}", ShaderParamType.Bool, "1", "whether or not to smoothly blend between animated frames"); + public static readonly ShaderParam MINSIZE = new($"${nameof(MINSIZE)}", ShaderParamType.Float, "0.0", "minimum screen fractional size of particle"); + public static readonly ShaderParam STARTFADESIZE = new($"${nameof(STARTFADESIZE)}", ShaderParamType.Float, "10.0", "screen fractional size to start fading particle out"); + public static readonly ShaderParam ENDFADESIZE = new($"${nameof(ENDFADESIZE)}", ShaderParamType.Float, "20.0", "screen fractional size to finish fading particle out"); + public static readonly ShaderParam MAXSIZE = new($"${nameof(MAXSIZE)}", ShaderParamType.Float, "20.0", "maximum screen fractional size of particle"); + public static readonly ShaderParam USEINSTANCING = new($"${nameof(USEINSTANCING)}", ShaderParamType.Bool, "1", "whether to use GPU vertex instancing (submit 1 vert per particle quad)"); + public static readonly ShaderParam SPLINETYPE = new($"${nameof(SPLINETYPE)}", ShaderParamType.Integer, "0", "spline type 0 = none, 1=ctamull rom"); + public static readonly ShaderParam MAXDISTANCE = new($"${nameof(MAXDISTANCE)}", ShaderParamType.Float, "100000.0", "maximum distance to draw particles at"); + public static readonly ShaderParam FARFADEINTERVAL = new($"${nameof(FARFADEINTERVAL)}", ShaderParamType.Float, "400.0", "interval over which to fade out far away particles"); + + static readonly ConVarRef mat_reduceparticles = new("mat_reduceparticles"); + + static readonly int[] TexCoordSize = [4, 4, 4, 2, 4, 4, 4, 4]; + static readonly int[] TexCoordSizeSpline = [4, 4, 4, 4, 4, 4, 4, 4]; + + public override string? GetFallbackShader(IMaterialVar[] vars) => null; + public override ShaderFlags GetFlags() => Flags; + public override int GetNumParams() => base.GetNumParams() + ShaderParams.Count; + public override ReadOnlySpan GetParamName(int paramIndex) { + int baseClassParamCount = base.GetNumParams(); + if (paramIndex < baseClassParamCount) + return base.GetParamName(paramIndex); + else + return ShaderParams[paramIndex - baseClassParamCount].GetName(); + } + public override ReadOnlySpan GetParamHelp(int paramIndex) { + int baseClassParamCount = base.GetNumParams(); + if (paramIndex < baseClassParamCount) + return base.GetParamHelp(paramIndex); + else + return ShaderParams[paramIndex - baseClassParamCount].GetHelp(); + } + public override ShaderParamType GetParamType(int paramIndex) { + int baseClassParamCount = base.GetNumParams(); + if (paramIndex < baseClassParamCount) + return base.GetParamType(paramIndex); + else + return ShaderParams[paramIndex - baseClassParamCount].GetType(); + } + public override ReadOnlySpan GetParamDefault(int paramIndex) { + int baseClassParamCount = base.GetNumParams(); + if (paramIndex < baseClassParamCount) + return base.GetParamDefault(paramIndex); + else + return ShaderParams[paramIndex - baseClassParamCount].GetDefaultValue(); + } + + static int GetDefaultDepthFeatheringValue() => mat_reduceparticles.GetBool() ? 0 : 1; + + protected override void OnInitShaderParams(IMaterialVar[] parms, ReadOnlySpan materialName) { + InitFloatParam(MAXDISTANCE, parms, 100000.0f); + InitFloatParam(FARFADEINTERVAL, parms, 400.0f); + InitFloatParam(MAXSIZE, parms, 20.0f); + InitFloatParam(ENDFADESIZE, parms, 20.0f); + InitFloatParam(STARTFADESIZE, parms, 10.0f); + InitFloatParam(DEPTHBLENDSCALE, parms, 50.0f); + InitFloatParam(OVERBRIGHTFACTOR, parms, 1.0f); + InitFloatParam(ADDBASETEXTURE2, parms, 0.0f); + InitFloatParam(ADDSELF, parms, 0.0f); + InitFloatParam(ZOOMANIMATESEQ2, parms, 0.0f); + + if (!parms[DEPTHBLEND].IsDefined()) + parms[DEPTHBLEND].SetIntValue(GetDefaultDepthFeatheringValue()); + + InitIntParam(DUALSEQUENCE, parms, 0); + InitIntParam(MAXLUMFRAMEBLEND1, parms, 0); + InitIntParam(MAXLUMFRAMEBLEND2, parms, 0); + InitIntParam(EXTRACTGREENALPHA, parms, 0); + InitIntParam(ADDOVERBLEND, parms, 0); + InitIntParam(BLENDFRAMES, parms, 1); + InitIntParam(USEINSTANCING, parms, 0); + + SetFlags2(parms, MaterialVarFlags2.IsSpritecard); + } + + protected override void OnInitShaderInstance(IMaterialVar[] parms, ReadOnlySpan materialName) { + SetFlags2(parms, MaterialVarFlags2.LightingVertexLit); + + if (parms[(int)ShaderMaterialVars.BaseTexture].IsDefined()) { + bool extractGreenAlpha = false; + if (parms[EXTRACTGREENALPHA].IsDefined()) + extractGreenAlpha = parms[EXTRACTGREENALPHA].GetIntValue() != 0; + + LoadTexture((int)ShaderMaterialVars.BaseTexture, !extractGreenAlpha ? (int)TextureFlags.SRGB : 0); + } + if (parms[RAMPTEXTURE].IsDefined()) + LoadTexture(RAMPTEXTURE, (int)TextureFlags.SRGB); + } + + protected override void OnDrawElements(IMaterialVar[] parms, IShaderDynamicAPI shaderAPI, VertexCompressionType vertexCompression) { + bool useRampTexture = parms[RAMPTEXTURE].IsDefined(); + bool zoomSeq2 = parms[ZOOMANIMATESEQ2].GetFloatValue() > 1.0f; + bool additive2ndTexture = parms[ADDBASETEXTURE2].GetFloatValue() != 0.0f; + int splineType = parms[SPLINETYPE].GetIntValue(); + + if (IsSnapshotting()) { + IShaderShadow shaderShadow = ShaderShadow!; + + bool secondSequence = parms[DUALSEQUENCE].GetIntValue() != 0; + bool addOverBlend = parms[ADDOVERBLEND].GetIntValue() != 0; + bool extractGreenAlpha = parms[EXTRACTGREENALPHA].GetIntValue() != 0; + bool blendFrames = parms[BLENDFRAMES].GetIntValue() != 0; + if (splineType != 0) + blendFrames = false; + bool addSelf = parms[ADDSELF].GetFloatValue() != 0.0f; + + shaderShadow.EnableCulling(false); + shaderShadow.EnableAlphaWrites(false); + shaderShadow.EnableTexture(Sampler.Sampler0, true); + + if (useRampTexture) { + shaderShadow.EnableTexture(Sampler.Sampler1, true); + shaderShadow.EnableSRGBRead(Sampler.Sampler1, true); + } + + shaderShadow.EnableAlphaTest(!(additive2ndTexture || addSelf)); + shaderShadow.AlphaFunc(ShaderAlphaFunc.Greater, 0.01f); + + if (additive2ndTexture || addOverBlend || addSelf) + EnableAlphaBlending(ShaderBlendFactor.One, ShaderBlendFactor.OneMinusSrcAlpha); + else if (IsFlagSet(parms, MaterialVarFlags.Additive)) + EnableAlphaBlending(ShaderBlendFactor.SrcAlpha, ShaderBlendFactor.One); + else + EnableAlphaBlending(ShaderBlendFactor.SrcAlpha, ShaderBlendFactor.OneMinusSrcAlpha); + + int numTexCoords = secondSequence ? 8 : 5; + shaderShadow.VertexShaderVertexFormat(VertexFormat.Position | VertexFormat.Color, numTexCoords, splineType != 0 ? TexCoordSizeSpline : TexCoordSize, 0); + + if (splineType != 0) + shaderShadow.SetVertexShader("splinecard", 0); + else { + StaticShaderIndex vshIndex = new(shaderShadow, ShaderType.Vertex, "spritecard"); + vshIndex.Set("DUALSEQUENCE", secondSequence); + vshIndex.Set("ZOOM_ANIMATE_SEQ2", zoomSeq2); + vshIndex.Set("EXTRACTGREENALPHA", extractGreenAlpha); + shaderShadow.SetVertexShader("spritecard", vshIndex.GetIndex()); + } + + StaticShaderIndex pshIndex = new(shaderShadow, ShaderType.Pixel, "spritecard"); + pshIndex.Set("ADDBASETEXTURE2", additive2ndTexture); + pshIndex.Set("ADDSELF", addSelf); + pshIndex.Set("ANIMBLEND", blendFrames); + pshIndex.Set("DUALSEQUENCE", secondSequence); + pshIndex.Set("SEQUENCE_BLEND_MODE", secondSequence ? parms[SEQUENCE_BLEND_MODE].GetIntValue() : 0); + pshIndex.Set("MAXLUMFRAMEBLEND1", parms[MAXLUMFRAMEBLEND1].GetIntValue()); + pshIndex.Set("MAXLUMFRAMEBLEND2", secondSequence ? parms[MAXLUMFRAMEBLEND1].GetIntValue() : 0); + pshIndex.Set("COLORRAMP", useRampTexture); + pshIndex.Set("EXTRACTGREENALPHA", extractGreenAlpha); + shaderShadow.SetPixelShader("spritecard", pshIndex.GetIndex()); + + shaderShadow.EnableSRGBWrite(true); + + if (!extractGreenAlpha) + shaderShadow.EnableSRGBRead(Sampler.Sampler0, true); + } + else { + BindTexture(Sampler.Sampler0, (int)ShaderMaterialVars.BaseTexture, (int)ShaderMaterialVars.Frame); + + if (useRampTexture) + BindTexture(Sampler.Sampler1, RAMPTEXTURE, (int)ShaderMaterialVars.Frame); + + int orientation = Math.Clamp(parms[ORIENTATION].GetIntValue(), 0, 2); + + if (zoomSeq2) { + float zScale = 1.0f / parms[ZOOMANIMATESEQ2].GetFloatValue(); + Span c0 = [0.5f * (1.0f + zScale), zScale, 0, 0]; + shaderAPI.SetVertexShaderConstant(VertexShaderConst.ShaderSpecificConst7, c0); + } + + float maxDistance = parms[MAXDISTANCE].GetFloatValue(); + float startFade = MathF.Max(1.0f, maxDistance - parms[FARFADEINTERVAL].GetFloatValue()); + + Span vc0 = [ + parms[MINSIZE].GetFloatValue(), parms[MAXSIZE].GetFloatValue(), + parms[STARTFADESIZE].GetFloatValue(), parms[ENDFADESIZE].GetFloatValue(), + startFade, 1.0f / (maxDistance - startFade), + 0, 0 + ]; + shaderAPI.SetVertexShaderConstant(VertexShaderConst.ShaderSpecificConst8, vc0, 2); + + Span pc0 = [ + parms[ADDBASETEXTURE2].GetFloatValue(), + parms[OVERBRIGHTFACTOR].GetFloatValue(), + parms[ADDSELF].GetFloatValue(), + 0.0f + ]; + shaderAPI.SetPixelShaderConstant(0, pc0); + + if (splineType != 0) + shaderAPI.SetVertexShaderIndex(0); + else { + DynamicShaderIndex vshIndex = new(shaderAPI, ShaderType.Vertex); + vshIndex.Set("ORIENTATION", orientation); + shaderAPI.SetVertexShaderIndex(vshIndex.GetIndex()); + } + + DynamicShaderIndex pshIndex = new(shaderAPI, ShaderType.Pixel); + shaderAPI.SetPixelShaderIndex(pshIndex.GetIndex()); + } + Draw(); + } +}