@adatechnology/game-vfx-three 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson Fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# @adatechnology/game-vfx-three
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The three.js renderer of [`@adatechnology/game-vfx`](../game-vfx). It draws a `VfxWorld` with the shaders of the Explosion Lab and lends the host an
+`EffectSink` (`@adatechnology/game-contracts`) so modules ask for effects by id without bringing particles of their own.
+
+- **Puffs**: one icosahedron instance each, faceted, with the five-band posterised heat ramp, the noise dissolve and the banded light of the Lab
+  (shader verbatim; the only change is the r160 `colorspace_fragment` chunk). **Shrapnel** streaks, additive **halos**, the **shock** shell and the dust
+  ring on the ground, glowing **debris** (two instanced meshes, rocks and plates), the **blast lights** and **fire lights** as point lights.
+- **Marks**: scorch, dirt, rim rocks and blood as meshes. A scorch or dirt mesh conforms to the ground as it was when the mark was made, so craters
+  and marks agree. `createGroundPatch(THREE, { field })` is the Lab's 60 m patch as a mesh that follows a `GroundField`.
+- **Screen**: `overlay` puts the Lab's white flash (`mix-blend-mode: screen`) and the Workshop's white, red edge, sides and gas tint inside your container.
+  `applyCamera()` shakes the camera for the render that follows and answers the function that puts it back.
+- **Workshop layers**: what `world.play` fills is drawn too, made when the first recipe plays: the two sprite systems with the page's soft-point shader, streaks,
+  500 instanced debris boxes, the decals (wet and dry), the expanding rings and the flash and fire lights. The Workshop's screen state joins the overlay (the
+  stronger value of each field). The lens blobs and the post-processing the page paints on a 2D canvas are not drawn yet.
+- **Bench module**: `createVfxTestModule({ locale })` (id `vfx`, group `effects`) for `game-test-room`: pick an explosion or a recipe (listed by team), its variant,
+  replay or auto replay, distance, LOD band, quality and six layers (`show_puffs`, `show_sparks`, `show_glows`, `show_debris`, `show_shock`, `show_sprites`),
+  with the sheet of the effect, a timeline whose playhead follows the effect's clock, and the counters against the budget (particles 400, debris 40, lights 6).
+  It plays through `host.effects`, or into a renderer of its own when the host lends none.
+- Lights use the raw colours of the Lab and are multiplied by `lightScale` (default `Math.PI`: r155+ lights are physical, the Lab's r128 ones were not).
+
+```ts
+import * as THREE from 'three'
+import { createVfxRenderer } from '@adatechnology/game-vfx-three'
+
+const vfx = createVfxRenderer(THREE, { scene, camera, overlay: container, vfx: { profile: 'high', seed: 1 } })
+vfx.play({ effect: 'm67', point: [0, 0.1, 0], seed: 7 }) // EffectSink: a handle, or null for an unknown id
+
+// every frame: steps the world, redraws, then render with the shake around it
+vfx.update(dt)
+const restore = vfx.applyCamera()
+gl.render(scene, camera)
+restore()
+```
+
+Pass a `VfxWorld` as `vfx` to share one world between renderers (the test room does): the renderer that owns the loop calls `update`, nobody else.
+`configure({ lod_band: 'auto' | 'near' | 'middle' | 'far' })` forces the scale, `configure({ quality: 'high' | 'medium' | 'low' })` thins the recipes and `configure({ layer_puffs: false })` hides a layer (`puffs`, `sparks`, `glows`, `debris`, `shock`, `sprites`). In Node (tests) pass `createCanvas` so the marks can draw their textures.
+
+## Install
+
+```sh
+pnpm add @adatechnology/game-vfx-three three
+```
+
+Browser without a bundler (the global is `GameVfxThree`; load three.js first):
+
+```html
+<script src="https://unpkg.com/@adatechnology/game-vfx-three/dist/index.global.js"></script>
+<script>
+  const vfx = GameVfxThree.createVfxRenderer(THREE, { scene, camera })
+</script>
+```

package/dist/index.d.ts

@@ -0,0 +1,184 @@
+import * as THREE_NS from 'three';
+import { EffectSink, TestableModule } from '@adatechnology/game-contracts';
+import { VfxWorld, ScreenState, VfxOptions, VfxProfileName, EffectDef, ExplosionDef, GroundField, SpriteKindSystem, MarkEvent } from '@adatechnology/game-vfx';
+
+/** The only three.js members the renderer needs at runtime. Pass your own `THREE` instance (the whole namespace works). */
+type ThreeLib = Pick<typeof THREE_NS, 'AdditiveBlending' | 'BufferAttribute' | 'BufferGeometry' | 'BoxGeometry' | 'CanvasTexture' | 'CircleGeometry' | 'Color' | 'DodecahedronGeometry' | 'DynamicDrawUsage' | 'Euler' | 'Float32BufferAttribute' | 'Group' | 'IcosahedronGeometry' | 'InstancedBufferAttribute' | 'InstancedBufferGeometry' | 'InstancedMesh' | 'LineBasicMaterial' | 'LineSegments' | 'LinearSRGBColorSpace' | 'Matrix4' | 'Mesh' | 'MeshBasicMaterial' | 'MeshStandardMaterial' | 'NormalBlending' | 'PlaneGeometry' | 'Points' | 'PointLight' | 'Quaternion' | 'RepeatWrapping' | 'RingGeometry' | 'SRGBColorSpace' | 'DoubleSide' | 'ShaderMaterial' | 'SphereGeometry' | 'Vector3'>;
+/** A canvas the marks draw their textures on. A browser has one; a test supplies a fake. */
+interface CanvasLike {
+    width: number;
+    height: number;
+    getContext(kind: '2d'): CanvasContextLike | null;
+}
+/** The drawing calls the scorch and dirt textures use. */
+interface CanvasContextLike {
+    fillStyle: unknown;
+    strokeStyle: unknown;
+    lineWidth: number;
+    globalAlpha: number;
+    clearRect(x: number, y: number, w: number, h: number): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    stroke(): void;
+    arc(x: number, y: number, radius: number, start: number, end: number): void;
+    fill(): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): {
+        addColorStop(offset: number, color: string): void;
+    };
+}
+interface VfxRendererOptions {
+    /** Where the effects live: everything is added under one group. */
+    scene: THREE_NS.Object3D;
+    camera: THREE_NS.Camera;
+    /** A shared world (the test room lends one to every renderer) or the options of the world to create. */
+    vfx?: VfxWorld | VfxOptions;
+    /** Pool sizes when the world is created here (`vfx` given as options without a profile). Default `medium`. */
+    quality?: VfxProfileName;
+    /** Where the screen flash goes (the room's container). Without it nothing is drawn on the screen. */
+    overlay?: HTMLElement;
+    /** Skips the flash and the camera shake. Default: what the browser says (`prefers-reduced-motion`). */
+    reducedMotion?: boolean;
+    /** Canvas factory for the textures of the marks. Default `document.createElement('canvas')`. */
+    createCanvas?: () => CanvasLike;
+    /** Direction towards the light the puffs are shaded with. Default the Lab's moon. */
+    lightDirection?: readonly [number, number, number];
+    /** Pixels of point size per metre at a distance of one metre for the sprite kinds; roughly `viewportHeight / (2 * tan(fov / 2))`. Default 700. */
+    pointScale?: number;
+    /** Multiplies the blast and fire lights. Default `Math.PI`: three.js r155+ lights are physical, the Lab's were not (r128). */
+    lightScale?: number;
+}
+/** The world's counters flattened (`lastBlast` becomes `last_puffs`, `last_sparks`, `last_chunks`, `last_lights`), plus `drawCalls`. */
+type VfxRendererStats = Readonly<Record<string, number>>;
+interface VfxRenderer extends EffectSink {
+    readonly world: VfxWorld;
+    /** Steps the world, then redraws everything from it. Call once per frame (a shared world is stepped here, nowhere else). */
+    update(dt: number): void;
+    /** Shakes the camera for the render that follows (the Lab's L1092) and answers the function that puts it back. */
+    applyCamera(): () => void;
+    stats(): VfxRendererStats;
+    /** The screen state the overlay draws (shake, flash...). */
+    screen(): Readonly<ScreenState>;
+    dispose(): void;
+}
+
+/** `configure({ layer_<id>: false })` hides a layer of the renderer: `puffs`, `sparks`, `glows`, `debris`, `shock`, `sprites`. */
+declare const VFX_LAYERS: readonly ["puffs", "sparks", "glows", "debris", "shock", "sprites"];
+/** Draws a `VfxWorld`: the Lab's shaders, debris, shock, lights, marks and the screen overlay, and plays effects asked of it by id (`EffectSink`). */
+declare function createVfxRenderer(THREE: ThreeLib, options: VfxRendererOptions): VfxRenderer;
+
+interface VfxTestModuleOptions {
+    readonly locale?: string;
+    /** The recipes the bench lists (default `GAME_EFFECTS`) and the explosions (default `EXPLOSIONS`). */
+    readonly effects?: Readonly<Record<string, EffectDef>>;
+    readonly explosions?: Readonly<Record<string, ExplosionDef>>;
+    /** Seconds between two replays while `auto_repeat` is on. */
+    readonly repeatSeconds?: number;
+}
+/**
+ * The effects bench: pick an explosion or a recipe (listed by team), its variant, the distance, the quality and the layers, replay it or let it repeat,
+ * and watch the particle and light counters against the budget. It plays through `host.effects` (the room's world) and, in a host without one, draws
+ * into a renderer of its own.
+ */
+declare function createVfxTestModule(options?: VfxTestModuleOptions): TestableModule;
+
+/** The words of the effects bench, per locale (the effects' own texts live in `@adatechnology/game-vfx`). */
+interface BenchText {
+    readonly module: string;
+    readonly controls: Readonly<Record<'effect' | 'variant' | 'replay' | 'auto_repeat' | 'distance' | 'lod_band' | 'quality', string>>;
+    readonly lod: Readonly<Record<'auto' | 'near' | 'middle' | 'far', string>>;
+    readonly quality: Readonly<Record<'high' | 'medium' | 'low', string>>;
+    readonly layers: Readonly<Record<'puffs' | 'sparks' | 'glows' | 'debris' | 'shock' | 'sprites', string>>;
+    readonly metrics: Readonly<Record<'puffs' | 'sparks' | 'debris' | 'lights' | 'budget_particles' | 'lod' | 'phase' | 'blast_time', string>>;
+    readonly sheet: Readonly<Record<'explosion' | 'lethal' | 'injury' | 'radius' | 'fireballs' | 'particles' | 'scale', string>>;
+    readonly none: string;
+}
+declare const benchTexts: Readonly<Record<string, BenchText>>;
+declare const benchText: (locale: string) => BenchText;
+
+interface GroundPatchOptions {
+    /** The height field the craters dig; the mesh follows it. */
+    readonly field: GroundField;
+    /** What the patch is made of (default a plain flat-shaded grey standard material). */
+    readonly material?: THREE_NS.Material;
+    /** Texture coordinates repeat every this many metres (the Lab's 17). */
+    readonly textureMetres?: number;
+}
+interface GroundPatch {
+    readonly mesh: THREE_NS.Mesh;
+    /** Redraws the vertices when the field changed since the last call. Returns whether it did. */
+    sync(): boolean;
+    dispose(): void;
+}
+/** The Lab's 60 m deformable patch with 33 cm cells (L60-83), as a mesh that follows a `GroundField`. */
+declare function createGroundPatch(THREE: ThreeLib, options: GroundPatchOptions): GroundPatch;
+
+interface ScreenOverlay {
+    update(state: Readonly<ScreenState>): void;
+    dispose(): void;
+}
+/**
+ * The screen effects as overlays inside the host's container: the Lab's white flash (L1087, `mix-blend-mode: screen`) and the Workshop's white,
+ * red edge, the two sides and the gas tint (W356-366), with the same colours. Nothing is drawn while the state is at rest.
+ */
+declare function createScreenOverlay(container: HTMLElement): ScreenOverlay;
+
+interface SpriteLayer {
+    readonly additive: THREE_NS.Points;
+    readonly normal: THREE_NS.Points;
+    /** Tells the GPU what changed and answers how many sprites are drawn. */
+    sync(): number;
+    dispose(): void;
+}
+/** Draws the game's sprite kinds (debris, sparks, smoke, steam, drips...) as two soft point layers, additive and normal. */
+declare function createSpriteLayer(THREE: ThreeLib, system: SpriteKindSystem, pointScale: number): SpriteLayer;
+
+/** The soft round point sprite of the game's sprite kinds (moved verbatim from the destruction renderer's particles). */
+declare const SPRITE_VERTEX = "\nuniform float uScale;\nattribute float size;\nattribute float alpha;\nattribute vec3 pcolor;\nvarying float vAlpha;\nvarying vec3 vColor;\nvoid main() {\n  vAlpha = alpha;\n  vColor = pcolor;\n  vec4 mv = modelViewMatrix * vec4(position, 1.0);\n  gl_PointSize = min(size * uScale / max(0.1, -mv.z), 256.0);\n  gl_Position = projectionMatrix * mv;\n}";
+declare const SPRITE_FRAGMENT = "\nvarying float vAlpha;\nvarying vec3 vColor;\nvoid main() {\n  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;\n  float a = (1.0 - smoothstep(0.35, 1.0, d)) * vAlpha;\n  if (a < 0.004) discard;\n  gl_FragColor = vec4(vColor, a);\n}";
+
+interface MarkLayer {
+    readonly group: THREE_NS.Group;
+    /** The shared rock and plate shapes, so the debris and the rim rocks use the same geometry. */
+    handle(event: MarkEvent): void;
+    update(dt: number): void;
+    /** The meshes in the group right now. */
+    count(): number;
+    dispose(): void;
+}
+interface MarkLayerOptions {
+    readonly ground: GroundField | undefined;
+    readonly createCanvas: (() => CanvasLike) | undefined;
+    readonly rockGeometry: THREE_NS.BufferGeometry;
+    readonly plateGeometry: THREE_NS.BufferGeometry;
+}
+/**
+ * The scorch, dirt, rim rocks and blood of the Lab as meshes (L443-476). A scorch or dirt mesh follows the ground as it was the moment the mark was
+ * made (`conform`), so the renderer builds it from the mark event, not later.
+ */
+declare function createMarkLayer(THREE: ThreeLib, options: MarkLayerOptions): MarkLayer;
+
+/**
+ * The puff shader of the Lab (L130-192), verbatim: a faceted icosahedron per puff, a five-band posterised heat ramp, a noise dissolve and banded light.
+ * The only change is the r160 colour-space chunk: `encodings_fragment` (r128) is `colorspace_fragment` now.
+ */
+declare const PUFF_VERTEX = "\nfloat h3(vec3 p){p=fract(p*.3183099+.1);p*=17.0;return fract(p.x*p.y*p.z*(p.x+p.y+p.z));}\nfloat vn(vec3 x){vec3 i=floor(x),f=fract(x);f=f*f*(3.-2.*f);\n return mix(mix(mix(h3(i),h3(i+vec3(1,0,0)),f.x),mix(h3(i+vec3(0,1,0)),h3(i+vec3(1,1,0)),f.x),f.y),\n            mix(mix(h3(i+vec3(0,0,1)),h3(i+vec3(1,0,1)),f.x),mix(h3(i+vec3(0,1,1)),h3(i+vec3(1,1,1)),f.x),f.y),f.z);}\n\nattribute vec4 aP;attribute vec4 aD;attribute vec3 aC;\nvarying vec3 vWP;varying vec3 vL;varying vec4 vD;varying vec3 vC;\nvoid main(){\n  vec3 p=position;\n  float s=aD.z;\n  float n=vn(p*1.6+vec3(s*11.0,s*7.0,s*3.0));\n  p*=0.78+0.5*n;\n  float a=s*6.2831;float c=cos(a),si=sin(a);p.xz=mat2(c,-si,si,c)*p.xz;\n  vL=p;\n  vec3 wp=aP.xyz+p*aP.w;\n  vWP=wp;vD=aD;vC=aC;\n  gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.0);\n}";
+declare const PUFF_FRAGMENT = "\nfloat h3(vec3 p){p=fract(p*.3183099+.1);p*=17.0;return fract(p.x*p.y*p.z*(p.x+p.y+p.z));}\nfloat vn(vec3 x){vec3 i=floor(x),f=fract(x);f=f*f*(3.-2.*f);\n return mix(mix(mix(h3(i),h3(i+vec3(1,0,0)),f.x),mix(h3(i+vec3(0,1,0)),h3(i+vec3(1,1,0)),f.x),f.y),\n            mix(mix(h3(i+vec3(0,0,1)),h3(i+vec3(1,0,1)),f.x),mix(h3(i+vec3(0,1,1)),h3(i+vec3(1,1,1)),f.x),f.y),f.z);}\n\nuniform vec3 uLight;uniform vec3 uSky;uniform vec3 uGround;uniform vec3 uGlowPos;uniform vec3 uGlowCol;uniform float uGlowI;\nvarying vec3 vWP;varying vec3 vL;varying vec4 vD;varying vec3 vC;\nvec3 L(vec3 c){return pow(c,vec3(2.2));}\nvec3 ramp(float h){\n  vec3 c0=L(vec3(.36,.07,.03)),c1=L(vec3(.76,.21,.1)),c2=L(vec3(1.,.54,.16)),c3=L(vec3(1.,.83,.42)),c4=L(vec3(1.,.96,.84));\n  if(h<.25)return mix(c0,c1,h/.25);\n  if(h<.5)return mix(c1,c2,(h-.25)/.25);\n  if(h<.8)return mix(c2,c3,(h-.5)/.3);\n  return mix(c3,c4,clamp((h-.8)/.4,0.,1.));\n}\nvoid main(){\n  vec3 N=normalize(cross(dFdx(vWP),dFdy(vWP)));\n  float age=vD.x,heat=vD.y,kind=vD.w;\n  float n=vn(vL*2.4+vD.z*13.0);\n  float diss=smoothstep(.5,1.,age);\n  if(n<diss*1.08-.04)discard;\n  float lam=max(dot(N,uLight),0.);\n  float band=lam>.55?1.:lam>.15?.68:.42;\n  vec3 col=vC*(vec3(.5,.56,.7)*band*1.05+vec3(.2,.19,.18)+uGround*(.4-.4*N.y));\n  vec3 tg=uGlowPos-vWP;float dg=length(tg)+.001;\n  float gi=uGlowI/(1.+dg*dg*.05)*(.3+.7*max(dot(N,tg/dg),0.));\n  col+=uGlowCol*gi*vC*1.6;\n  float h=heat*(.72+.56*n)+heat*(-N.y)*.18;\n  if(h>.05){\n    float hq=floor(h*5.+.5)/5.;\n    vec3 fc=ramp(clamp(hq,0.,1.2))*(1.1+3.1*hq);\n    col=mix(col,fc,smoothstep(.04,.2,h));\n  }\n  if(kind>2.5&&kind<3.5){col+=vec3(.02,.025,.03);}\n  gl_FragColor=vec4(col,1.);\n  #include <tonemapping_fragment>\n  #include <colorspace_fragment>\n}";
+
+/** The streak shader of shrapnel, sparks and embers (Lab L255-275), verbatim except for the r160 colour-space chunk. */
+declare const SPARK_VERTEX = "\nattribute vec3 aPos;attribute vec3 aVel;attribute vec4 aE;varying vec2 vU;varying vec4 vE;\nvoid main(){\n  float sp=length(aVel)+1e-4;vec3 d=aVel/sp;\n  vec3 tc=normalize(cameraPosition-aPos);\n  vec3 sd=normalize(cross(d,tc)+vec3(1e-5));\n  float len=max(aE.y*2.5,min(sp*aE.z,2.2));\n  vec3 wp=aPos+sd*position.x*aE.y-d*position.y*len;\n  vU=position.xy;vE=aE;\n  gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);\n}";
+declare const SPARK_FRAGMENT = "\nvarying vec2 vU;varying vec4 vE;\nvoid main(){\n  float age=vE.x,k=vE.w;\n  float w=1.-abs(vU.x)*2.;w=w*w;\n  float tail=1.-vU.y;\n  vec3 c;\n  if(k<.5){c=mix(vec3(4.,3.3,2.2),vec3(2.4,.7,.12),smoothstep(0.,.55,age));c=mix(c,vec3(.5,.06,.02),smoothstep(.55,1.,age));}\n  else if(k<1.5){c=mix(vec3(1.6,1.6,1.6),vec3(.35,.35,.36),smoothstep(0.,.4,age));}\n  else if(k<2.5){c=mix(vec3(5.,5.,6.),vec3(1.,1.3,2.),smoothstep(0.,.5,age));}\n  else if(k<3.5){c=vec3(.9,1.2,1.4)*(1.-age);}\n  else {c=mix(vec3(3.2,1.4,.3),vec3(1.2,.25,.05),age);}\n  float a=w*(.35+.65*tail)*(1.-smoothstep(.75,1.,age));\n  gl_FragColor=vec4(c*a,1.);\n  #include <tonemapping_fragment>\n  #include <colorspace_fragment>\n}";
+
+/** The additive halo (Lab L297-304), verbatim except for the r160 colour-space chunk. */
+declare const GLOW_VERTEX = "attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;\nvoid main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);\nvec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}";
+declare const GLOW_FRAGMENT = "varying vec2 vU;varying vec4 vC;void main(){float r=dot(vU,vU);if(r>1.)discard;float f=exp(-r*4.2)-.015;gl_FragColor=vec4(vC.rgb*vC.a*max(f,0.),1.);\n  #include <tonemapping_fragment>\n  #include <colorspace_fragment>\n}";
+
+/** The shock shell (fresnel edge, Lab L322-325) and the dust ring on the ground (L326-333), verbatim except for the r160 colour-space chunk. */
+declare const SHELL_VERTEX = "varying vec3 vN;varying vec3 vV;void main(){vec4 wp=modelMatrix*vec4(position,1.);vN=normalize(mat3(modelMatrix)*normal);vV=normalize(cameraPosition-wp.xyz);gl_Position=projectionMatrix*viewMatrix*wp;}";
+declare const SHELL_FRAGMENT = "uniform float uA;varying vec3 vN;varying vec3 vV;void main(){float f=1.-abs(dot(vN,vV));f=pow(f,5.);gl_FragColor=vec4(vec3(1.,.93,.82)*f*uA*.45,1.);\n  #include <tonemapping_fragment>\n  #include <colorspace_fragment>\n}";
+declare const RING_VERTEX = "varying vec2 vU;void main(){vU=position.xz;gl_Position=projectionMatrix*viewMatrix*modelMatrix*vec4(position,1.);}";
+declare const RING_FRAGMENT = "uniform float uA;uniform float uW;uniform vec3 uC;varying vec2 vU;\n  float h(vec2 p){return fract(sin(dot(p,vec2(12.9898,78.233)))*43758.5453);}\n  void main(){float r=length(vU);float b=smoothstep(1.,1.-uW,r)*smoothstep(1.-uW*3.5,1.-uW,r);float a=atan(vU.y,vU.x);float n=.7+.3*h(vec2(floor(a*14.),1.));gl_FragColor=vec4(uC,b*uA*n);\n  #include <tonemapping_fragment>\n  #include <colorspace_fragment>\n}";
+
+export { type BenchText, type CanvasContextLike, type CanvasLike, GLOW_FRAGMENT, GLOW_VERTEX, type GroundPatch, type GroundPatchOptions, type MarkLayer, type MarkLayerOptions, PUFF_FRAGMENT, PUFF_VERTEX, RING_FRAGMENT, RING_VERTEX, SHELL_FRAGMENT, SHELL_VERTEX, SPARK_FRAGMENT, SPARK_VERTEX, SPRITE_FRAGMENT, SPRITE_VERTEX, type ScreenOverlay, type SpriteLayer, type ThreeLib, VFX_LAYERS, type VfxRenderer, type VfxRendererOptions, type VfxRendererStats, type VfxTestModuleOptions, benchText, benchTexts, createGroundPatch, createMarkLayer, createScreenOverlay, createSpriteLayer, createVfxRenderer, createVfxTestModule };