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