@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/fx/emit-surface.js

@@ -0,0 +1,124 @@
+import { SURFACE_TRI_FLOATS } from './particles-wgsl.js';
+function isGeometry(src) {
+    return 'vertices' in src && 'layout' in src;
+}
+/**
+ * Build the sampling table of a `Geometry` (xyz at 0, normal at 3 of each `layout.floats`
+ * vertex) or of raw `positions`/`normals`/`indices`. Without indices every three positions
+ * are a triangle; without normals the face normal is used. Allocates; build once per mesh.
+ */
+export function buildEmitSurface(src, opts = {}) {
+    let positions;
+    let normals;
+    let indices;
+    let stride = 3;
+    let nOffset = 3;
+    if (isGeometry(src)) {
+        positions = src.vertices;
+        normals = src.vertices;
+        indices = src.indices;
+        stride = src.layout.floats;
+    }
+    else {
+        positions = src.positions;
+        normals = src.normals;
+        indices = src.indices;
+        nOffset = 0;
+    }
+    const vertexCount = Math.floor(positions.length / stride);
+    const triangles = indices ? Math.floor(indices.length / 3) : Math.floor(vertexCount / 3);
+    const table = new Float32Array(triangles * SURFACE_TRI_FLOATS);
+    let area = 0;
+    const n = new Float32Array(3);
+    for (let t = 0; t < triangles; t++) {
+        const o = t * SURFACE_TRI_FLOATS;
+        for (let k = 0; k < 3; k++) {
+            const vi = indices ? indices[t * 3 + k] : t * 3 + k;
+            const base = vi * stride;
+            table[o + k * 4] = positions[base];
+            table[o + k * 4 + 1] = positions[base + 1];
+            table[o + k * 4 + 2] = positions[base + 2];
+        }
+        // Face normal and area from the edge cross product.
+        const ax = table[o + 4] - table[o];
+        const ay = table[o + 5] - table[o + 1];
+        const az = table[o + 6] - table[o + 2];
+        const bx = table[o + 8] - table[o];
+        const by = table[o + 9] - table[o + 1];
+        const bz = table[o + 10] - table[o + 2];
+        n[0] = ay * bz - az * by;
+        n[1] = az * bx - ax * bz;
+        n[2] = ax * by - ay * bx;
+        const len = Math.hypot(n[0], n[1], n[2]);
+        area += len * 0.5;
+        if (len > 0) {
+            n[0] /= len;
+            n[1] /= len;
+            n[2] /= len;
+        }
+        for (let k = 0; k < 3; k++) {
+            const vi = indices ? indices[t * 3 + k] : t * 3 + k;
+            const no = o + 12 + k * 4;
+            if (normals && normals.length >= (vi + 1) * stride) {
+                const base = vi * stride + nOffset;
+                const nx = normals[base];
+                const ny = normals[base + 1];
+                const nz = normals[base + 2];
+                const nl = Math.hypot(nx, ny, nz) || 1;
+                table[no] = nx / nl;
+                table[no + 1] = ny / nl;
+                table[no + 2] = nz / nl;
+            }
+            else {
+                table[no] = n[0];
+                table[no + 1] = n[1];
+                table[no + 2] = n[2];
+            }
+        }
+        table[o + 3] = area;
+    }
+    // Normalise the cumulative areas to 0..1 (the last is exactly 1).
+    if (area > 0) {
+        for (let t = 0; t < triangles; t++)
+            table[t * SURFACE_TRI_FLOATS + 3] /= area;
+    }
+    if (triangles > 0)
+        table[(triangles - 1) * SURFACE_TRI_FLOATS + 3] = 1;
+    return {
+        kind: 'mesh',
+        positions,
+        normals,
+        indices,
+        alongNormal: opts.alongNormal,
+        table,
+        triangles,
+        area,
+    };
+}
+/**
+ * The CPU mirror of the kernel's sampling: triangle by `u` (binary search of the cumulative
+ * areas), point by `v`, `w` (square-root barycentrics, uniform over the triangle). Writes
+ * position xyz then normal xyz into `out` (6 floats). Returns the triangle index.
+ */
+export function sampleEmitSurface(surface, u, v, w, out) {
+    const tb = surface.table;
+    let lo = 0;
+    let hi = surface.triangles - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (tb[mid * SURFACE_TRI_FLOATS + 3] < u)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    const o = lo * SURFACE_TRI_FLOATS;
+    const r1 = Math.sqrt(v);
+    const w0 = 1 - r1;
+    const w1 = r1 * (1 - w);
+    const w2 = r1 * w;
+    for (let k = 0; k < 3; k++) {
+        out[k] = tb[o + k] * w0 + tb[o + 4 + k] * w1 + tb[o + 8 + k] * w2;
+        out[3 + k] = tb[o + 12 + k] * w0 + tb[o + 16 + k] * w1 + tb[o + 20 + k] * w2;
+    }
+    return lo;
+}

package/dist/fx/flicker.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure, allocation-free light helpers. Feed the result into a tint/emissive/intensity value.
+ */
+/** Smooth 1D value noise in [0, 1]. */
+export declare function valueNoise1(x: number, seed?: number): number;
+export interface FlickerOptions {
+    /** Distinguishes multiple lights. */
+    seed?: number;
+    /** Noise frequency in Hz-ish. Default 7. */
+    speed?: number;
+    /** 0..1 depth of the flicker. Default 0.3. */
+    amount?: number;
+    /** Value at rest. Default 1. */
+    base?: number;
+}
+/**
+ * Flame/torch flicker: two octaves of value noise plus a rare dip.
+ * Returns `base * (1 - amount * n)` with n in [0, 1].
+ */
+export declare function flicker(t: number, opts?: FlickerOptions): number;
+export interface PulseOptions {
+    /** Seconds per cycle. Default 2. */
+    period?: number;
+    min?: number;
+    max?: number;
+    /** 0..1 phase offset. */
+    phase?: number;
+}
+/** Smooth breathing pulse between `min` and `max` (cosine ease). */
+export declare function pulse(t: number, opts?: PulseOptions): number;

package/dist/fx/flicker.js

@@ -0,0 +1,42 @@
+/**
+ * Pure, allocation-free light helpers. Feed the result into a tint/emissive/intensity value.
+ */
+function hash1(n) {
+    const s = Math.sin(n * 127.1 + 311.7) * 43758.5453123;
+    return s - Math.floor(s);
+}
+/** Smooth 1D value noise in [0, 1]. */
+export function valueNoise1(x, seed = 0) {
+    const i = Math.floor(x);
+    const f = x - i;
+    const u = f * f * (3 - 2 * f);
+    const a = hash1(i + seed * 57.13);
+    const b = hash1(i + 1 + seed * 57.13);
+    return a + (b - a) * u;
+}
+/**
+ * Flame/torch flicker: two octaves of value noise plus a rare dip.
+ * Returns `base * (1 - amount * n)` with n in [0, 1].
+ */
+export function flicker(t, opts = {}) {
+    const seed = opts.seed ?? 0;
+    const speed = opts.speed ?? 7;
+    const amount = opts.amount ?? 0.3;
+    const base = opts.base ?? 1;
+    const n1 = valueNoise1(t * speed, seed);
+    const n2 = valueNoise1(t * speed * 2.7 + 13.3, seed + 1);
+    const dip = valueNoise1(t * speed * 0.21 + 5.1, seed + 2);
+    let n = n1 * 0.65 + n2 * 0.35;
+    if (dip > 0.85)
+        n = Math.min(1, n + (dip - 0.85) * 3);
+    return base * (1 - amount * n);
+}
+/** Smooth breathing pulse between `min` and `max` (cosine ease). */
+export function pulse(t, opts = {}) {
+    const period = opts.period ?? 2;
+    const min = opts.min ?? 0.6;
+    const max = opts.max ?? 1;
+    const ph = opts.phase ?? 0;
+    const k = 0.5 - 0.5 * Math.cos(((t / period + ph) % 1) * Math.PI * 2);
+    return min + (max - min) * k;
+}

package/dist/fx/index.d.ts

@@ -0,0 +1,31 @@
+export type { BillboardDepth, BillboardDesc, BillboardFacing, BillboardSize, BillboardsOptions, } from './billboard.js';
+export { BillboardHandle, Billboards, createBillboards, pxToWorld } from './billboard.js';
+export { BB_FLAG_BAR, BB_FLAG_PX, BB_FLAG_TEXTURED, BB_FLAG_YAW, BILLBOARD_BYTES, BILLBOARD_FLOATS, BILLBOARD_WGSL, } from './billboard-wgsl.js';
+export type { DebugColor, DebugDrawOptions, DebugQuat, DebugVec3 } from './debug-draw.js';
+export { createDebugDraw, DEBUG_VERTEX_FLOATS, DebugDraw } from './debug-draw.js';
+export { DEBUG_DRAW_WGSL } from './debug-wgsl.js';
+export type { DecalBlend, DecalDesc, DecalMode, DecalsOptions } from './decals.js';
+export { DECAL_INSTANCE_FLOATS, DECAL_PARAMS_FLOATS, Decals } from './decals.js';
+export { WGSL_DECAL_BOX, WGSL_DECAL_DEPTH_COPY, WGSL_DECAL_QUAD } from './decals-wgsl.js';
+export type { CreateEffectOptions, EffectDesc, EffectEmitterDesc, EffectFollow, EffectPoint, EffectSystemDesc, EffectSystemOptions, } from './effect.js';
+export { createEffect, Effect, EffectInstance, validateEffectDesc } from './effect.js';
+export { HIT_SPARK_EFFECT, MAGIC_AURA_EFFECT, SMOKE_PUFF_EFFECT } from './effects/index.js';
+export type { EmitSurface, MeshShapeSource } from './emit-surface.js';
+export { buildEmitSurface, sampleEmitSurface } from './emit-surface.js';
+export type { FlickerOptions, PulseOptions } from './flicker.js';
+export { flicker, pulse, valueNoise1 } from './flicker.js';
+export type { AttractFalloff, EmitParams, EmitShape, ParticleFields, ParticleForce, ParticleReadback, ParticleSystemOptions, Range, } from './particles.js';
+export { applyForces, evaluateCurve, MAX_CURVE_STOPS, ParticleEmitter, ParticleSystem, } from './particles.js';
+export { COLOR_CURVE_FLOATS, FX_PARTICLE_FLOATS, FX_REQUEST_FLOATS, FX_SIM_FLOATS, FX_SPAWN_FLOATS, MAX_FORCES, PARTICLE_COLLIDE_WGSL, PARTICLE_COMPUTE_WGSL, PARTICLE_COUNT_WGSL, PARTICLE_EXT_COMPUTE_WGSL, PARTICLE_EXT_RENDER_WGSL, PARTICLE_RENDER_WGSL, PARTICLE_WORLD_COMPUTE_WGSL, PARTICLE_WORLD_RENDER_WGSL, SIZE_CURVE_FLOATS, SURFACE_TRI_FLOATS, } from './particles-wgsl.js';
+export { FX_DEFAULT_SEED } from './random.js';
+export type { SkyOptions, SkyStars } from './sky.js';
+export { SKY_PARAMS_FLOATS, Sky, skyRay } from './sky.js';
+export { SKY_WGSL } from './sky-wgsl.js';
+export type { AtlasCanvas, AtlasContext2D, AtlasRegion, TextAtlasOptions, TextStyle, } from './text-atlas.js';
+export { TextAtlas } from './text-atlas.js';
+export type { TrailBlend, TrailFacing, TrailOptions } from './trail.js';
+export { Trail, TrailBatch } from './trail.js';
+export { TRAIL_TEXTURED_WGSL, TRAIL_WGSL } from './trail-wgsl.js';
+export type { WaterFoam, WaterOptions, WaterWave } from './water.js';
+export { WATER_PARAMS_FLOATS, Water, waterHeight } from './water.js';
+export { WATER_DEPTH_COPY_WGSL, WATER_MAX_WAVES, WATER_WGSL } from './water-wgsl.js';

package/dist/fx/index.js

@@ -0,0 +1,20 @@
+export { BillboardHandle, Billboards, createBillboards, pxToWorld } from './billboard.js';
+export { BB_FLAG_BAR, BB_FLAG_PX, BB_FLAG_TEXTURED, BB_FLAG_YAW, BILLBOARD_BYTES, BILLBOARD_FLOATS, BILLBOARD_WGSL, } from './billboard-wgsl.js';
+export { createDebugDraw, DEBUG_VERTEX_FLOATS, DebugDraw } from './debug-draw.js';
+export { DEBUG_DRAW_WGSL } from './debug-wgsl.js';
+export { DECAL_INSTANCE_FLOATS, DECAL_PARAMS_FLOATS, Decals } from './decals.js';
+export { WGSL_DECAL_BOX, WGSL_DECAL_DEPTH_COPY, WGSL_DECAL_QUAD } from './decals-wgsl.js';
+export { createEffect, Effect, EffectInstance, validateEffectDesc } from './effect.js';
+export { HIT_SPARK_EFFECT, MAGIC_AURA_EFFECT, SMOKE_PUFF_EFFECT } from './effects/index.js';
+export { buildEmitSurface, sampleEmitSurface } from './emit-surface.js';
+export { flicker, pulse, valueNoise1 } from './flicker.js';
+export { applyForces, evaluateCurve, MAX_CURVE_STOPS, ParticleEmitter, ParticleSystem, } from './particles.js';
+export { COLOR_CURVE_FLOATS, FX_PARTICLE_FLOATS, FX_REQUEST_FLOATS, FX_SIM_FLOATS, FX_SPAWN_FLOATS, MAX_FORCES, PARTICLE_COLLIDE_WGSL, PARTICLE_COMPUTE_WGSL, PARTICLE_COUNT_WGSL, PARTICLE_EXT_COMPUTE_WGSL, PARTICLE_EXT_RENDER_WGSL, PARTICLE_RENDER_WGSL, PARTICLE_WORLD_COMPUTE_WGSL, PARTICLE_WORLD_RENDER_WGSL, SIZE_CURVE_FLOATS, SURFACE_TRI_FLOATS, } from './particles-wgsl.js';
+export { FX_DEFAULT_SEED } from './random.js';
+export { SKY_PARAMS_FLOATS, Sky, skyRay } from './sky.js';
+export { SKY_WGSL } from './sky-wgsl.js';
+export { TextAtlas } from './text-atlas.js';
+export { Trail, TrailBatch } from './trail.js';
+export { TRAIL_TEXTURED_WGSL, TRAIL_WGSL } from './trail-wgsl.js';
+export { WATER_PARAMS_FLOATS, Water, waterHeight } from './water.js';
+export { WATER_DEPTH_COPY_WGSL, WATER_MAX_WAVES, WATER_WGSL } from './water-wgsl.js';

package/dist/fx/particles-wgsl.d.ts

@@ -0,0 +1,57 @@
+export declare const PARTICLE_COMPUTE_WGSL = "\n\nstruct Particle {\n  posVel: vec4f,  // pos.xy, vel.xy (logical px, px/s)\n  c0: vec4f,      // colour at birth (linear, premultiplied by nothing)\n  c1: vec4f,      // colour at death\n  life: vec4f,    // age, lifetime, size at birth, size at death\n  phys: vec4f,    // gravity.xy, drag, emissive\n};\nstruct Sim {\n  dt: f32,\n  floorY: f32,\n  bounce: f32,\n  time: f32,\n  capacity: f32,\n  stretch: f32,\n  spawnCount: f32,\n  _pad: f32,\n};\n\nstruct Spawn {\n  a: vec4f,   // x, y, shapeA, shapeB\n  b: vec4f,   // angle, spread, speedMin, speedMax\n  c: vec4f,   // lifeMin, lifeMax, sizeStart, sizeEnd\n  c0: vec4f,\n  c1: vec4f,\n  d: vec4f,   // gravX, gravY, drag, shapeKind (0 point, 1 circle, 2 rect, 3 line)\n  e: vec4f,   // start, count, seed, emissive\n};\n@group(0) @binding(0) var<storage, read_write> particles: array<Particle>;\n@group(0) @binding(1) var<storage, read> spawns: array<Spawn>;\n@group(0) @binding(2) var<uniform> sim: Sim;\n\nfn pcg(v: u32) -> u32 {\n  let s = v * 747796405u + 2891336453u;\n  let w = ((s >> ((s >> 28u) + 4u)) ^ s) * 277803737u;\n  return (w >> 22u) ^ w;\n}\nfn rnd(state: ptr<function, u32>) -> f32 {\n  *state = pcg(*state);\n  return f32(*state) / 4294967295.0;\n}\n\n@compute @workgroup_size(64) fn spawn(@builtin(global_invocation_id) gid: vec3u) {\n  if (f32(gid.y) >= sim.spawnCount) { return; }\n  let cmd = spawns[gid.y];\n  let i = gid.x;\n  if (f32(i) >= cmd.e.y) { return; }\n  let cap = u32(sim.capacity);\n  let idx = (u32(cmd.e.x) + i) % cap;\n  var st = pcg(i ^ pcg(u32(cmd.e.z)));\n\n  var pos = cmd.a.xy;\n  let kind = cmd.d.w;\n  if (kind > 0.5 && kind < 1.5) {\n    let r = sqrt(rnd(&st)) * cmd.a.z;\n    let th = rnd(&st) * 6.2831853;\n    pos += vec2f(cos(th), sin(th)) * r;\n  } else if (kind > 1.5 && kind < 2.5) {\n    pos += (vec2f(rnd(&st), rnd(&st)) - 0.5) * cmd.a.zw;\n  } else if (kind > 2.5) {\n    pos += cmd.a.zw * rnd(&st);\n  }\n  let ang = cmd.b.x + (rnd(&st) - 0.5) * cmd.b.y;\n  let speed = mix(cmd.b.z, cmd.b.w, rnd(&st));\n  let life = mix(cmd.c.x, cmd.c.y, rnd(&st));\n  let sj = 0.7 + 0.6 * rnd(&st);\n\n  var p: Particle;\n  p.posVel = vec4f(pos, vec2f(cos(ang), sin(ang)) * speed);\n  p.c0 = cmd.c0;\n  p.c1 = cmd.c1;\n  p.life = vec4f(0.0, max(life, 1e-3), cmd.c.z * sj, cmd.c.w * sj);\n  p.phys = vec4f(cmd.d.xyz, cmd.e.w);\n  particles[idx] = p;\n}\n\n@compute @workgroup_size(64) fn update(@builtin(global_invocation_id) gid: vec3u) {\n  let i = gid.x;\n  if (f32(i) >= sim.capacity) { return; }\n  var p = particles[i];\n  if (p.life.x >= p.life.y) { return; }\n  let dt = sim.dt;\n  p.life.x += dt;\n  var v = p.posVel.zw + p.phys.xy * dt;\n  v *= exp(-p.phys.z * dt);\n  var pos = p.posVel.xy + v * dt;\n  if (pos.y > sim.floorY && v.y > 0.0) {\n    pos.y = sim.floorY;\n    v = vec2f(v.x * 0.75, -v.y * sim.bounce);\n  }\n  p.posVel = vec4f(pos, v);\n  particles[i] = p;\n}\n";
+export declare const PARTICLE_RENDER_WGSL = "\n\nstruct EngineGlobals {\n  logicalSize: vec2f,\n  targetSize: vec2f,\n  time: f32,\n  dt: f32,\n  _pad: vec2f,\n};\n@group(0) @binding(0) var<uniform> globals: EngineGlobals;\nstruct EngineCamera {\n  view: mat4x4f,\n  proj: mat4x4f,\n  view_proj: mat4x4f,\n  camera_pos: vec4f,\n  viewport: vec4f,\n  view_index: u32,\n  _pad0: u32, _pad1: u32, _pad2: u32,\n  inv_view_proj: mat4x4f,\n  prev_view_proj: mat4x4f,\n  prev_view: mat4x4f,\n  jitter: vec4f,\n};\n@group(0) @binding(1) var<uniform> camera: EngineCamera;\n\n\nstruct Particle {\n  posVel: vec4f,  // pos.xy, vel.xy (logical px, px/s)\n  c0: vec4f,      // colour at birth (linear, premultiplied by nothing)\n  c1: vec4f,      // colour at death\n  life: vec4f,    // age, lifetime, size at birth, size at death\n  phys: vec4f,    // gravity.xy, drag, emissive\n};\nstruct Sim {\n  dt: f32,\n  floorY: f32,\n  bounce: f32,\n  time: f32,\n  capacity: f32,\n  stretch: f32,\n  spawnCount: f32,\n  _pad: f32,\n};\n\n@group(1) @binding(0) var<storage, read> particles: array<Particle>;\n@group(1) @binding(1) var<uniform> sim: Sim;\n\nstruct PVOut {\n  @builtin(position) clip: vec4f,\n  @location(0) q: vec2f,\n  @location(1) color: vec4f,\n  @location(2) emissive: f32,\n};\nstruct FragOut {\n  @location(0) color: vec4f,\n  @location(1) emissive: vec4f,\n};\n\n@vertex fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> PVOut {\n  var o: PVOut;\n  let p = particles[ii];\n  if (p.life.x >= p.life.y) {\n    o.clip = vec4f(0.0, 0.0, 2.0, 1.0);\n    return o;\n  }\n  var corners = array<vec2f, 6>(\n    vec2f(-1.0, -1.0), vec2f(1.0, -1.0), vec2f(1.0, 1.0),\n    vec2f(-1.0, -1.0), vec2f(1.0, 1.0), vec2f(-1.0, 1.0)\n  );\n  let q = corners[vi];\n  let t = p.life.x / p.life.y;\n  let size = max(mix(p.life.z, p.life.w, t), 0.0);\n  let vel = p.posVel.zw;\n  let speed = length(vel);\n  var dir = vec2f(1.0, 0.0);\n  if (speed > 1e-3) { dir = vel / speed; }\n  let len = size + speed * sim.stretch;\n  let perp = vec2f(-dir.y, dir.x);\n  let world = p.posVel.xy + dir * (q.x * len * 0.5) + perp * (q.y * size * 0.5);\n  o.clip = camera.view_proj * vec4f(world, 0.0, 1.0);\n  o.q = q;\n  o.color = mix(p.c0, p.c1, t);\n  o.emissive = p.phys.w;\n  return o;\n}\n\n@fragment fn fs(in: PVOut) -> FragOut {\n  let d = length(in.q);\n  var a = clamp(1.0 - d, 0.0, 1.0);\n  a = a * a * in.color.a;\n  let c = in.color.rgb * a;\n  var o: FragOut;\n  o.color = vec4f(c, a);\n  o.emissive = vec4f(c * in.emissive, a);\n  return o;\n}\n";
+/** Particles per `Particle` struct below: 10 vec4 = 160 bytes. */
+export declare const FX_PARTICLE_FLOATS = 40;
+/** Floats per extended spawn record (`Spawn` below). */
+export declare const FX_SPAWN_FLOATS = 52;
+/** Forces the extended sim block carries. */
+export declare const MAX_FORCES = 8;
+/** Floats of the extended sim block: 20 scalars + 8 forces × 3 vec4. */
+export declare const FX_SIM_FLOATS: number;
+/** Floats per size-curve slot (count, 8 stops, 3 pad) and per colour-curve slot (count + pad, 8 RGBA). */
+export declare const SIZE_CURVE_FLOATS = 12;
+export declare const COLOR_CURVE_FLOATS = 36;
+/** Floats per sub-emission request (`Req` below). */
+export declare const FX_REQUEST_FLOATS = 8;
+/** Floats per mesh-surface triangle (p0 + cdf, p1, p2, n0, n1, n2). */
+export declare const SURFACE_TRI_FLOATS = 24;
+/**
+ * The extended render kernel: the quad is built from the view rows (world) or the XY axes (2D),
+ * aligned to the velocity (streaks) when the particle asks, rotated by its spin, sized and
+ * coloured by the curve table or the two-stop sugar, textured from the sprite sheet tile when
+ * the system has one (both blend modes; premultiplied on output), with the world-space fades
+ * and lighting of before.
+ */
+/**
+ * The extended render shader; with `velocity` (the velocity attachment's fragment location, 2
+ * or 3; world space only) the build that writes its own motion (ws/render-11): each corner's
+ * previous position is `world - vel * sim.dt` (this frame's step back), projected through
+ * `camera.prev_view_proj`, and the fragment writes `vec4f(engine_motion(..), 0, alpha)`.
+ * `velocity` 0 is the exported strings exactly.
+ */
+export declare function fxRenderWgsl(world: boolean, velocity?: number): string;
+/** The extended 2D kernel (`extended: true`, or implied by `texture`, `forces`, `collide`). */
+export declare const PARTICLE_EXT_COMPUTE_WGSL: string;
+export declare const PARTICLE_EXT_RENDER_WGSL: string;
+/** World space: the same extended kernel with a 3D cone launch, y-up floor and the view-row quad. */
+export declare const PARTICLE_WORLD_COMPUTE_WGSL: string;
+export declare const PARTICLE_WORLD_RENDER_WGSL: string;
+/**
+ * Depth collision (world space, \`readsDepth\` + \`collide\`): runs in the depth hook over this
+ * frame's opaque depth. A live particle whose projected depth lies behind the scene by less
+ * than \`thickness\` (view-ray units) is pushed out along the surface normal (from the depth's
+ * neighbours) onto the surface, so a resting particle does not creep along the view ray, and its
+ * velocity is reflected about that normal, scaled by
+ * \`bounce\` normally and by \`1 - friction\` tangentially. A particle deeper than that is
+ * swept: if its position one step back (\`pos - vel * dt\`) was in front of the scene it
+ * crossed the surface this frame and is put back there, so a slow frame does not tunnel.
+ */
+export declare const PARTICLE_COLLIDE_WGSL: string;
+/** Copies a depth texture into the particles' own depth32float copy (soft-particle source). */
+export declare const PARTICLE_DEPTH_COPY_WGSL = "\n@group(0) @binding(0) var src: texture_depth_2d;\n@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {\n  let p = vec2f(f32((i << 1u) & 2u), f32(i & 2u));\n  return vec4f(p * 2.0 - 1.0, 0.0, 1.0);\n}\n@fragment fn fs(@builtin(position) pos: vec4f) -> @builtin(frag_depth) f32 {\n  return textureLoad(src, vec2i(pos.xy), 0);\n}\n";
+/**
+ * Counts live particles of either layout: \`stride\` vec4s per particle, \`life\` at vec4 index
+ * \`lifeAt\` (age in x, lifetime in y), and among them those whose y (vec4 \`posAt\`) is below
+ * \`belowY\`.
+ */
+export declare const PARTICLE_COUNT_WGSL = "\nstruct CountParams {\n  capacity: u32,\n  stride: u32,\n  lifeAt: u32,\n  posAt: u32,\n  belowY: f32,\n  _a: f32,\n  _b: f32,\n  _c: f32,\n};\nstruct Counts {\n  alive: atomic<u32>,\n  below: atomic<u32>,\n};\n@group(0) @binding(0) var<storage, read> data: array<vec4f>;\n@group(0) @binding(1) var<storage, read_write> counts: Counts;\n@group(0) @binding(2) var<uniform> params: CountParams;\n@compute @workgroup_size(64) fn count(@builtin(global_invocation_id) gid: vec3u) {\n  if (gid.x >= params.capacity) { return; }\n  let life = data[gid.x * params.stride + params.lifeAt];\n  if (life.x < life.y) {\n    atomicAdd(&counts.alive, 1u);\n    if (data[gid.x * params.stride + params.posAt].y < params.belowY) {\n      atomicAdd(&counts.below, 1u);\n    }\n  }\n}\n";