From 676a542113a9a9b952a2ad4944f39622ea19cf5c Mon Sep 17 00:00:00 2001
From: Earu <20880060+Earu@users.noreply.github.com>
Date: Tue, 17 Nov 2026 01:14:47 +0400
Subject: [PATCH 1/3] particles: core, sprite/rope/trail rendering, game glue
and the common operators
Particle system core, spritecard rendering and client/server glue, with the
41 particle functions used by at least 10 stock GMod systems. Remaining
operators, Lua bindings and particle tracers follow separately.
---
Directory.Packages.props | 1 +
Game.Assets/Assets.cs | 1 +
Game.Assets/sdn/shaders/splinecard_gl460.vs | 63 +
Game.Assets/sdn/shaders/spritecard_gl460.fs | 175 ++
Game.Assets/sdn/shaders/spritecard_gl460.vs | 212 +++
Game.Client/C_BaseAnimating.cs | 167 +-
Game.Client/C_BaseEntity.cs | 13 +-
Game.Client/C_BasePlayer.cs | 6 +
Game.Client/C_ParticleSystem.cs | 136 +-
Game.Client/C_TEEffectDispatch.cs | 49 +-
Game.Client/ClientEntityList.cs | 7 +
Game.Client/ClientModeShared.cs | 1 +
Game.Client/Game.Client.csproj | 1 +
Game.Client/HLClient.cs | 50 +-
Game.Client/IClientMode.cs | 1 +
Game.Client/NewParticleEffect.cs | 387 ++++
Game.Client/ParticleMgr.cs | 201 +-
Game.Client/ParticleProperty.cs | 400 ++++
Game.Client/ViewRender.cs | 4 +
Game.Server/Game.Server.csproj | 1 +
Game.Server/GameInterface.cs | 7 +-
Game.Server/World.cs | 2 +-
Game.Shared/EffectData.cs | 22 +-
Game.Shared/EventList.cs | 4 +
Game.Shared/Game.Shared.csproj | 1 +
Game.Shared/GarrysMod/GarrysMod.cs | 2 +-
Game.Shared/GarrysMod/LuaGame.cs | 5 +-
Game.Shared/GarrysMod/LuaGlobalFunctions.cs | 4 +-
Game.Shared/ParticleParse.cs | 225 ++-
Game.Shared/ParticleSystemQuery.cs | 560 ++++++
Source.Common/Mathematics/MathLib.cs | 6 +
Source.NET.slnx | 3 +
.../BuiltinParticleConstraints.cs | 469 +++++
Source.Particles/BuiltinParticleEmitters.cs | 367 ++++
Source.Particles/BuiltinParticleForces.cs | 133 ++
.../BuiltinParticleInitializers.cs | 1164 ++++++++++++
.../BuiltinParticleOperators.ControlPoints.cs | 41 +
.../BuiltinParticleOperators.Movement.cs | 199 ++
Source.Particles/BuiltinParticleOperators.cs | 618 +++++++
.../BuiltinParticleRenderers.Rope.cs | 344 ++++
.../BuiltinParticleRenderers.Trail.cs | 265 +++
Source.Particles/BuiltinParticleRenderers.cs | 564 ++++++
Source.Particles/DmxElementUnpack.cs | 151 ++
Source.Particles/IParticleSystemQuery.cs | 104 ++
Source.Particles/ParticleCollection.cs | 1628 +++++++++++++++++
Source.Particles/ParticleConstants.cs | 96 +
Source.Particles/ParticleOperator.cs | 241 +++
Source.Particles/ParticleSystemDefinition.cs | 353 ++++
Source.Particles/ParticleSystemDictionary.cs | 93 +
Source.Particles/ParticleSystemMgr.cs | 484 +++++
Source.Particles/RandomFloats.cs | 263 +++
Source.Particles/Sheet.cs | 231 +++
Source.Particles/Source.Particles.csproj | 14 +
Source.StdShader.Gl46/Spritecard.cs | 252 +++
54 files changed, 10759 insertions(+), 32 deletions(-)
create mode 100644 Game.Assets/sdn/shaders/splinecard_gl460.vs
create mode 100644 Game.Assets/sdn/shaders/spritecard_gl460.fs
create mode 100644 Game.Assets/sdn/shaders/spritecard_gl460.vs
create mode 100644 Game.Client/NewParticleEffect.cs
create mode 100644 Game.Client/ParticleProperty.cs
create mode 100644 Game.Shared/ParticleSystemQuery.cs
create mode 100644 Source.Particles/BuiltinParticleConstraints.cs
create mode 100644 Source.Particles/BuiltinParticleEmitters.cs
create mode 100644 Source.Particles/BuiltinParticleForces.cs
create mode 100644 Source.Particles/BuiltinParticleInitializers.cs
create mode 100644 Source.Particles/BuiltinParticleOperators.ControlPoints.cs
create mode 100644 Source.Particles/BuiltinParticleOperators.Movement.cs
create mode 100644 Source.Particles/BuiltinParticleOperators.cs
create mode 100644 Source.Particles/BuiltinParticleRenderers.Rope.cs
create mode 100644 Source.Particles/BuiltinParticleRenderers.Trail.cs
create mode 100644 Source.Particles/BuiltinParticleRenderers.cs
create mode 100644 Source.Particles/DmxElementUnpack.cs
create mode 100644 Source.Particles/IParticleSystemQuery.cs
create mode 100644 Source.Particles/ParticleCollection.cs
create mode 100644 Source.Particles/ParticleConstants.cs
create mode 100644 Source.Particles/ParticleOperator.cs
create mode 100644 Source.Particles/ParticleSystemDefinition.cs
create mode 100644 Source.Particles/ParticleSystemDictionary.cs
create mode 100644 Source.Particles/ParticleSystemMgr.cs
create mode 100644 Source.Particles/RandomFloats.cs
create mode 100644 Source.Particles/Sheet.cs
create mode 100644 Source.Particles/Source.Particles.csproj
create mode 100644 Source.StdShader.Gl46/Spritecard.cs
diff --git a/Directory.Packages.props b/Directory.Packages.props
index cee916b17..a08b1f073 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 4db9a793f..b8607de57 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 000000000..81f56c5e4
--- /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 000000000..d9a3711b5
--- /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 000000000..ba043dd3d
--- /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 c6ff6d8d9..dc4f47489 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_BaseEntity.cs b/Game.Client/C_BaseEntity.cs
index a34dd59b8..15aaf3d9d 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 814b7e053..a510094ca 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 cab86ef4e..15728ad3a 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 83407e246..eaa72cf75 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 3c063110a..a199bab98 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 c9a872192..456530cf8 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/Game.Client.csproj b/Game.Client/Game.Client.csproj
index c618aea07..556018d4a 100644
--- a/Game.Client/Game.Client.csproj
+++ b/Game.Client/Game.Client.csproj
@@ -6,6 +6,7 @@
+
diff --git a/Game.Client/HLClient.cs b/Game.Client/HLClient.cs
index 089660cce..f77f88f2f 100644
--- a/Game.Client/HLClient.cs
+++ b/Game.Client/HLClient.cs
@@ -79,7 +79,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 +140,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 +211,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 +245,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 +332,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 +437,8 @@ private void OnRenderStart() {
beams.UpdateTempEntBeams();
}
+ ParticleMgr.Instance.Simulate((float)gpGlobals.FrameTime);
+
C_BaseEntity.CalcAimEntPositions();
C_BaseEntity.AddVisibleEntities();
@@ -544,12 +586,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 870643166..c65c2934d 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 000000000..900a7bd8f
--- /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 a3406e57a..af9bde41e 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 000000000..23bb00977
--- /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 a6fc1939b..ae3748669 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 42019900f..216c2794a 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 23fc90279..7324e7939 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 0fdba776c..a6af0f6ef 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 b48907856..d0a7dcd78 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 527eb547e..607e3bb17 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 8d64a9c75..7f369f7a0 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/LuaGame.cs b/Game.Shared/GarrysMod/LuaGame.cs
index 5d6aedcb8..72c68cb11 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 405ed4c57..706fdd3f8 100644
--- a/Game.Shared/GarrysMod/LuaGlobalFunctions.cs
+++ b/Game.Shared/GarrysMod/LuaGlobalFunctions.cs
@@ -173,8 +173,8 @@ 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;
}
diff --git a/Game.Shared/ParticleParse.cs b/Game.Shared/ParticleParse.cs
index a604c7386..76a4f7e6b 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 000000000..ba7a373b0
--- /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/Source.Common/Mathematics/MathLib.cs b/Source.Common/Mathematics/MathLib.cs
index 31438bfc8..f729696d8 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);
diff --git a/Source.NET.slnx b/Source.NET.slnx
index a3f97c6c4..505d8d7f6 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 000000000..2c464ec73
--- /dev/null
+++ b/Source.Particles/BuiltinParticleConstraints.cs
@@ -0,0 +1,469 @@
+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_WorldTraceConstraint.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_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;
+ }
+}
diff --git a/Source.Particles/BuiltinParticleEmitters.cs b/Source.Particles/BuiltinParticleEmitters.cs
new file mode 100644
index 000000000..b5c84ad63
--- /dev/null
+++ b/Source.Particles/BuiltinParticleEmitters.cs
@@ -0,0 +1,367 @@
+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);
+ }
+
+ 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);
+ }
+}
diff --git a/Source.Particles/BuiltinParticleForces.cs b/Source.Particles/BuiltinParticleForces.cs
new file mode 100644
index 000000000..ebfa68edf
--- /dev/null
+++ b/Source.Particles/BuiltinParticleForces.cs
@@ -0,0 +1,133 @@
+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_AttractToControlPoint.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_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);
+ }
+ }
+}
diff --git a/Source.Particles/BuiltinParticleInitializers.cs b/Source.Particles/BuiltinParticleInitializers.cs
new file mode 100644
index 000000000..30032ce6b
--- /dev/null
+++ b/Source.Particles/BuiltinParticleInitializers.cs
@@ -0,0 +1,1164 @@
+using Datamodel;
+
+using Source.Common;
+using Source.Common.Formats.BSP;
+using Source.Common.Mathematics;
+
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+using static Source.Particles.ParticleConstants;
+
+namespace Source.Particles;
+
+public static class BuiltinParticleInitializers
+{
+ public static void AddBuiltInParticleInitializers(ParticleSystemMgr mgr) {
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateWithinSphere.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_PositionOffset.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreateSequentialPath.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InitialRepulsionVelocity.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_InitialVelocityNoise.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomLifeTime.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomRadius.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomAlpha.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomRotation.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomYaw.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomColor.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomTrailLength.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomSequence.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_CreationNoise.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RemapScalar.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_AgeNoise.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_SequenceLifeTime.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomYawFlip.Definition);
+ mgr.AddParticleOperator(ParticleFunctionType.Initializer, C_INIT_RandomSecondSequence.Definition);
+ }
+}
+
+internal static class ParticleInitUtil
+{
+ public const int ROTATION_ATTRIBUTES_MASK = 0x101010;
+ public const int ALPHA_ATTRIBUTES_MASK = 0x10080;
+ public const int INT_ATTRIBUTES_MASK = 0x4800;
+ public const float DEG2RAD = 0.017453292f;
+ public const float INV_255 = 0.003921569f;
+ public static readonly Vector3 Vec3Invalid = new(float.MaxValue, float.MaxValue, float.MaxValue);
+
+ public static float ReadScalar(ParticleCollection particles, int attribute, int particle)
+ => (INT_ATTRIBUTES_MASK & (1 << attribute)) != 0 ? particles.GetIntAttributeValue(attribute, particle) : particles.GetFloatAttributeValue(attribute, particle);
+
+ public static void WriteScalar(ParticleCollection particles, int attribute, int particle, float value) {
+ if ((INT_ATTRIBUTES_MASK & (1 << attribute)) != 0)
+ particles.GetIntAttributeRefForWrite(attribute, particle) = (int)value;
+ else
+ particles.GetFloatAttributeRefForWrite(attribute, particle) = value;
+ }
+
+ public static float RemapClamped(float value, float inMin, float inMax, float outMin, float outMax) {
+ if (inMin == inMax)
+ return value < inMax ? outMin : outMax;
+ float t = Math.Clamp((value - inMin) / (inMax - inMin), 0.0f, 1.0f);
+ return t * (outMax - outMin) + outMin;
+ }
+
+ public static Vector3 ClampedTint(Color tint, Color tintMin, Color tintMax, float amplification) {
+ float scale = amplification * INV_255;
+ return new(Math.Max(tintMin.R, Math.Min(tint.R, tintMax.R)) * scale,
+ Math.Max(tintMin.G, Math.Min(tint.G, tintMax.G)) * scale,
+ Math.Max(tintMin.B, Math.Min(tint.B, tintMax.B)) * scale);
+ }
+
+ static float Overlay(float color, float tint) => tint >= 0.5f ? 1.0f - (1.0f - color + (1.0f - color)) * (1.0f - tint) : (color + color) * tint;
+
+ public static Vector3 BlendTint(in Vector3 colorMin, in Vector3 colorMax, float rand, in Vector3 tint, float tintPerc, int blendMode) {
+ Vector3 color = (colorMax - colorMin) * rand + colorMin;
+ Vector3 target = blendMode switch {
+ 0 => tint,
+ 1 => new(Overlay(color.X, tint.X), Overlay(color.Y, tint.Y), Overlay(color.Z, tint.Z)),
+ 2 => Vector3.Min(color, tint),
+ 3 => Vector3.Max(color, tint),
+ 4 => color * tint,
+ _ => Vector3.Zero
+ };
+ color = (target - color) * tintPerc + color;
+ return new(Math.Min(color.X, 1.0f), Math.Min(color.Y, 1.0f), Math.Min(color.Z, 1.0f));
+ }
+
+ public static Vector3 Abs(Vector3 v, in Vector3 absMask) {
+ if (absMask.X != 0.0f)
+ v.X = MathF.Abs(v.X);
+ if (absMask.Y != 0.0f)
+ v.Y = MathF.Abs(v.Y);
+ if (absMask.Z != 0.0f)
+ v.Z = MathF.Abs(v.Z);
+ return v;
+ }
+}
+
+public sealed class C_INIT_RandomLifeTime : ParticleOperatorInstance
+{
+ public float LifetimeMin;
+ public float LifetimeMax;
+ public float LifetimeRandExponent;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Lifetime Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("lifetime_min", "0", (o, v) => o.LifetimeMin = v)
+ .Float("lifetime_max", "0", (o, v) => o.LifetimeMax = v)
+ .Float("lifetime_random_exponent", "1", (o, v) => o.LifetimeRandExponent = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK;
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_LIFE_DURATION, LifetimeMin, LifetimeMax, LifetimeRandExponent, particles, firstParticle, numParticles);
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_LIFE_DURATION, LifetimeMin, LifetimeMax, LifetimeRandExponent, particles, startBlock, numBlocks, false);
+}
+
+public sealed class C_INIT_RandomRadius : ParticleOperatorInstance
+{
+ public float RadiusMin;
+ public float RadiusMax;
+ public float RadiusRandExponent;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Radius Random", ParticleOperatorId.PiRadius, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("radius_min", "1", (o, v) => o.RadiusMin = v)
+ .Float("radius_max", "1", (o, v) => o.RadiusMax = v)
+ .Float("radius_random_exponent", "1", (o, v) => o.RadiusRandExponent = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK;
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_RADIUS, RadiusMin, RadiusMax, RadiusRandExponent, particles, firstParticle, numParticles);
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_RADIUS, RadiusMin, RadiusMax, RadiusRandExponent, particles, startBlock, numBlocks, false);
+}
+
+public sealed class C_INIT_RandomAlpha : ParticleOperatorInstance
+{
+ public int AlphaMin;
+ public int AlphaMax;
+ public float AlphaRandExponent;
+ float AlphaMinNorm;
+ float AlphaMaxNorm;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Alpha Random", ParticleOperatorId.PiAlpha, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("alpha_min", "255", (o, v) => o.AlphaMin = v)
+ .Int("alpha_max", "255", (o, v) => o.AlphaMax = v)
+ .Float("alpha_random_exponent", "1", (o, v) => o.AlphaRandExponent = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_ALPHA_MASK;
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ AlphaMinNorm = AlphaMin * ParticleInitUtil.INV_255;
+ AlphaMaxNorm = AlphaMax * ParticleInitUtil.INV_255;
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_ALPHA, AlphaMinNorm, AlphaMaxNorm, AlphaRandExponent, particles, firstParticle, numParticles);
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_ALPHA, AlphaMinNorm, AlphaMaxNorm, AlphaRandExponent, particles, startBlock, numBlocks, false);
+}
+
+public sealed class C_INIT_RandomTrailLength : ParticleOperatorInstance
+{
+ public float MinLength;
+ public float MaxLength;
+ public float LengthRandExponent;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Trail Length Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("length_min", "0.1", (o, v) => o.MinLength = v)
+ .Float("length_max", "0.1", (o, v) => o.MaxLength = v)
+ .Float("length_random_exponent", "1", (o, v) => o.LengthRandExponent = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_TRAIL_LENGTH_MASK;
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeScalar(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, MinLength, MaxLength, LengthRandExponent, particles, firstParticle, numParticles);
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeBlock(PARTICLE_ATTRIBUTE_TRAIL_LENGTH, MinLength, MaxLength, LengthRandExponent, particles, startBlock, numBlocks, false);
+}
+
+public abstract class GeneralRandomRotation : ParticleOperatorInstance
+{
+ public float Degrees;
+ public float DegreesMin;
+ public float DegreesMax;
+ public float RotationRandExponent;
+ public bool RandomlyFlipDirection;
+ protected float Radians;
+ protected float RadiansMin;
+ protected float RadiansMax;
+
+ protected static DmxElementUnpackStructure Unpack(string initial, string min, string max, string exponent, bool flip) where T : GeneralRandomRotation {
+ DmxElementUnpackStructure unpack = ParticleOperatorUnpack.Begin()
+ .Float(initial, "0", (o, v) => o.Degrees = v)
+ .Float(min, "0", (o, v) => o.DegreesMin = v)
+ .Float(max, "360", (o, v) => o.DegreesMax = v)
+ .Float(exponent, "1", (o, v) => o.RotationRandExponent = v);
+ return flip ? unpack.Bool("randomly_flip_direction", "0", (o, v) => o.RandomlyFlipDirection = v) : unpack;
+ }
+
+ protected abstract int GetAttributeToInit();
+
+ public override uint GetWrittenAttributes() => 1u << GetAttributeToInit();
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ Radians = Degrees * ParticleInitUtil.DEG2RAD;
+ RadiansMin = DegreesMin * ParticleInitUtil.DEG2RAD;
+ RadiansMax = DegreesMax * ParticleInitUtil.DEG2RAD;
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ int attribute = GetAttributeToInit();
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ float value = particles.RandomFloatExp(RadiansMin, RadiansMax, RotationRandExponent) + Radians;
+ if (RandomlyFlipDirection) {
+ float rand = particles.RandomFloat(0.0f, 1.0f);
+ if (rand + rand < 1.0f)
+ value = -value;
+ }
+ particles.GetFloatAttributeRefForWrite(attribute, p) = value;
+ }
+ }
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context)
+ => InitScalarAttributeRandomRangeBlock(GetAttributeToInit(), RadiansMin, RadiansMax, RotationRandExponent, particles, startBlock, numBlocks, RandomlyFlipDirection);
+}
+
+public sealed class C_INIT_RandomRotation : GeneralRandomRotation
+{
+ public static readonly ParticleOperatorDefinition Definition = new("Rotation Random", ParticleOperatorId.PiRotation, false,
+ Unpack("rotation_initial", "rotation_offset_min", "rotation_offset_max", "rotation_random_exponent", true));
+
+ protected override int GetAttributeToInit() => PARTICLE_ATTRIBUTE_ROTATION;
+}
+
+public sealed class C_INIT_RandomYaw : GeneralRandomRotation
+{
+ public static readonly ParticleOperatorDefinition Definition = new("Rotation Yaw Random", ParticleOperatorId.PiYaw, false,
+ Unpack("yaw_initial", "yaw_offset_min", "yaw_offset_max", "yaw_random_exponent", false));
+
+ protected override int GetAttributeToInit() => PARTICLE_ATTRIBUTE_YAW;
+}
+
+public sealed class C_INIT_RandomYawFlip : ParticleOperatorInstance
+{
+ public float Percent;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Rotation Yaw Flip Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("Flip Percentage", ".5", (o, v) => o.Percent = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_YAW_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_YAW_MASK;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ if (particles.RandomFloat(0.0f, 1.0f) < Percent)
+ particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_YAW, p) += 3.1415927f;
+ }
+ }
+}
+
+public sealed class C_INIT_RandomColor : ParticleOperatorInstance
+{
+ public Color ColorMin;
+ public Color ColorMax;
+ public Color TintMin;
+ public Color TintMax;
+ public float TintPerc;
+ public float UpdateThreshold;
+ public int TintCP;
+ public int FieldOutput;
+ public int TintBlendMode;
+ public float LightAmplification;
+ Vector3 NormColorMin;
+ Vector3 NormColorMax;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Color Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Color("color1", "255 255 255 255", (o, v) => o.ColorMin = v)
+ .Color("color2", "255 255 255 255", (o, v) => o.ColorMax = v)
+ .Float("tint_perc", "0.0", (o, v) => o.TintPerc = v)
+ .Int("tint control point", "0", (o, v) => o.TintCP = v)
+ .Color("tint clamp min", "0 0 0 0", (o, v) => o.TintMin = v)
+ .Color("tint clamp max", "255 255 255 255", (o, v) => o.TintMax = v)
+ .Float("tint update movement threshold", "32", (o, v) => o.UpdateThreshold = v)
+ .Int("tint blend mode", "0", (o, v) => o.TintBlendMode = v)
+ .Float("light amplification amount", "1", (o, v) => o.LightAmplification = v)
+ .Int("output field", "6", (o, v) => o.FieldOutput = v));
+
+ static ref Vector3 LastPosition(Span context) => ref MemoryMarshal.AsRef(context);
+
+ public override uint GetWrittenAttributes() => 1u << FieldOutput;
+ public override uint GetReadAttributes() => 0;
+ public override ulong GetReadControlPointMask() => 1UL << (TintCP & 63);
+ public override int GetRequiredContextBytes() => 12;
+
+ public override void InitializeContextData(ParticleCollection particles, Span context) => LastPosition(context) = Vector3.Zero;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ NormColorMin = new Vector3(ColorMin.R, ColorMin.G, ColorMin.B) * ParticleInitUtil.INV_255;
+ NormColorMax = new Vector3(ColorMax.R, ColorMax.G, ColorMax.B) * ParticleInitUtil.INV_255;
+ FieldOutput = Math.Clamp(FieldOutput, 0, MAX_PARTICLE_ATTRIBUTES_GMOD - 1);
+ }
+
+ const int MAX_PARTICLE_ATTRIBUTES_GMOD = 22;
+
+ Vector3 ComputeTint(ParticleCollection particles, Span context) {
+ Color tint;
+ ParticleCollection? parent = particles.Parent;
+ if (parent != null && parent.LocalLightingCP == TintCP)
+ tint = parent.LocalLighting;
+ else {
+ ref Vector3 lastPosition = ref LastPosition(context);
+ particles.GetControlPointAtTime(TintCP, particles.CurTime, out Vector3 origin);
+ if (Vector3.Distance(lastPosition, origin) >= UpdateThreshold || particles.LocalLightingCP == -1) {
+ particles.Mgr!.Query().GetLightingAtPoint(origin, out tint);
+ particles.LocalLighting = tint;
+ particles.LocalLightingCP = TintCP;
+ lastPosition = origin;
+ }
+ else
+ tint = particles.LocalLighting;
+ }
+ return ParticleInitUtil.ClampedTint(tint, TintMin, TintMax, LightAmplification);
+ }
+
+ Vector3 ColorFor(float rand, bool doTint, in Vector3 tint)
+ => doTint ? ParticleInitUtil.BlendTint(NormColorMin, NormColorMax, rand, tint, TintPerc, TintBlendMode) : (NormColorMax - NormColorMin) * rand + NormColorMin;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ bool doTint = TintPerc != 0.0f;
+ Vector3 tint = doTint ? ComputeTint(particles, context) : default;
+ for (int p = firstParticle; p < firstParticle + numParticles; p++)
+ particles.SetVectorAttribute(FieldOutput, p, ColorFor(particles.RandomFloat(0.0f, 1.0f), doTint, tint));
+ }
+
+ public override void InitNewParticlesBlock(ParticleCollection particles, int startBlock, int numBlocks, int attributeWriteMask, Span context) {
+ bool doTint = TintPerc != 0.0f;
+ Vector3 tint = doTint ? ComputeTint(particles, context) : default;
+ int randContext = RandSIMD.GetContext();
+ for (int b = 0; b < numBlocks; b++) {
+ Vector128 rand = RandSIMD.Next(randContext);
+ for (int lane = 0; lane < 4; lane++)
+ particles.SetVectorAttribute(FieldOutput, (startBlock + b) * 4 + lane, ColorFor(rand[lane], doTint, tint));
+ }
+ RandSIMD.ReleaseContext(randContext);
+ }
+}
+
+public sealed class C_INIT_RandomSequence : ParticleOperatorInstance
+{
+ const int MAX_SEQUENCE_TABLE = 64;
+
+ public int SequenceMin;
+ public int SequenceMax;
+ public bool Shuffle;
+ public bool Linear;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Sequence Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("sequence_min", "0", (o, v) => o.SequenceMin = v)
+ .Int("sequence_max", "0", (o, v) => o.SequenceMax = v)
+ .Bool("shuffle", "0", (o, v) => o.Shuffle = v)
+ .Bool("linear", "0", (o, v) => o.Linear = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK;
+ public override uint GetReadAttributes() => 0;
+ public override int GetRequiredContextBytes() => (MAX_SEQUENCE_TABLE + 1) * sizeof(int);
+
+ static int GetEntry(Span table, int index) => (uint)index < MAX_SEQUENCE_TABLE ? table[index + 1] : index;
+
+ static void SetEntry(Span table, int index, int value) {
+ if ((uint)index < MAX_SEQUENCE_TABLE)
+ table[index + 1] = value;
+ }
+
+ void ShuffleTable(ParticleCollection particles, Span table) {
+ for (int j = SequenceMax; SequenceMin < j; j--) {
+ int swap = (int)((j - SequenceMin + 1) * particles.RandomFloat(0.0f, 1.0f)) + SequenceMin;
+ int value = GetEntry(table, j);
+ SetEntry(table, j, GetEntry(table, swap));
+ SetEntry(table, swap, value);
+ }
+ }
+
+ public override void InitializeContextData(ParticleCollection particles, Span context) {
+ if (!Shuffle && !Linear)
+ return;
+
+ Span table = MemoryMarshal.Cast(context);
+ table[0] = SequenceMin;
+ for (int i = SequenceMin; i <= SequenceMax; i++)
+ SetEntry(table, i, i);
+ if (Shuffle && SequenceMin < SequenceMax)
+ ShuffleTable(particles, table);
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ if (!Shuffle && !Linear) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++)
+ particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p) = particles.RandomInt(SequenceMin, SequenceMax);
+ return;
+ }
+
+ Span table = MemoryMarshal.Cast(context);
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ if (SequenceMax < table[0]) {
+ if (Shuffle && SequenceMin < SequenceMax)
+ ShuffleTable(particles, table);
+ table[0] = SequenceMin;
+ }
+ particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p) = GetEntry(table, table[0]);
+ table[0]++;
+ }
+ }
+}
+
+public sealed class C_INIT_RandomSecondSequence : ParticleOperatorInstance
+{
+ public int SequenceMin;
+ public int SequenceMax;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Sequence Two Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("sequence_min", "0", (o, v) => o.SequenceMin = v)
+ .Int("sequence_max", "0", (o, v) => o.SequenceMax = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1_MASK;
+ public override uint GetReadAttributes() => 0;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++)
+ particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER1, p) = particles.RandomInt(SequenceMin, SequenceMax);
+ }
+}
+
+public sealed class C_INIT_SequenceLifeTime : ParticleOperatorInstance
+{
+ public float FramesPerSecond;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Lifetime From Sequence", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("Frames Per Second", "30", (o, v) => o.FramesPerSecond = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER_MASK;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ Sheet? sheet = particles.Sheet;
+ if (FramesPerSecond == 0.0f || sheet == null)
+ return;
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ int sequence = (int)particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_SEQUENCE_NUMBER, p);
+ float frameSpan = (uint)sequence < Sheet.MAX_SEQUENCES ? sheet.FrameSpan[sequence] : 0.0f;
+ particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_LIFE_DURATION, p) = frameSpan == 0.0f ? 1.0f : frameSpan / FramesPerSecond;
+ }
+ }
+}
+
+public sealed class C_INIT_CreateWithinSphere : ParticleOperatorInstance
+{
+ public float RadiusMin;
+ public float RadiusMax;
+ public Vector3 DistanceBias;
+ public Vector3 DistanceBiasAbs;
+ public int ControlPointNumber;
+ public int ScaleCP;
+ public float SpeedMin;
+ public float SpeedMax;
+ public float SpeedRandExp;
+ public bool LocalCoords;
+ public bool UseHighestEndCP;
+ public float EndCPGrowthTime;
+ public Vector3 LocalCoordinateSystemSpeedMin;
+ public Vector3 LocalCoordinateSystemSpeedMax;
+ public int CreateInModel;
+ bool HasDistanceBias;
+ bool HasDistanceBiasAbs;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Position Within Sphere Random", ParticleOperatorId.PiPosition, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("distance_min", "0", (o, v) => o.RadiusMin = v)
+ .Float("distance_max", "0", (o, v) => o.RadiusMax = v)
+ .Vector3("distance_bias", "1 1 1", (o, v) => o.DistanceBias = v)
+ .Vector3("distance_bias_absolute_value", "0 0 0", (o, v) => o.DistanceBiasAbs = v)
+ .Bool("bias in local system", "0", (o, v) => o.LocalCoords = v)
+ .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)
+ .Float("speed_min", "0", (o, v) => o.SpeedMin = v)
+ .Float("speed_max", "0", (o, v) => o.SpeedMax = v)
+ .Float("speed_random_exponent", "1", (o, v) => o.SpeedRandExp = v)
+ .Vector3("speed_in_local_coordinate_system_min", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMin = v)
+ .Vector3("speed_in_local_coordinate_system_max", "0 0 0", (o, v) => o.LocalCoordinateSystemSpeedMax = v)
+ .Int("create in model", "0", (o, v) => o.CreateInModel = v)
+ .Bool("randomly distribute to highest supplied Control Point", "0", (o, v) => o.UseHighestEndCP = v)
+ .Float("randomly distribution growth time", "0", (o, v) => o.EndCPGrowthTime = v)
+ .Int("scale cp (distance/speed/local speed)", "-1", (o, v) => o.ScaleCP = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+
+ public override ulong GetReadControlPointMask() {
+ ulong mask = 1UL << (ControlPointNumber & 63);
+ if (UseHighestEndCP)
+ return ~(mask - 1);
+ if (ScaleCP != -1)
+ mask |= 1UL << (ScaleCP & 63);
+ return mask;
+ }
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+ ScaleCP = Math.Clamp(ScaleCP, -1, MAX_PARTICLE_CONTROL_POINTS - 1);
+ HasDistanceBias = DistanceBias.X != 1.0f || DistanceBias.Y != 1.0f || DistanceBias.Z != 1.0f;
+ HasDistanceBiasAbs = DistanceBiasAbs.X != 0.0f || DistanceBiasAbs.Y != 0.0f || DistanceBiasAbs.Z != 0.0f;
+ }
+
+ int PickControlPoint(ParticleCollection particles, List? validCPs) {
+ if (validCPs == null || validCPs.Count == 0)
+ return ControlPointNumber;
+
+ float growth = 1.0f;
+ if (EndCPGrowthTime != 0.0f)
+ growth = Math.Min(particles.CurTime, EndCPGrowthTime) / EndCPGrowthTime;
+
+ if (growth >= 1.0f)
+ return validCPs[(int)(validCPs.Count * particles.RandomFloat(0.0f, 1.0f))];
+
+ int highest = particles.GetHighestControlPoint();
+ int low = ControlPointNumber;
+ int high = highest < ControlPointNumber ? ControlPointNumber : highest;
+ int query = particles.RandomQueryCount++;
+ growth = Math.Clamp(growth, 0.0f, 1.0f);
+ int currentHigh = (int)MathF.Floor(growth * (high - low) + low);
+ int target = (int)((currentHigh - low + 1) * particles.RandomFloat(query, 0.0f, 1.0f)) + low;
+ int found = validCPs.IndexOf(target);
+ if (found >= 0)
+ return validCPs[found];
+
+ particles.RandomQueryCount = query + 2;
+ return validCPs[(int)(validCPs.Count * particles.RandomFloat(query + 1, 0.0f, 1.0f))];
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ Vector3 scale = Vector3.One;
+ if (ScaleCP >= 0)
+ scale = particles.ControlPoints[ScaleCP].Position;
+
+ List? validCPs = null;
+ if (UseHighestEndCP) {
+ validCPs = [];
+ for (int i = ControlPointNumber; i <= particles.GetHighestControlPoint(); i++) {
+ if (particles.ControlPoints[i].Position != ParticleInitUtil.Vec3Invalid)
+ validCPs.Add(i);
+ }
+ }
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ float time = Math.Max(particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), particles.CurTime - particles.Dt);
+ int currentControlPoint = UseHighestEndCP ? PickControlPoint(particles, validCPs) : ControlPointNumber;
+
+ Vector3 randomPosition;
+ Vector3 randomDirection;
+ int tries = 0;
+ while (true) {
+ float length = particles.RandomVectorInUnitSphere(particles.RandomQueryCount, out randomDirection);
+ particles.RandomQueryCount += 3;
+
+ if (HasDistanceBiasAbs)
+ randomDirection = ParticleInitUtil.Abs(randomDirection, DistanceBiasAbs);
+ randomDirection *= DistanceBias;
+ MathLib.VectorNormalize(ref randomDirection);
+
+ randomPosition = randomDirection * (((RadiusMax - RadiusMin) * length + RadiusMin) * scale.X);
+
+ if (!HasDistanceBias || !LocalCoords) {
+ particles.GetControlPointAtTime(currentControlPoint, time, out Vector3 controlPoint);
+ randomPosition += controlPoint;
+ }
+ else {
+ particles.GetControlPointTransformAtTime(currentControlPoint, time, out Matrix3x4 transform);
+ MathLib.VectorTransform(in randomPosition, in transform, out randomPosition);
+ }
+
+ if (CreateInModel == 0)
+ break;
+ if (particles.Mgr!.Query().MovePointInsideControllingObject(particles, particles.ControlPoints[currentControlPoint].Object, ref randomPosition))
+ break;
+ if (++tries >= 10)
+ break;
+ }
+
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, randomPosition);
+
+ if ((attributeWriteMask & PARTICLE_ATTRIBUTE_PREV_XYZ_MASK) == 0)
+ continue;
+
+ Vector3 offset = Vector3.Zero;
+ if (SpeedMax > 0.0f)
+ offset = -randomDirection * (particles.RandomFloatExp(SpeedMin, SpeedMax, SpeedRandExp) * scale.Y);
+
+ float localX = particles.RandomFloat(LocalCoordinateSystemSpeedMin.X, LocalCoordinateSystemSpeedMax.X);
+ float localY = particles.RandomFloat(LocalCoordinateSystemSpeedMin.Y, LocalCoordinateSystemSpeedMax.Y);
+ float localZ = particles.RandomFloat(LocalCoordinateSystemSpeedMin.Z, LocalCoordinateSystemSpeedMax.Z);
+
+ ref readonly ParticleControlPoint cp = ref particles.ControlPoint(currentControlPoint);
+ offset -= cp.ForwardVector * (localX * scale.Z);
+ offset -= cp.RightVector * (localY * scale.Z);
+ offset -= cp.UpVector * (localZ * scale.Z);
+
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, randomPosition + offset * particles.PreviousDt);
+ }
+ }
+}
+
+public sealed class C_INIT_PositionOffset : ParticleOperatorInstance
+{
+ public Vector3 OffsetMin;
+ public Vector3 OffsetMax;
+ public int ControlPointNumber;
+ public bool LocalCoords;
+ public bool Proportional;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Position Modify Offset Random", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)
+ .Vector3("offset min", "0 0 0", (o, v) => o.OffsetMin = v)
+ .Vector3("offset max", "0 0 0", (o, v) => o.OffsetMax = v)
+ .Bool("offset in local space 0/1", "0", (o, v) => o.LocalCoords = v)
+ .Bool("offset proportional to radius 0/1", "0", (o, v) => o.Proportional = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element)
+ => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ Vector3 offset;
+ if (!Proportional)
+ particles.RandomVector(OffsetMin, OffsetMax, out offset);
+ else {
+ float radius = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p);
+ particles.RandomVector(OffsetMin * radius, OffsetMax * radius, out offset);
+ }
+
+ if (LocalCoords) {
+ particles.GetControlPointTransformAtTime(ControlPointNumber, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Matrix3x4 transform);
+ MathLib.VectorRotate(in offset, in transform, out offset);
+ }
+
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + offset);
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + offset);
+ }
+ }
+}
+
+public sealed class C_INIT_CreateSequentialPath : ParticleOperatorInstance
+{
+ struct Context
+ {
+ public int Unused;
+ public float PathPosition;
+ public float StepDirection;
+ public float CPPairPosition;
+ public float Step;
+ public float CPStep;
+ }
+
+ public float MaxDistance;
+ public float NumToAssign;
+ public bool Loop;
+ public bool CPPairs;
+ public bool SaveOffset;
+ public PathParameters PathParams;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Position Along Path Sequential", ParticleOperatorId.PiPosition, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("maximum distance", "0", (o, v) => o.MaxDistance = v)
+ .Float("bulge", "0", (o, v) => o.PathParams.Bulge = v)
+ .Int("start control point number", "0", (o, v) => o.PathParams.StartControlPointNumber = v)
+ .Int("end control point number", "0", (o, v) => o.PathParams.EndControlPointNumber = v)
+ .Int("bulge control 0=random 1=orientation of start pnt 2=orientation of end point", "0", (o, v) => o.PathParams.BulgeControl = v)
+ .Float("mid point position", "0.5", (o, v) => o.PathParams.MidPoint = v)
+ .Float("particles to map from start to end", "100", (o, v) => o.NumToAssign = v)
+ .Bool("restart behavior (0 = bounce, 1 = loop )", "1", (o, v) => o.Loop = v)
+ .Bool("Use sequential CP pairs between start and end point", "0", (o, v) => o.CPPairs = v)
+ .Bool("Save Offset", "0", (o, v) => o.SaveOffset = v));
+
+ static ref Context Ctx(Span context) => ref MemoryMarshal.AsRef(context);
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override int GetRequiredContextBytes() => 24;
+
+ public override ulong GetReadControlPointMask() {
+ ulong startMask = (1UL << PathParams.StartControlPointNumber) - 1;
+ if (CPPairs)
+ return ~startMask;
+ return ~startMask & ((1UL << ((PathParams.EndControlPointNumber + 1) & 63)) - 1);
+ }
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ PathParams.StartControlPointNumber = Math.Clamp(PathParams.StartControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+ PathParams.EndControlPointNumber = Math.Clamp(PathParams.EndControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+ }
+
+ public override void InitializeContextData(ParticleCollection particles, Span context) {
+ ref Context ctx = ref Ctx(context);
+ ctx.PathPosition = 0.0f;
+ ctx.Step = NumToAssign <= 1.0f ? 0.0f : 1.0f / (NumToAssign - 1.0f);
+ ctx.StepDirection = -1.0f;
+ if (!CPPairs)
+ return;
+
+ ctx.CPPairPosition = PathParams.StartControlPointNumber;
+ int pairs = PathParams.EndControlPointNumber - PathParams.StartControlPointNumber;
+ if (pairs > 1 && NumToAssign > 1.0f) {
+ ctx.Step = pairs * ctx.Step;
+ ctx.CPStep = ctx.Step;
+ }
+ else
+ ctx.CPStep = 0.0f;
+ }
+
+ public override void Restart(ParticleCollection particles, Span context) => InitializeContextData(particles, context);
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ ref Context ctx = ref Ctx(context);
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ PathParameters path = PathParams;
+ if (CPPairs) {
+ float span = PathParams.EndControlPointNumber - PathParams.StartControlPointNumber;
+ if (span < ctx.CPPairPosition || ctx.CPPairPosition < PathParams.StartControlPointNumber) {
+ if (!Loop) {
+ ctx.CPStep = -ctx.CPStep;
+ ctx.Step = -ctx.Step;
+ ctx.StepDirection = -ctx.StepDirection;
+ ctx.CPPairPosition = ctx.CPStep + ctx.CPStep + ctx.CPPairPosition;
+ ctx.PathPosition = ctx.Step + ctx.Step + ctx.PathPosition;
+ }
+ else
+ ctx.CPPairPosition -= span;
+ }
+ path.StartControlPointNumber = (int)ctx.CPPairPosition;
+ path.EndControlPointNumber = (int)ctx.CPPairPosition + 1;
+ }
+
+ if (ctx.PathPosition > 1.0000001f || ctx.PathPosition < 0.0f) {
+ if (!Loop && !CPPairs) {
+ ctx.Step = -ctx.Step;
+ ctx.StepDirection = -ctx.StepDirection;
+ ctx.PathPosition = ctx.Step + ctx.Step + ctx.PathPosition;
+ }
+ else
+ ctx.PathPosition += ctx.StepDirection;
+ }
+
+ float t = ctx.PathPosition;
+ particles.CalculatePathValues(in path, particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p), out Vector3 startPnt, out Vector3 midPnt, out Vector3 endPnt);
+
+ int query = particles.RandomQueryCount;
+ particles.RandomQueryCount += 3;
+ Vector3 randomOffset = new(
+ particles.RandomFloat(query, -MaxDistance, MaxDistance),
+ particles.RandomFloat(query + 1, -MaxDistance, MaxDistance),
+ particles.RandomFloat(query + 2, -MaxDistance, MaxDistance));
+
+ Vector3 startMid = (midPnt - startPnt) * t + startPnt;
+ Vector3 midEnd = (endPnt - midPnt) * t + midPnt;
+ Vector3 position = (midEnd - startMid) * t + startMid + randomOffset;
+
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, position);
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, position);
+ if (SaveOffset)
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_HITBOX_RELATIVE_XYZ, p, new Vector3(t, path.StartControlPointNumber, path.EndControlPointNumber));
+
+ ctx.PathPosition += ctx.Step;
+ ctx.CPPairPosition += ctx.CPStep;
+ }
+ }
+}
+
+public sealed class C_INIT_InitialRepulsionVelocity : ParticleOperatorInstance
+{
+ static readonly Vector3[] TraceDirections = [new(1, 0, 0), new(-1, 0, 0), new(0, 1, 0), new(0, -1, 0), new(0, 0, 1), new(0, 0, -1)];
+
+ public string CollisionGroupName = "NONE";
+ public int CollisionGroupNumber;
+ public Vector3 MinVelocity;
+ public Vector3 MaxVelocity;
+ public int ControlPointNumber;
+ public bool PerParticle;
+ public bool Translate;
+ public bool Proportional;
+ public float TraceLength;
+ public bool PerParticleTR;
+ public bool InheritFromParent;
+ public int ChildCP;
+ public int ChildGroupID;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Velocity Repulse from World", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Vector3("minimum velocity", "0 0 0", (o, v) => o.MinVelocity = v)
+ .Vector3("maximum velocity", "1 1 1", (o, v) => o.MaxVelocity = v)
+ .String("collision group", "NONE", 128, (o, v) => o.CollisionGroupName = v)
+ .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)
+ .Bool("Per Particle World Collision Tests", "0", (o, v) => o.PerParticle = v)
+ .Bool("Use radius for Per Particle Trace Length", "0", (o, v) => o.PerParticleTR = v)
+ .Bool("Offset instead of accelerate", "0", (o, v) => o.Translate = v)
+ .Bool("Offset proportional to radius 0/1", "0", (o, v) => o.Proportional = v)
+ .Float("Trace Length", "64.0", (o, v) => o.TraceLength = v)
+ .Bool("Inherit from Parent", "0", (o, v) => o.InheritFromParent = v)
+ .Int("control points to broadcast to children (n + 1)", "-1", (o, v) => o.ChildCP = v)
+ .Int("Child Group ID to affect", "0", (o, v) => o.ChildGroupID = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_RADIUS_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override bool InitMultipleOverride() => true;
+
+ public override ulong GetReadControlPointMask() {
+ if (PerParticle)
+ return 0;
+ ulong mask = 1UL << (ControlPointNumber & 63);
+ if (InheritFromParent)
+ mask |= 1UL << ((ControlPointNumber + 1) & 63);
+ return mask;
+ }
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ CollisionGroupNumber = def.Mgr.Query().GetCollisionGroupFromName(CollisionGroupName);
+ ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+ }
+
+ float TraceRepulsion(IParticleSystemQuery query, in Vector3 origin, float traceLength, out Vector3 direction) {
+ float total = 0.0f;
+ direction = Vector3.Zero;
+ for (int i = 0; i < TraceDirections.Length; i++) {
+ GameTrace trace = default;
+ query.TraceLine(origin, origin + TraceDirections[i] * traceLength, (Mask)Contents.Solid, null, CollisionGroupNumber, ref trace);
+ float blocked = 1.0f - trace.Fraction;
+ total += blocked;
+ direction -= TraceDirections[i] * blocked;
+ }
+
+ if (direction == Vector3.Zero) {
+ direction = new Vector3(0, 0, 1);
+ total = 0.0f;
+ }
+ MathLib.VectorNormalize(ref direction);
+ return total;
+ }
+
+ void BroadcastToChildren(ParticleCollection particles, in Vector3 direction, float total) {
+ for (ParticleCollection? child = particles.Children; child != null; child = child.Next) {
+ if (child.GetGroupID() != ChildGroupID)
+ continue;
+ if ((uint)ChildCP < MAX_PARTICLE_CONTROL_POINTS)
+ child.SetControlPoint(ChildCP, direction);
+ if ((uint)(ChildCP + 1) < MAX_PARTICLE_CONTROL_POINTS)
+ child.SetControlPoint(ChildCP + 1, new Vector3(total, 0, 0));
+ }
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ IParticleSystemQuery query = particles.Mgr!.Query();
+
+ if (PerParticle) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ Vector3 origin = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p);
+ float radius = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p);
+ float total = TraceRepulsion(query, origin, PerParticleTR ? radius : TraceLength, out Vector3 direction);
+ Vector3 velocity = ((MaxVelocity - MinVelocity) * total + MinVelocity) * direction * total;
+ if (Proportional)
+ velocity *= radius;
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, origin + velocity);
+ if (Translate)
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + velocity);
+ }
+ return;
+ }
+
+ float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, firstParticle);
+ Vector3 repulsion;
+ if (!InheritFromParent) {
+ particles.GetControlPointAtTime(ControlPointNumber, creationTime, out Vector3 origin);
+ float total = TraceRepulsion(query, origin, TraceLength, out Vector3 direction);
+ direction *= total;
+ repulsion = ((MaxVelocity - MinVelocity) * total + MinVelocity) * direction;
+ if (ChildCP != -1)
+ BroadcastToChildren(particles, direction, total);
+ }
+ else {
+ particles.GetControlPointAtTime(ControlPointNumber, creationTime, out Vector3 direction);
+ particles.GetControlPointAtTime(ControlPointNumber + 1, creationTime, out Vector3 amount);
+ repulsion = ((MaxVelocity - MinVelocity) * amount.X + MinVelocity) * direction;
+ }
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ if (Proportional)
+ repulsion *= particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_RADIUS, p);
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + repulsion);
+ if (Translate)
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) + repulsion);
+ }
+ }
+}
+
+public sealed class C_INIT_InitialVelocityNoise : ParticleOperatorInstance
+{
+ public Vector3 AbsVal;
+ public Vector3 AbsValInv;
+ public Vector3 OffsetLoc;
+ public float Offset;
+ public Vector3 OutputMin;
+ public Vector3 OutputMax;
+ public float NoiseScale;
+ public float NoiseScaleLoc;
+ public int ControlPointNumber;
+ public bool LocalSpace;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Velocity Noise", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("Control Point Number", "0", (o, v) => o.ControlPointNumber = v)
+ .Float("Time Noise Coordinate Scale", "1", (o, v) => o.NoiseScale = v)
+ .Float("Spatial Noise Coordinate Scale", "0.01", (o, v) => o.NoiseScaleLoc = v)
+ .Float("Time Coordinate Offset", "0", (o, v) => o.Offset = v)
+ .Vector3("Spatial Coordinate Offset", "0 0 0", (o, v) => o.OffsetLoc = v)
+ .Vector3("Absolute Value", "0 0 0", (o, v) => o.AbsVal = v)
+ .Vector3("Invert Abs Value", "0 0 0", (o, v) => o.AbsValInv = v)
+ .Vector3("output minimum", "0 0 0", (o, v) => o.OutputMin = v)
+ .Vector3("output maximum", "1 1 1", (o, v) => o.OutputMax = v)
+ .Bool("Apply Velocity in Local Space (0/1)", "0", (o, v) => o.LocalSpace = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element)
+ => ControlPointNumber = Math.Clamp(ControlPointNumber, 0, MAX_PARTICLE_CONTROL_POINTS - 1);
+
+ static float Shape(float noise, bool abs, bool invert) {
+ if (abs)
+ noise = MathF.Abs(noise);
+ return invert ? 1.0f - noise : noise;
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ bool anyInvert = AbsValInv.X != 0.0f || AbsValInv.Y != 0.0f || AbsValInv.Z != 0.0f;
+ Vector3 valueScale = new(AbsVal.X != 0.0f ? 1.0f : 0.5f, AbsVal.Y != 0.0f ? 1.0f : 0.5f, AbsVal.Z != 0.0f ? 1.0f : 0.5f);
+ Vector3 range = OutputMax - OutputMin;
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p);
+ float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p);
+ float coordTime = (Offset + creationTime) * NoiseScale;
+ Vector3 coord = (position + OffsetLoc) * NoiseScaleLoc + new Vector3(coordTime);
+
+ float noiseX = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z);
+ float noiseY = NoiseSIMD.Noise(coord.X + 100000.5f, coord.Y + 300000.25f, coord.Z + 9000001.0f);
+ float noiseZ = NoiseSIMD.Noise(coord.X + 110000.25f, coord.Y + 310000.75f, coord.Z + 9100000.0f);
+
+ Vector3 noise = new(
+ Shape(noiseX, AbsVal.X != 0.0f, anyInvert && AbsValInv.X != 0.0f),
+ Shape(noiseY, AbsVal.Y != 0.0f, anyInvert && AbsValInv.Y != 0.0f),
+ Shape(noiseZ, AbsVal.Z != 0.0f, anyInvert && AbsValInv.Z != 0.0f));
+
+ Vector3 velocity = (noise * range * valueScale + (Vector3.One - valueScale) * range + OutputMin) * particles.PreviousDt;
+
+ if (LocalSpace) {
+ particles.GetControlPointTransformAtTime(ControlPointNumber, creationTime, out Matrix3x4 transform);
+ MathLib.VectorRotate(in velocity, in transform, out velocity);
+ }
+
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_PREV_XYZ, p, particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p) - velocity);
+ }
+ }
+}
+
+public sealed class C_INIT_CreationNoise : ParticleOperatorInstance
+{
+ public int FieldOutput;
+ public bool AbsVal;
+ public bool AbsValInv;
+ public float Offset;
+ public float OutputMin;
+ public float OutputMax;
+ public float NoiseScale;
+ public float NoiseScaleLoc;
+ public Vector3 OffsetLoc;
+ public float WorldTimeScale;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Remap Noise to Scalar", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("time noise coordinate scale", "0.1", (o, v) => o.NoiseScale = v)
+ .Float("spatial noise coordinate scale", "0.001", (o, v) => o.NoiseScaleLoc = v)
+ .Int("output field", "3", (o, v) => o.FieldOutput = v)
+ .Float("time coordinate offset", "0", (o, v) => o.Offset = v)
+ .Vector3("spatial coordinate offset", "0 0 0", (o, v) => o.OffsetLoc = v)
+ .Bool("absolute value", "0", (o, v) => o.AbsVal = v)
+ .Bool("invert absolute value", "0", (o, v) => o.AbsValInv = v)
+ .Float("output minimum", "0", (o, v) => o.OutputMin = v)
+ .Float("output maximum", "1", (o, v) => o.OutputMax = v)
+ .Float("world time noise coordinate scale", "0", (o, v) => o.WorldTimeScale = v));
+
+ public override uint GetWrittenAttributes() => 1u << FieldOutput;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element)
+ => FieldOutput = Math.Clamp(FieldOutput, 0, 21);
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ float valueScale = AbsVal ? 1.0f : 0.5f;
+ float outputMin = OutputMin;
+ float outputMax = OutputMax;
+ if ((ParticleInitUtil.ROTATION_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) {
+ outputMin *= ParticleInitUtil.DEG2RAD;
+ outputMax *= ParticleInitUtil.DEG2RAD;
+ }
+ float range = outputMax - outputMin;
+ float coordTime = (particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, firstParticle) + Offset) * NoiseScale;
+ float worldTime = (float)(uint)MSTime * WorldTimeScale;
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ Vector3 coord = (particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + OffsetLoc) * NoiseScaleLoc + new Vector3(worldTime + coordTime);
+ float noise = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z);
+ if (AbsVal)
+ noise = MathF.Abs(noise);
+ if (AbsValInv)
+ noise = 1.0f - noise;
+
+ float value = noise * range * valueScale + (1.0f - valueScale) * range + outputMin;
+ if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0)
+ value = Math.Clamp(value, 0.0f, 1.0f);
+ particles.GetFloatAttributeRefForWrite(FieldOutput, p) = value;
+ }
+ }
+}
+
+public sealed class C_INIT_AgeNoise : ParticleOperatorInstance
+{
+ public bool AbsVal;
+ public bool AbsValInv;
+ public float Offset;
+ public float AgeMin;
+ public float AgeMax;
+ public float NoiseScale;
+ public float NoiseScaleLoc;
+ public Vector3 OffsetLoc;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Lifetime Pre-Age Noise", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("time noise coordinate scale", "1.0", (o, v) => o.NoiseScale = v)
+ .Float("spatial noise coordinate scale", "1.0", (o, v) => o.NoiseScaleLoc = v)
+ .Float("time coordinate offset", "0", (o, v) => o.Offset = v)
+ .Vector3("spatial coordinate offset", "0 0 0", (o, v) => o.OffsetLoc = v)
+ .Bool("absolute value", "0", (o, v) => o.AbsVal = v)
+ .Bool("invert absolute value", "0", (o, v) => o.AbsValInv = v)
+ .Float("start age minimum", "0", (o, v) => o.AgeMin = v)
+ .Float("start age maximum", "1", (o, v) => o.AgeMax = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_CREATION_TIME_MASK;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ float valueScale = AbsVal ? 1.0f : 0.5f;
+ float range = AgeMax - AgeMin;
+
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ ref float creationTime = ref particles.GetFloatAttributeRefForWrite(PARTICLE_ATTRIBUTE_CREATION_TIME, p);
+ float coordTime = (creationTime + Offset) * NoiseScale;
+ Vector3 coord = (particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p) + OffsetLoc) * NoiseScaleLoc + new Vector3(coordTime);
+ float noise = NoiseSIMD.Noise(coord.X, coord.Y, coord.Z);
+ if (AbsVal)
+ noise = MathF.Abs(noise);
+ if (AbsValInv)
+ noise = 1.0f - noise;
+
+ float age = Math.Clamp(range * valueScale * noise + (1.0f - valueScale) * range + AgeMin, 0.0f, 1.0f);
+ creationTime -= age * particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_LIFE_DURATION, p);
+ }
+ }
+}
+
+public sealed class C_INIT_RemapScalar : ParticleOperatorInstance
+{
+ public int FieldInput;
+ public int FieldOutput;
+ public float InputMin;
+ public float InputMax;
+ public float OutputMin;
+ public float OutputMax;
+ public float StartTime;
+ public float EndTime;
+ public bool ScaleInitialRange;
+ public bool ActiveRange;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Remap Initial Scalar", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Float("emitter lifetime start time (seconds)", "-1", (o, v) => o.StartTime = v)
+ .Float("emitter lifetime end time (seconds)", "-1", (o, v) => o.EndTime = v)
+ .Int("input field", "8", (o, v) => o.FieldInput = v)
+ .Float("input minimum", "0", (o, v) => o.InputMin = v)
+ .Float("input maximum", "1", (o, v) => o.InputMax = v)
+ .Int("output field", "3", (o, v) => o.FieldOutput = v)
+ .Float("output minimum", "0", (o, v) => o.OutputMin = v)
+ .Float("output maximum", "1", (o, v) => o.OutputMax = v)
+ .Bool("output is scalar of initial random range", "0", (o, v) => o.ScaleInitialRange = v)
+ .Bool("only active within specified input range", "0", (o, v) => o.ActiveRange = v));
+
+ public override uint GetWrittenAttributes() => 1u << FieldOutput;
+ public override uint GetReadAttributes() => 1u << FieldInput;
+ public override bool InitMultipleOverride() => true;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ FieldInput = Math.Clamp(FieldInput, 0, 21);
+ if (FieldOutput < 0 || FieldOutput > 21) {
+ FieldOutput = Math.Clamp(FieldOutput, 0, 21);
+ return;
+ }
+ if ((ParticleInitUtil.ALPHA_ATTRIBUTES_MASK & (1 << FieldOutput)) != 0) {
+ OutputMin = Math.Clamp(OutputMin, 0.0f, 1.0f);
+ OutputMax = Math.Clamp(OutputMax, 0.0f, 1.0f);
+ }
+ }
+
+ public override void InitNewParticlesScalar(ParticleCollection particles, int firstParticle, int numParticles, int attributeWriteMask, Span context) {
+ for (int p = firstParticle; p < firstParticle + numParticles; p++) {
+ float creationTime = particles.GetFloatAttributeValue(PARTICLE_ATTRIBUTE_CREATION_TIME, p);
+ float input = ParticleInitUtil.ReadScalar(particles, FieldInput, p);
+ bool inTime = (StartTime <= creationTime && creationTime < EndTime) || StartTime == -1.0f || EndTime == -1.0f;
+ if (!inTime || (ActiveRange && (input < InputMin || input > InputMax)))
+ continue;
+
+ float output = ParticleInitUtil.RemapClamped(input, InputMin, InputMax, OutputMin, OutputMax);
+ if (ScaleInitialRange)
+ output *= ParticleInitUtil.ReadScalar(particles, FieldOutput, p);
+ ParticleInitUtil.WriteScalar(particles, FieldOutput, p, output);
+ }
+ }
+}
diff --git a/Source.Particles/BuiltinParticleOperators.ControlPoints.cs b/Source.Particles/BuiltinParticleOperators.ControlPoints.cs
new file mode 100644
index 000000000..4a5de7935
--- /dev/null
+++ b/Source.Particles/BuiltinParticleOperators.ControlPoints.cs
@@ -0,0 +1,41 @@
+using Datamodel;
+
+using System.Numerics;
+
+using static Source.Particles.ParticleConstants;
+
+namespace Source.Particles;
+
+public sealed class C_OP_DampenToCP : ParticleOperatorInstance
+{
+ public int ControlPointNumber;
+ public float Range;
+ public float Scale;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Movement Dampen Relative to Control Point", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)
+ .Float("falloff range", "100", (o, v) => o.Range = v)
+ .Float("dampen scale", "1", (o, v) => o.Scale = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_XYZ_MASK | PARTICLE_ATTRIBUTE_PREV_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK;
+ public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber;
+ public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber);
+
+ public override void Operate(ParticleCollection particles, float opStrength, Span context) {
+ if (Range <= 0.0f)
+ return;
+ Vector3 controlPoint = particles.GetControlPointAtCurrentTime(ControlPointNumber);
+ for (int p = 0; p < particles.ActiveParticles; p++) {
+ Vector3 position = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_XYZ, p);
+ float distance = (position - controlPoint).Length();
+ if (distance > Range)
+ continue;
+ float dampen = MathF.Pow(distance / Range, Scale);
+ Vector3 prev = particles.GetVectorAttributeValue(PARTICLE_ATTRIBUTE_PREV_XYZ, p);
+ Vector3 dampened = prev + (position - prev) * dampen;
+ particles.SetVectorAttribute(PARTICLE_ATTRIBUTE_XYZ, p, Vector3.Lerp(position, dampened, opStrength));
+ }
+ }
+}
diff --git a/Source.Particles/BuiltinParticleOperators.Movement.cs b/Source.Particles/BuiltinParticleOperators.Movement.cs
new file mode 100644
index 000000000..6ef3d214d
--- /dev/null
+++ b/Source.Particles/BuiltinParticleOperators.Movement.cs
@@ -0,0 +1,199 @@
+using Datamodel;
+
+using Source.Common;
+using Source.Common.Mathematics;
+
+using System.Numerics;
+using System.Runtime.Intrinsics;
+
+using static Source.Particles.ParticleConstants;
+
+namespace Source.Particles;
+
+public abstract class C_OP_GeneralSpin : ParticleOperatorInstance
+{
+ public int SpinRateDegrees;
+ public int SpinRateMinDegrees;
+ public float SpinRateStopTime;
+ float SpinRateRadians;
+ float SpinRateMinRadians;
+
+ protected abstract int AttributeToSpin { get; }
+
+ public override uint GetWrittenAttributes() => SpinRateDegrees != 0 ? 1u << AttributeToSpin : 0;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK;
+
+ public override void InitParams(ParticleSystemDefinition def, Element element) {
+ SpinRateRadians = SpinRateDegrees * 0.017453292f;
+ SpinRateMinRadians = SpinRateMinDegrees * 0.017453292f;
+ }
+
+ public override void Operate(ParticleCollection particles, float opStrength, Span context) {
+ float curSpinRate = SpinRateRadians * opStrength;
+ if (curSpinRate == 0.0f)
+ return;
+
+ float dt = particles.Dt;
+ float drot = MathF.Abs(curSpinRate * 2.0f * MathF.PI) * dt;
+ if (SpinRateStopTime == 0.0f)
+ drot = (float)(drot % (2.0 * Math.PI));
+ if (curSpinRate < 0.0f)
+ drot = -drot;
+
+ float minSpeed = MathF.Abs(SpinRateMinRadians * 2.0f * MathF.PI) * dt;
+ const float twoPi = 6.2831855f;
+ int attribute = AttributeToSpin;
+ int count = (particles.ActiveParticles + 3) & ~3;
+ for (int p = 0; p < count; p++) {
+ float ooFadeRate = 0.0f;
+ if (SpinRateStopTime != 0.0f)
+ ooFadeRate = 1.0f / (SpinRateStopTime * ParticleOpUtil.Lifetime(particles, p));
+ float scale = Math.Max(0.0f, 1.0f - ParticleOpUtil.Age(particles, p) * ooFadeRate);
+ float delta = drot * scale;
+ if (delta <= minSpeed)
+ delta = minSpeed;
+ ref float rot = ref particles.GetFloatAttributeRefForWrite(attribute, p);
+ float newRot = rot + delta;
+ float wrapped = newRot >= twoPi ? newRot - twoPi : newRot;
+ rot = newRot <= -twoPi ? wrapped + twoPi : wrapped;
+ }
+ }
+}
+
+public sealed class C_OP_Spin : C_OP_GeneralSpin
+{
+ protected override int AttributeToSpin => PARTICLE_ATTRIBUTE_ROTATION;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Rotation Spin Roll", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("spin_rate_degrees", "0", (o, v) => o.SpinRateDegrees = v)
+ .Float("spin_stop_time", "0", (o, v) => o.SpinRateStopTime = v)
+ .Int("spin_rate_min", "0", (o, v) => o.SpinRateMinDegrees = v));
+}
+
+public sealed class C_OP_PositionLock : ParticleOperatorInstance
+{
+ struct LockContext
+ {
+ public Vector3 PrevPosition;
+ public Matrix3x4 PrevTransform;
+ }
+
+ public int ControlPointNumber;
+ public float StartTimeMin;
+ public float StartTimeMax;
+ public float StartTimeExp;
+ public float EndTimeMin;
+ public float EndTimeMax;
+ public float EndTimeExp;
+ public float Range;
+ public bool LockRot;
+
+ public static readonly ParticleOperatorDefinition Definition = new("Movement Lock to Control Point", ParticleOperatorId.Generic, false,
+ ParticleOperatorUnpack.Begin()
+ .Int("control_point_number", "0", (o, v) => o.ControlPointNumber = v)
+ .Float("start_fadeout_min", "1", (o, v) => o.StartTimeMin = v)
+ .Float("start_fadeout_max", "1", (o, v) => o.StartTimeMax = v)
+ .Float("start_fadeout_exponent", "1", (o, v) => o.StartTimeExp = v)
+ .Float("end_fadeout_min", "1", (o, v) => o.EndTimeMin = v)
+ .Float("end_fadeout_max", "1", (o, v) => o.EndTimeMax = v)
+ .Float("end_fadeout_exponent", "1", (o, v) => o.EndTimeExp = v)
+ .Float("distance fade range", "0", (o, v) => o.Range = v)
+ .Bool("lock rotation", "0", (o, v) => o.LockRot = v));
+
+ public override uint GetWrittenAttributes() => PARTICLE_ATTRIBUTE_PREV_XYZ_MASK | PARTICLE_ATTRIBUTE_XYZ_MASK;
+ public override uint GetReadAttributes() => PARTICLE_ATTRIBUTE_CREATION_TIME_MASK | PARTICLE_ATTRIBUTE_LIFE_DURATION_MASK | PARTICLE_ATTRIBUTE_PARTICLE_ID_MASK;
+ public override ulong GetReadControlPointMask() => 1UL << ControlPointNumber;
+ public override void InitParams(ParticleSystemDefinition def, Element element) => ControlPointNumber = ParticleOpUtil.ClampCP(ControlPointNumber);
+ public override int GetRequiredContextBytes() => System.Runtime.CompilerServices.Unsafe.SizeOf();
+
+ public override void InitializeContextData(ParticleCollection particles, Span