@godot-scene-web/effects 0.1.0

package/dist/particles-CQC9BFSI.js

@@ -0,0 +1,757 @@
+//#region src/particles/godot-renderer.ts
+/** The default backend: Godot's own default for a new project. */
+const DEFAULT_GODOT_RENDERER = "forward_plus";
+/** Coerce an untrusted value (a hand-authored spec blob, a consumer option) to a backend. */
+function normalizeGodotRenderer(value) {
+	return value === "mobile" || value === "gl_compatibility" || value === "forward_plus" ? value : DEFAULT_GODOT_RENDERER;
+}
+/**
+* True when the backend runs `ParticleProcessMaterial.color` through
+* `Color::srgb_to_linear()` at UBO-upload time. Both RendererRD backends do;
+* Compatibility/GLES3 does not.
+*/
+function linearizesParticleColor(renderer) {
+	return renderer !== "gl_compatibility";
+}
+/**
+* Godot's `Color::srgb_to_linear()`, one channel — `core/math/color.h:191-197`:
+*
+* ```cpp
+* r < 0.04045f ? r * (1.0f / 12.92f)
+*              : Math::pow(float((r + 0.055) * (1.0 / (1.0 + 0.055))), 2.4f)
+* ```
+*
+* The piecewise IEC 61966-2-1 curve with exponent **2.4**, not a `pow(x, 2.2)`
+* approximation, and the threshold comparison is strict `<`. Written here the way Godot
+* writes it — reciprocal multiplies rather than divides — so the two read the same;
+* Godot evaluates the inner expression in double and then narrows to float before
+* `pow`, while JS stays in double throughout, a difference orders of magnitude below
+* the 1/255 the comparison is made at.
+*
+* Note the fixed point at both ends: `srgbToLinear(0) === 0` and `srgbToLinear(1) === 1`.
+* A fully saturated channel is where this curve is the identity, which is why it is the
+* per-channel regression check on the parity fixture (see `docs/parity.md`).
+*/
+function srgbToLinear(value) {
+	return value < .04045 ? value * (1 / 12.92) : ((value + .055) * (1 / 1.055)) ** 2.4;
+}
+/**
+* A particle system's base colour as the given backend uploads it: RGB through
+* {@link srgbToLinear} on the RendererRD backends, returned unchanged on
+* Compatibility/GLES3.
+*
+* `fromProcessMaterial` is the scope gate. Only `ParticleProcessMaterial.color` — a
+* `GPUParticles2D` with a process material — rides the UBO path that linearizes. When the
+* base colour instead came from `CPUParticles2D.color` or the node's `modulate`, it reaches
+* the canvas by a route Godot leaves in sRGB whatever the backend, and this returns it
+* untouched.
+*
+* **ALPHA IS NEVER TOUCHED.** `Color::srgb_to_linear()` passes `a` straight through
+* (`color.h:196`), so the coverage the blend algebra runs on is the authored value on
+* every backend and every path.
+*
+* Always returns a fresh tuple, so callers never alias the raw colour they passed in.
+*/
+function linearizeParticleBaseColor(color, renderer, fromProcessMaterial) {
+	return fromProcessMaterial && linearizesParticleColor(renderer) ? [
+		srgbToLinear(color[0]),
+		srgbToLinear(color[1]),
+		srgbToLinear(color[2]),
+		color[3]
+	] : [
+		color[0],
+		color[1],
+		color[2],
+		color[3]
+	];
+}
+//#endregion
+//#region src/particles/instance-buffer.ts
+/** Floats per particle render instance: center.xy, scale.xy, rotation, color.rgba, frame. */
+const INSTANCE_STRIDE = 10;
+/**
+* CPU-owned packed particle instances. This class deliberately knows nothing about
+* WebGL, WebGPU, a canvas, or a device lifecycle; render adapters own residency.
+*/
+var InstanceBuffer = class {
+	data;
+	/** Number of instances written since the last reset. */
+	count = 0;
+	capacity;
+	constructor(initialCapacity = 256) {
+		this.capacity = Math.max(1, initialCapacity);
+		this.data = new Float32Array(this.capacity * 10);
+	}
+	reset() {
+		this.count = 0;
+	}
+	push(x, y, scaleX, scaleY, rotation, r, g, b, a, frame) {
+		this.ensureCapacity(this.count + 1);
+		const offset = this.count * 10;
+		const data = this.data;
+		data[offset] = x;
+		data[offset + 1] = y;
+		data[offset + 2] = scaleX;
+		data[offset + 3] = scaleY;
+		data[offset + 4] = rotation;
+		data[offset + 5] = r;
+		data[offset + 6] = g;
+		data[offset + 7] = b;
+		data[offset + 8] = a;
+		data[offset + 9] = frame;
+		this.count += 1;
+	}
+	ensureCapacity(instances) {
+		if (instances <= this.capacity) return;
+		let next = this.capacity;
+		while (next < instances) next *= 2;
+		const grown = new Float32Array(next * 10);
+		grown.set(this.data);
+		this.data = grown;
+		this.capacity = next;
+	}
+};
+//#endregion
+//#region src/particles/pack-instances.ts
+/** The sprite-sheet grid used for a texture; untextured particles always have one frame. */
+function frameGridFor(textured, hframes, vframes) {
+	return textured ? [Math.max(1, hframes), Math.max(1, vframes)] : [1, 1];
+}
+/** Pack live particle state into a caller-owned, reusable GPU instance buffer. */
+function packParticleInstances(input) {
+	const { state, config, instances } = input;
+	const originX = input.origin?.[0] ?? 0;
+	const originY = input.origin?.[1] ?? 0;
+	const frameW = config.flipbookCropOnly ? input.textureWidth : input.textureWidth / Math.max(1, config.hframes);
+	const frameH = config.flipbookCropOnly ? input.textureHeight : input.textureHeight / Math.max(1, config.vframes);
+	const transform = input.transform;
+	const modulate = input.modulate;
+	const xx = transform?.xx ?? 1, xy = transform?.xy ?? 0, yx = transform?.yx ?? 0, yy = transform?.yy ?? 1;
+	const tx = transform?.originX ?? 0, ty = transform?.originY ?? 0;
+	const scale = transform?.scale ?? 1, rotation = transform?.rotation ?? 0;
+	const mr = modulate?.[0] ?? 1, mg = modulate?.[1] ?? 1, mb = modulate?.[2] ?? 1, ma = modulate?.[3] ?? 1;
+	instances.reset();
+	for (let i = 0; i < state.particles.length; i += 1) {
+		const p = state.particles[i];
+		if (!(p.active && p.a > 0)) continue;
+		const localX = originX + p.x, localY = originY + p.y;
+		instances.push(xx * localX + yx * localY + tx, xy * localX + yy * localY + ty, Math.max(0, frameW * p.scaleX * scale), Math.max(0, frameH * p.scaleY * scale), p.rotation + rotation, p.r * mr, p.g * mg, p.b * mb, p.a * ma, p.frame);
+	}
+	return instances.count;
+}
+//#endregion
+//#region src/particles/sampling.ts
+function lerp$1(a, b, t) {
+	return a + (b - a) * t;
+}
+/** Godot-style endpoint-clamped gradient sampling. */
+function sampleParticleGradient(stops, t, interpolationMode = 0) {
+	if (stops.length === 0) return [
+		0,
+		0,
+		0,
+		1
+	];
+	if (t <= stops[0].offset) return stops[0].color;
+	const last = stops[stops.length - 1];
+	if (t >= last.offset) return last.color;
+	for (let index = 0; index < stops.length - 1; index += 1) {
+		const a = stops[index];
+		const b = stops[index + 1];
+		if (t >= a.offset && t <= b.offset) {
+			if (interpolationMode === 1) return a.color;
+			const fraction = (t - a.offset) / (b.offset - a.offset || 1);
+			return [
+				lerp$1(a.color[0], b.color[0], fraction),
+				lerp$1(a.color[1], b.color[1], fraction),
+				lerp$1(a.color[2], b.color[2], fraction),
+				lerp$1(a.color[3], b.color[3], fraction)
+			];
+		}
+	}
+	return last.color;
+}
+/** Allocation-free gradient sampling for simulation hot paths. */
+function sampleParticleGradientInto(stops, t, out, interpolationMode = 0) {
+	if (stops.length === 0) {
+		out[0] = 0;
+		out[1] = 0;
+		out[2] = 0;
+		out[3] = 1;
+		return;
+	}
+	let a = stops[0];
+	if (t <= a.offset) {
+		out[0] = a.color[0];
+		out[1] = a.color[1];
+		out[2] = a.color[2];
+		out[3] = a.color[3];
+		return;
+	}
+	const last = stops[stops.length - 1];
+	if (t >= last.offset) {
+		out[0] = last.color[0];
+		out[1] = last.color[1];
+		out[2] = last.color[2];
+		out[3] = last.color[3];
+		return;
+	}
+	for (let index = 0; index < stops.length - 1; index += 1) {
+		a = stops[index];
+		const b = stops[index + 1];
+		if (t >= a.offset && t <= b.offset) {
+			const f = interpolationMode === 1 ? 0 : (t - a.offset) / (b.offset - a.offset || 1);
+			out[0] = lerp$1(a.color[0], b.color[0], f);
+			out[1] = lerp$1(a.color[1], b.color[1], f);
+			out[2] = lerp$1(a.color[2], b.color[2], f);
+			out[3] = lerp$1(a.color[3], b.color[3], f);
+			return;
+		}
+	}
+	out[0] = last.color[0];
+	out[1] = last.color[1];
+	out[2] = last.color[2];
+	out[3] = last.color[3];
+}
+/** Godot-style endpoint-clamped linear curve sampling. */
+function sampleParticleCurve(points, t) {
+	if (points.length === 0) return 0;
+	if (t <= points[0].x) return points[0].y;
+	const last = points[points.length - 1];
+	if (t >= last.x) return last.y;
+	for (let index = 0; index < points.length - 1; index += 1) {
+		const a = points[index];
+		const b = points[index + 1];
+		if (t >= a.x && t <= b.x) return lerp$1(a.y, b.y, (t - a.x) / (b.x - a.x || 1));
+	}
+	return last.y;
+}
+function normalizeParticleCurve(points) {
+	return points?.filter((point) => Number.isFinite(point.x) && Number.isFinite(point.y)).slice().sort((a, b) => a.x - b.x);
+}
+//#endregion
+//#region src/particles/simulate.ts
+const TAU = Math.PI * 2;
+const DEG2RAD = Math.PI / 180;
+function lerp(a, b, t) {
+	return a + (b - a) * t;
+}
+function clamp01$1(value) {
+	return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function randFromSeed(holder) {
+	let s = holder.seed | 0;
+	if (s === 0) s = 305420679;
+	const k = Math.trunc(s / 127773);
+	s = 16807 * (s - k * 127773) - 2836 * k;
+	if (s < 0) s += 2147483647;
+	holder.seed = s >>> 0;
+	return holder.seed % 65536 / 65535;
+}
+const spawnRng = { seed: 1 };
+const forceRng = { seed: 1 };
+const displayColor = [
+	1,
+	1,
+	1,
+	1
+];
+function mixSeed(s) {
+	return Math.imul(s >>> 0 ^ 2654435769, 2654435761) >>> 0;
+}
+function hash01(i, seed) {
+	let h = Math.imul(i + 1 ^ (seed | 0), 2654435761) >>> 0;
+	h ^= h >>> 15;
+	h = Math.imul(h, 2246822519) >>> 0;
+	h ^= h >>> 13;
+	return (h >>> 0) / 4294967296;
+}
+function hueRotateInto(p, r, g, b, angle) {
+	const c = Math.cos(angle);
+	const s = Math.sin(angle);
+	const rr = r * (.299 + .701 * c + .168 * s) + g * (.587 - .587 * c + .33 * s) + b * (.114 - .114 * c - .497 * s);
+	const gg = r * (.299 - .299 * c - .328 * s) + g * (.587 + .413 * c + .035 * s) + b * (.114 - .114 * c + .292 * s);
+	const bb = r * (.299 - .3 * c + 1.25 * s) + g * (.587 - .588 * c - 1.05 * s) + b * (.114 + .886 * c - .203 * s);
+	p.r = rr;
+	p.g = gg;
+	p.b = bb;
+}
+function sampleEmissionInto(cfg, p) {
+	let x = 0;
+	let y = 0;
+	const shape = cfg.emissionShape;
+	if (shape === 1 || shape === 2) {
+		const a = randFromSeed(spawnRng) * TAU;
+		const r = cfg.emissionSphereRadius * Math.sqrt(randFromSeed(spawnRng));
+		x = Math.cos(a) * r;
+		y = Math.sin(a) * r;
+	} else if (shape === 3) {
+		x = (randFromSeed(spawnRng) * 2 - 1) * cfg.emissionBoxExtents[0];
+		y = (randFromSeed(spawnRng) * 2 - 1) * cfg.emissionBoxExtents[1];
+	} else if (shape === 6) {
+		const a = randFromSeed(spawnRng) * TAU;
+		const outer = Math.max(cfg.emissionRingRadius, cfg.emissionRingInnerRadius, 1e-4);
+		const inner = Math.max(0, Math.min(cfg.emissionRingInnerRadius, outer));
+		const r = Math.sqrt(randFromSeed(spawnRng) * (outer * outer - inner * inner) + inner * inner);
+		x = Math.cos(a) * r;
+		y = Math.sin(a) * r;
+	}
+	p.x = x * cfg.emissionScale[0] + cfg.emissionOffset[0];
+	p.y = y * cfg.emissionScale[1] + cfg.emissionOffset[1];
+}
+function restartPhase(cfg, i) {
+	let rp = cfg.amount > 0 ? i / cfg.amount : 0;
+	if (cfg.randomness > 0) rp += cfg.randomness * hash01(i, cfg.seed) / cfg.amount;
+	return rp * (1 - cfg.explosiveness);
+}
+function restartParticle(state, i, cycle) {
+	const cfg = state.config;
+	const p = state.particles[i];
+	const baseSeed = cfg.seed + i * 2 + cycle >>> 0;
+	p.seed = baseSeed || 1;
+	spawnRng.seed = mixSeed(baseSeed) || 1;
+	p.angleRand = randFromSeed(spawnRng);
+	p.scaleRand = randFromSeed(spawnRng);
+	p.hueRand = randFromSeed(spawnRng);
+	p.animOffsetRand = randFromSeed(spawnRng);
+	if (cfg.colorInitialRamp?.length) sampleParticleGradientInto(cfg.colorInitialRamp, randFromSeed(spawnRng), p.startColor);
+	else {
+		p.startColor[0] = 1;
+		p.startColor[1] = 1;
+		p.startColor[2] = 1;
+		p.startColor[3] = 1;
+	}
+	const angle = Math.atan2(cfg.direction[1], cfg.direction[0]) + (randFromSeed(spawnRng) * 2 - 1) * cfg.spread * DEG2RAD;
+	const speed = lerp(cfg.initialVelocityMin, cfg.initialVelocityMax, randFromSeed(spawnRng));
+	p.vx = Math.cos(angle) * speed;
+	p.vy = Math.sin(angle) * speed;
+	p.rotation = lerp(cfg.angleMin, cfg.angleMax, p.angleRand) * DEG2RAD;
+	if (cfg.alignY) {
+		if (Math.hypot(p.vx, p.vy) > 0) p.rotation = Math.atan2(p.vy, p.vx) + Math.PI / 2;
+	}
+	p.lifetime = Math.max(.01, cfg.lifetime * (1 - randFromSeed(spawnRng) * cfg.lifetimeRandomness));
+	sampleEmissionInto(cfg, p);
+	p.time = 0;
+	p.active = true;
+	updateDisplay(cfg, p, 0);
+}
+function updateDisplay(cfg, p, tv) {
+	let sx = 1;
+	let sy = 1;
+	if (cfg.scaleCurveX && cfg.scaleCurveX.length > 0 || cfg.scaleCurveY && cfg.scaleCurveY.length > 0) {
+		sx = cfg.scaleCurveX?.length ? sampleParticleCurve(cfg.scaleCurveX, tv) : 1;
+		sy = cfg.scaleCurveY?.length ? sampleParticleCurve(cfg.scaleCurveY, tv) : 1;
+	} else if (cfg.scaleCurve && cfg.scaleCurve.length > 0) {
+		sx = sampleParticleCurve(cfg.scaleCurve, tv);
+		sy = sx;
+	}
+	const base = lerp(cfg.scaleMin, cfg.scaleMax, p.scaleRand);
+	p.scaleX = Math.max(1e-5, sx * base);
+	p.scaleY = Math.max(1e-5, sy * base);
+	if (cfg.colorRamp?.length) sampleParticleGradientInto(cfg.colorRamp, tv, displayColor);
+	else {
+		displayColor[0] = 1;
+		displayColor[1] = 1;
+		displayColor[2] = 1;
+		displayColor[3] = 1;
+	}
+	let r = displayColor[0];
+	let g = displayColor[1];
+	let b = displayColor[2];
+	let a = displayColor[3];
+	r *= cfg.baseColorRender[0];
+	g *= cfg.baseColorRender[1];
+	b *= cfg.baseColorRender[2];
+	a *= cfg.baseColorRender[3];
+	if (cfg.alphaCurve && cfg.alphaCurve.length > 0) a *= sampleParticleCurve(cfg.alphaCurve, tv);
+	const hueMag = lerp(cfg.hueVariationMin, cfg.hueVariationMax, p.hueRand) * (cfg.hueCurve && cfg.hueCurve.length > 0 ? sampleParticleCurve(cfg.hueCurve, tv) : 1);
+	if (hueMag !== 0) {
+		hueRotateInto(p, r, g, b, hueMag * TAU);
+		r = p.r;
+		g = p.g;
+		b = p.b;
+	}
+	p.r = r * p.startColor[0];
+	p.g = g * p.startColor[1];
+	p.b = b * p.startColor[2];
+	p.a = a * p.startColor[3];
+	const cells = cfg.hframes * cfg.vframes;
+	const total = cfg.frameCount && cfg.frameCount > 0 ? cfg.frameCount : cells;
+	if (cells > 1) {
+		const animSpeed = lerp(cfg.animSpeedMin, cfg.animSpeedMax, p.animOffsetRand);
+		const phase = lerp(cfg.animOffsetMin, cfg.animOffsetMax, p.animOffsetRand) + tv * animSpeed;
+		const f = cfg.animLoop ? phase - Math.floor(phase) : clamp01$1(phase);
+		p.frame = Math.min(total - 1, Math.max(0, Math.floor(f * total))) % cells;
+	} else p.frame = 0;
+}
+function integrate(cfg, p, dt) {
+	p.time += dt;
+	if (p.time >= p.lifetime) {
+		p.active = false;
+		return;
+	}
+	const tv = p.time / p.lifetime;
+	forceRng.seed = p.seed;
+	let fx = cfg.gravity[0];
+	let fy = cfg.gravity[1];
+	const speed = Math.hypot(p.vx, p.vy);
+	const la = lerp(cfg.linearAccelMin, cfg.linearAccelMax, randFromSeed(forceRng));
+	if (speed > 0 && la !== 0) {
+		fx += p.vx / speed * la;
+		fy += p.vy / speed * la;
+	}
+	const dlen = Math.hypot(p.x, p.y);
+	const ra = lerp(cfg.radialAccelMin, cfg.radialAccelMax, randFromSeed(forceRng));
+	if (dlen > 0 && ra !== 0) {
+		fx += p.x / dlen * ra;
+		fy += p.y / dlen * ra;
+	}
+	const ta = lerp(cfg.tangentialAccelMin, cfg.tangentialAccelMax, randFromSeed(forceRng));
+	if (dlen > 0 && ta !== 0) {
+		fx += -p.y / dlen * ta;
+		fy += p.x / dlen * ta;
+	}
+	p.vx += fx * dt;
+	p.vy += fy * dt;
+	const orbit = lerp(cfg.orbitVelocityMin, cfg.orbitVelocityMax, randFromSeed(forceRng));
+	if (orbit !== 0) {
+		const a = -orbit * dt * TAU;
+		const cos = Math.cos(a);
+		const sin = Math.sin(a);
+		const nx = p.x * cos - p.y * sin;
+		const ny = p.x * sin + p.y * cos;
+		p.x = nx;
+		p.y = ny;
+	}
+	const damp = lerp(cfg.dampingMin, cfg.dampingMax, randFromSeed(forceRng));
+	if (damp > 0) {
+		const cur = Math.hypot(p.vx, p.vy);
+		if (cur > 0) {
+			const dec = cfg.dampingAsFriction ? cur * damp * .05 * dt : damp * dt;
+			const v = Math.max(0, cur - dec);
+			p.vx = p.vx / cur * v;
+			p.vy = p.vy / cur * v;
+		}
+	}
+	const av = lerp(cfg.angularVelocityMin, cfg.angularVelocityMax, randFromSeed(forceRng));
+	p.rotation = (lerp(cfg.angleMin, cfg.angleMax, p.angleRand) + p.time * av) * DEG2RAD;
+	p.x += p.vx * dt;
+	p.y += p.vy * dt;
+	if (cfg.alignY) {
+		if (Math.hypot(p.vx, p.vy) > 0) p.rotation = Math.atan2(p.vy, p.vx) + Math.PI / 2;
+	}
+	updateDisplay(cfg, p, tv);
+}
+function step(state, dt) {
+	const cfg = state.config;
+	const lifetime = cfg.lifetime;
+	const prevTime = state.time;
+	let time = prevTime + dt;
+	if (time >= lifetime) {
+		const cycles = Math.floor(time / lifetime);
+		state.cycle += cycles;
+		time -= cycles * lifetime;
+		if (cfg.oneShot) state.emitting = false;
+	}
+	state.time = time;
+	const count = state.count;
+	for (let i = 0; i < count; i += 1) {
+		const p = state.particles[i];
+		if (state.emitting) {
+			const restartTime = restartPhase(cfg, i) * lifetime;
+			if (time > prevTime ? restartTime >= prevTime && restartTime < time : restartTime >= prevTime || restartTime < time) restartParticle(state, i, state.cycle);
+		}
+		if (p.active) integrate(cfg, p, dt);
+	}
+}
+/**
+* Advance the system by `dt` seconds (real time), stepping the simulation in fixed
+* `1/fixed_fps` (or 1/30) chunks so the look is frame-rate independent. Mutates
+* `state` in place. `maxSteps` bounds the loop (warm-up / tab-switch spikes).
+*
+* Returns the number of fixed sub-steps it actually executed — the unit of work this function
+* does, and the only honest denominator for its cost: one display frame can run zero steps (a
+* fast display under a 30Hz `fixed_fps`, or `speed_scale: 0`) or many (a long dt, a warm-up), so
+* a profiler that divided wall-clock by FRAMES would be measuring the display, not the sim (see
+* `ParticleProfile.simSteps` in `./runtime`). Purely additive: every caller may ignore it, and
+* this function stays pure of any clock.
+*/
+function simulateParticles(state, dt, maxSteps = 1e3) {
+	if (!(dt > 0)) return 0;
+	const cfg = state.config;
+	const frameTime = cfg.fixedFps > 0 ? 1 / cfg.fixedFps : 1 / 30;
+	state.remainder += dt * cfg.speedScale;
+	let steps = 0;
+	while (state.remainder >= frameTime && steps < maxSteps) {
+		step(state, frameTime);
+		state.remainder -= frameTime;
+		steps += 1;
+	}
+	return steps;
+}
+/**
+* Warm-start a freshly created system by its `preprocess` time (Godot pre-simulates
+* that much before first draw, so a long-lived ambient — fog with preprocess=100 —
+* appears mid-drift instead of empty/bursty). A REPEATING system reaches its steady
+* state within two lifetime cycles (a particle's look depends on its age, not absolute
+* time), so simulating `min(preprocess, 2 x lifetime)` is visually identical to the
+* full preprocess at bounded cost; a one-shot's whole life fits in that window too.
+* Steps are sized to cover the window (the default `maxSteps` caps at ~33s), and the
+* sub-step remainder is dropped so the leftover doesn't fast-forward the first live
+* frames at ~1000 steps per tick.
+*/
+function preprocessParticles(state) {
+	const cfg = state.config;
+	if (cfg.preprocess <= 0) return;
+	const warm = Math.min(cfg.preprocess, cfg.lifetime * 2);
+	const stepHz = cfg.fixedFps > 0 ? cfg.fixedFps : 30;
+	simulateParticles(state, warm, Math.ceil(warm * stepHz) + 2);
+	state.remainder = 0;
+}
+const STATIC_WARM_ONESHOT_FRACTION = .4;
+const STATIC_WARM_REPEAT_FRACTION = 1;
+/**
+* Warm a system to a representative FROZEN state for the runtime's static/particles mode. Reuses the authored
+* `preprocess` (an ambient emitter with preprocess>0 reaches its steady drift — identical to `preprocessParticles`),
+* and for a system that would otherwise sit at spawn (preprocess<=0, e.g. a one-shot burst or an un-preprocessed
+* emitter) advances a representative slice of a lifetime so the frozen frame is populated. Mutates `state`; the
+* caller draws once and then stops simulating (see the particle runtime's static mode).
+*
+* This warm has no notion of the burst ENDING — it is a single representative frame, so a one-shot warmed here
+* would otherwise be drawn as mid-flight forever. `staticOneShotExpired` is what retires it.
+*/
+function warmStaticParticles(state) {
+	const cfg = state.config;
+	if (cfg.preprocess > 0) {
+		preprocessParticles(state);
+		return;
+	}
+	const warm = cfg.lifetime * (cfg.oneShot ? STATIC_WARM_ONESHOT_FRACTION : STATIC_WARM_REPEAT_FRACTION);
+	const stepHz = cfg.fixedFps > 0 ? cfg.fixedFps : 30;
+	simulateParticles(state, warm, Math.ceil(warm * stepHz) + 2);
+	state.remainder = 0;
+}
+/**
+* Godot's own ACTIVE WINDOW for one one-shot cycle, in seconds: `lifetime * (2 - explosiveness)`
+* (particles.cpp `active_time`). At explosiveness 1 every particle is born at t=0, so the cycle is one
+* lifetime; at 0 the births are spread over a full lifetime, so the last particle dies at 2x lifetime.
+*
+* This is the SAME law the game-side mod uses to schedule a frozen one-shot's synthesized end-of-burst
+* (`CouchCoopHeadlessVisualSuspender.FinishNudgeDelaySeconds`), deliberately: the two sides have to agree on
+* when a burst is over, or one of them keeps drawing/reporting it after the other has stopped. No clamp and no
+* margin here — the mod's margin exists so its removal delta lands AFTER the client's tail, and this side IS
+* that tail. `normalizeParticleConfig` already guarantees a finite `lifetime >= 0.01` and `explosiveness` in
+* [0,1], so the result is finite and positive.
+*
+* `speedScale` is deliberately NOT folded in, for the same reason: the mod's law does not either, and a
+* disagreement would be worse than the (rare, small) inaccuracy of a re-timed burst.
+*/
+function oneShotBurstSeconds(cfg) {
+	return cfg.lifetime * (2 - cfg.explosiveness);
+}
+/**
+* FROZEN-MODE expiry decision: has a one-shot burst the client has been drawing statically outlived its own
+* active window, so the runtime should stop drawing it? Pure (no clock, no DOM) — the caller supplies the
+* seconds elapsed since IT first saw this system emitting.
+*
+* WHY THIS EXISTS. In frozen/static mode a system is warmed to a representative mid-flight frame and that frame
+* is parked forever — which is right for an ambient emitter (it really does emit forever) and wrong for a
+* one-shot (it is a BURST; it ends). Nothing else can retire it: the frozen runtime never simulates, so the
+* sim's own end-of-cycle never runs, and the only other input is the host's `emitting` flag — which a host can
+* get stuck on (the live case: a game-side freeze left `Emitting` latched true on every energy-counter VFX, so
+* the mirror drew a permanent "energy ring" over a counter the game was showing bare).
+*
+* WHY "since FIRST SIGHT". The client cannot know when the game started the burst — it sees only "this spec
+* says emitting". One full active window from first sight is exactly what the burst itself would do, so a
+* legitimate transient (a hit spark, a card-play flourish) still shows for its natural life; only a burst that
+* outlives its own window — i.e. one nothing ever turned off — is dropped.
+*/
+function staticOneShotExpired(cfg, secondsSinceFirstEmitting) {
+	if (!cfg.oneShot || !cfg.emitting) return false;
+	return secondsSinceFirstEmitting >= oneShotBurstSeconds(cfg);
+}
+/** Live particle count (for tests / draw). */
+function activeParticleCount(state) {
+	let n = 0;
+	for (const p of state.particles) if (p.active) n += 1;
+	return n;
+}
+//#endregion
+//#region src/particles/state.ts
+function makeParticle() {
+	return {
+		active: false,
+		time: 0,
+		lifetime: 1,
+		x: 0,
+		y: 0,
+		vx: 0,
+		vy: 0,
+		rotation: 0,
+		seed: 0,
+		angleRand: 0,
+		scaleRand: 0,
+		hueRand: 0,
+		animOffsetRand: 0,
+		startColor: [
+			1,
+			1,
+			1,
+			1
+		],
+		scaleX: 1,
+		scaleY: 1,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1,
+		frame: 0
+	};
+}
+const DEFAULT_MAX_INSTANCES = 2048;
+function createParticleState(config, maxInstances = DEFAULT_MAX_INSTANCES) {
+	const count = Math.max(1, Math.min(maxInstances, Math.round(config.amount)));
+	const particles = [];
+	for (let i = 0; i < count; i += 1) particles.push(makeParticle());
+	return {
+		config,
+		particles,
+		time: 0,
+		cycle: 0,
+		emitting: config.emitting,
+		remainder: 0,
+		count
+	};
+}
+/** Whether the system still needs simulating (live particles or still emitting). */
+function particlesAreLive(state) {
+	if (state.emitting) return true;
+	for (const p of state.particles) if (p.active) return true;
+	return false;
+}
+function num(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function bool(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function vec2(value, fallback) {
+	return Array.isArray(value) && value.length >= 2 && typeof value[0] === "number" && typeof value[1] === "number" ? [value[0], value[1]] : fallback;
+}
+function rgba(value, fallback) {
+	return Array.isArray(value) && value.length >= 4 ? [
+		num(value[0], fallback[0]),
+		num(value[1], fallback[1]),
+		num(value[2], fallback[2]),
+		num(value[3], fallback[3])
+	] : fallback;
+}
+function normalizeParticleConfig(raw) {
+	const c = raw ?? {};
+	const kind = c.kind === "CPUParticles2D" ? "CPUParticles2D" : "GPUParticles2D";
+	const godotRenderer = normalizeGodotRenderer(c.godotRenderer);
+	const baseColor = rgba(c.baseColor, [
+		1,
+		1,
+		1,
+		1
+	]);
+	const baseColorFromProcessMaterial = typeof c.baseColorFromProcessMaterial === "boolean" ? c.baseColorFromProcessMaterial : kind === "GPUParticles2D";
+	return {
+		kind,
+		godotRenderer,
+		amount: Math.max(1, Math.round(num(c.amount, 8))),
+		amountRatio: clamp01(num(c.amountRatio, 1)),
+		lifetime: Math.max(.01, num(c.lifetime, 1)),
+		lifetimeRandomness: clamp01(num(c.lifetimeRandomness, 0)),
+		oneShot: bool(c.oneShot, false),
+		emitting: bool(c.emitting, true),
+		explosiveness: clamp01(num(c.explosiveness, 0)),
+		randomness: clamp01(num(c.randomness, 0)),
+		preprocess: Math.max(0, num(c.preprocess, 0)),
+		speedScale: num(c.speedScale, 1),
+		fixedFps: Math.max(0, Math.round(num(c.fixedFps, 0))),
+		localCoords: bool(c.localCoords, false),
+		drawOrder: Math.round(num(c.drawOrder, 0)),
+		seed: Math.round(num(c.seed, 0)),
+		emissionShape: Math.round(num(c.emissionShape, 0)),
+		emissionOffset: vec2(c.emissionOffset, [0, 0]),
+		emissionScale: vec2(c.emissionScale, [1, 1]),
+		emissionSphereRadius: num(c.emissionSphereRadius, 0),
+		emissionRingRadius: num(c.emissionRingRadius, 0),
+		emissionRingInnerRadius: num(c.emissionRingInnerRadius, 0),
+		emissionRingHeight: num(c.emissionRingHeight, 0),
+		emissionBoxExtents: vec2(c.emissionBoxExtents, [0, 0]),
+		direction: vec2(c.direction, [1, 0]),
+		spread: num(c.spread, 45),
+		initialVelocityMin: num(c.initialVelocityMin, 0),
+		initialVelocityMax: num(c.initialVelocityMax, 0),
+		angleMin: num(c.angleMin, 0),
+		angleMax: num(c.angleMax, 0),
+		angularVelocityMin: num(c.angularVelocityMin, 0),
+		angularVelocityMax: num(c.angularVelocityMax, 0),
+		gravity: vec2(c.gravity, [0, 980]),
+		linearAccelMin: num(c.linearAccelMin, 0),
+		linearAccelMax: num(c.linearAccelMax, 0),
+		radialAccelMin: num(c.radialAccelMin, 0),
+		radialAccelMax: num(c.radialAccelMax, 0),
+		tangentialAccelMin: num(c.tangentialAccelMin, 0),
+		tangentialAccelMax: num(c.tangentialAccelMax, 0),
+		dampingMin: num(c.dampingMin, 0),
+		dampingMax: num(c.dampingMax, 0),
+		dampingAsFriction: bool(c.dampingAsFriction, false),
+		orbitVelocityMin: num(c.orbitVelocityMin, 0),
+		orbitVelocityMax: num(c.orbitVelocityMax, 0),
+		scaleMin: num(c.scaleMin, 1),
+		scaleMax: num(c.scaleMax, 1),
+		hueVariationMin: num(c.hueVariationMin, 0),
+		hueVariationMax: num(c.hueVariationMax, 0),
+		alignY: bool(c.alignY, false),
+		baseColor,
+		baseColorFromProcessMaterial,
+		baseColorRender: linearizeParticleBaseColor(baseColor, godotRenderer, baseColorFromProcessMaterial),
+		hframes: Math.max(1, Math.round(num(c.hframes, 1))),
+		vframes: Math.max(1, Math.round(num(c.vframes, 1))),
+		frameCount: Math.max(0, Math.round(num(c.frameCount, 0))),
+		animLoop: bool(c.animLoop, false),
+		animSpeedMin: num(c.animSpeedMin, 0),
+		animSpeedMax: num(c.animSpeedMax, 0),
+		animOffsetMin: num(c.animOffsetMin, 0),
+		animOffsetMax: num(c.animOffsetMax, 0),
+		colorRamp: c.colorRamp,
+		colorInitialRamp: c.colorInitialRamp,
+		scaleCurve: normalizeParticleCurve(c.scaleCurve),
+		scaleCurveX: normalizeParticleCurve(c.scaleCurveX),
+		scaleCurveY: normalizeParticleCurve(c.scaleCurveY),
+		alphaCurve: normalizeParticleCurve(c.alphaCurve),
+		hueCurve: normalizeParticleCurve(c.hueCurve)
+	};
+}
+/** Normalize portable renderer inputs without admitting HTML URL or placement fields. */
+function normalizeParticleRenderConfig(raw) {
+	const value = raw ?? {};
+	const erode = value.alphaErode;
+	const alphaErode = erode && Number.isFinite(erode.threshold) && Number.isFinite(erode.softness) ? {
+		threshold: erode.threshold,
+		softness: Math.max(0, erode.softness)
+	} : null;
+	return {
+		...normalizeParticleConfig(value),
+		textureWidth: Math.max(0, num(value.textureWidth, 0)),
+		textureHeight: Math.max(0, num(value.textureHeight, 0)),
+		flipbookCropOnly: value.flipbookCropOnly === true,
+		blendMode: Math.round(num(value.blendMode, 0)),
+		colorLut: value.colorLut,
+		colorLutInterpolation: value.colorLutInterpolation,
+		alphaFromRed: value.alphaFromRed === true,
+		alphaErode,
+		uvPolar: value.uvPolar === true
+	};
+}
+function clamp01(value) {
+	return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+//#endregion
+export { srgbToLinear as C, normalizeGodotRenderer as S, INSTANCE_STRIDE as _, activeParticleCount as a, linearizeParticleBaseColor as b, simulateParticles as c, normalizeParticleCurve as d, sampleParticleCurve as f, packParticleInstances as g, frameGridFor as h, particlesAreLive as i, staticOneShotExpired as l, sampleParticleGradientInto as m, normalizeParticleConfig as n, oneShotBurstSeconds as o, sampleParticleGradient as p, normalizeParticleRenderConfig as r, preprocessParticles as s, createParticleState as t, warmStaticParticles as u, InstanceBuffer as v, linearizesParticleColor as x, DEFAULT_GODOT_RENDERER as y };
+
+//# sourceMappingURL=particles-CQC9BFSI.js.map