three-ilda 0.1.0

package/src/webgl/LaserShowPipeline.js

@@ -0,0 +1,168 @@
+import { Color, DepthTexture, HalfFloatType, Layers, NoBlending, ShaderMaterial, Vector2, WebGLRenderTarget } from 'three'
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js'
+import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js'
+
+const QUAD_VERTEX = /* glsl */`
+varying vec2 vUv;
+void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`
+
+// Separable Gaussian with sigma 3 texels, the GaussianBlurNode settings of the node pipeline.
+function blurFragment(sigma = 3, radius = 8) {
+  const weights = []; let sum = 0
+  for (let i = 0; i <= radius; i++) { const w = Math.exp(-(i * i) / (2 * sigma * sigma)); weights.push(w); sum += i ? 2 * w : w }
+  const taps = weights.map((w, i) => i
+    ? `sum += (texture2D(tDiffuse, vUv + direction * ${i}.0) + texture2D(tDiffuse, vUv - direction * ${i}.0)) * ${(w / sum).toFixed(6)};`
+    : `vec4 sum = texture2D(tDiffuse, vUv) * ${(w / sum).toFixed(6)};`)
+  return /* glsl */`
+uniform sampler2D tDiffuse;
+uniform vec2 direction;
+varying vec2 vUv;
+void main() {
+  ${taps.join('\n  ')}
+  gl_FragColor = sum;
+}`
+}
+
+const COMPOSITE_FRAGMENT = /* glsl */`
+uniform sampler2D tScene, tBeams;
+uniform float haze;
+varying vec2 vUv;
+void main() {
+  vec4 scene = texture2D(tScene, vUv);
+  vec3 beams = texture2D(tBeams, vUv).rgb;
+  float protect = 1.0 - smoothstep(0.025, 0.3, max(scene.r, max(scene.g, scene.b)));
+  gl_FragColor = vec4(scene.rgb + (1.0 - exp(-beams)) * 0.14 * protect * haze, scene.a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`
+
+/** @typedef {import('../core/LaserShowBase.js').LaserShowBase} LaserShowBase */
+/**
+ * @typedef {Object} LaserShowPipelineOptions
+ * @property {number} [beamLayer] Layer reserved for beam meshes, 1 to 31 (default 31).
+ * @property {number} [strength] Bloom strength (default 15).
+ * @property {number} [radius] Bloom radius (default 1).
+ * @property {number} [threshold] Bloom luminance threshold (default 0).
+ * @property {number} [samples] MSAA samples of the scene pass (default 4).
+ */
+
+/**
+ * Post-processing for THREE.WebGLRenderer (the WebGL 2 version) with the same structure as the node pipeline:
+ * scene pass with a depth texture, bloom, a half-resolution beam pass faded by scene depth, blur and haze compositing.
+ * Uses the host's scene and camera; reserves beamLayer (default 31) for registered beam meshes.
+ */
+export class LaserShowPipeline {
+  /**
+   * @param {import('three').WebGLRenderer} renderer
+   * @param {import('three').Scene} scene
+   * @param {import('three').Camera} camera
+   * @param {LaserShowPipelineOptions} [options]
+   */
+  constructor(renderer, scene, camera, { beamLayer = 31, strength = 15, radius = 1, threshold = 0, samples = 4 } = {}) {
+    if (!Number.isInteger(beamLayer) || beamLayer < 1 || beamLayer > 31) throw new RangeError('beamLayer must be an integer from 1 to 31.')
+    this.renderer = renderer; this.scene = scene; this.camera = camera; this.beamLayer = beamLayer
+    /** @type {Map<LaserShowBase, { mask: number, uniforms: Record<string, { value: unknown }>, onDispose: () => void }>} */
+    this.shows = new Map()
+    this.disposed = false
+    this._size = new Vector2(); this._clear = new Color(); this._beamLayers = new Layers(); this._beamLayers.set(beamLayer)
+    this.sceneTarget = new WebGLRenderTarget(1, 1, { type: HalfFloatType, samples, depthTexture: new DepthTexture(1, 1) })
+    this.beamTarget = new WebGLRenderTarget(1, 1, { type: HalfFloatType, depthBuffer: false })
+    this.blurTarget = new WebGLRenderTarget(1, 1, { type: HalfFloatType, depthBuffer: false })
+    this.glow = new UnrealBloomPass(new Vector2(1, 1), strength, radius, threshold)
+    // UnrealBloomPass scales its composite by 3 "for backwards compatibility"; the TSL BloomNode does not.
+    // Drop the factor so glow.strength means the same in both versions (measured before this: WebGL 2 at 5 matched TSL at 15).
+    const composite = this.glow.compositeMaterial
+    if (composite.fragmentShader.includes('3.0 * bloomStrength')) { composite.fragmentShader = composite.fragmentShader.replace('3.0 * bloomStrength', 'bloomStrength'); composite.needsUpdate = true }
+    this._blur = new FullScreenQuad(new ShaderMaterial({
+      uniforms: { tDiffuse: { value: null }, direction: { value: new Vector2() } },
+      vertexShader: QUAD_VERTEX, fragmentShader: blurFragment(), depthTest: false, depthWrite: false, blending: NoBlending,
+    }))
+    this._composite = new FullScreenQuad(new ShaderMaterial({
+      uniforms: { tScene: { value: this.sceneTarget.texture }, tBeams: { value: this.beamTarget.texture }, haze: { value: 0 } },
+      vertexShader: QUAD_VERTEX, fragmentShader: COMPOSITE_FRAGMENT, depthTest: false, depthWrite: false, blending: NoBlending,
+    }))
+    // Shared by every registered beam material and refreshed on each render.
+    this._depth = {
+      tDepth: { value: this.sceneTarget.depthTexture }, resolution: { value: new Vector2(1, 1) },
+      cameraNear: { value: camera.near }, cameraFar: { value: camera.far }, orthographic: { value: camera.isOrthographicCamera === true },
+    }
+  }
+
+  /** @param {LaserShowBase} show @returns {this} */
+  add(show) {
+    if (this.shows.has(show)) return this
+    if (!show.isLaserShow || show.disposed) throw new TypeError('Expected a live LaserShow.')
+    const material = show.beams.material
+    if (!material.isShaderMaterial) throw new TypeError('Expected a LaserShow from the three-ilda/webgl entry.')
+    if (show.beams.userData.laserPipeline) throw new Error('This LaserShow already belongs to another LaserShowPipeline.')
+    const saved = { mask: show.beams.layers.mask, uniforms: {}, onDispose: () => this.remove(show) }
+    for (const key of Object.keys(this._depth)) { saved.uniforms[key] = material.uniforms[key]; material.uniforms[key] = this._depth[key] }
+    material.defines.DEPTH_FADE = ''; material.needsUpdate = true
+    show.beams.layers.set(this.beamLayer); show.beams.userData.laserPipeline = this
+    show.addEventListener('dispose', saved.onDispose); this.shows.set(show, saved)
+    return this
+  }
+
+  /** @param {LaserShowBase} show @returns {this} */
+  remove(show) {
+    const saved = this.shows.get(show)
+    if (!saved) return this
+    const material = show.beams.material
+    for (const key of Object.keys(saved.uniforms)) material.uniforms[key] = saved.uniforms[key]
+    delete material.defines.DEPTH_FADE; material.needsUpdate = true
+    show.beams.layers.mask = saved.mask; delete show.beams.userData.laserPipeline
+    show.removeEventListener('dispose', saved.onDispose); this.shows.delete(show)
+    return this
+  }
+
+  _resize(width, height) {
+    this.sceneTarget.setSize(width, height)
+    const w = Math.max(1, Math.round(width / 2)), h = Math.max(1, Math.round(height / 2))
+    this.beamTarget.setSize(w, h); this.blurTarget.setSize(w, h)
+    this.glow.setSize(width, height)
+    this._depth.resolution.value.set(w, h)
+  }
+
+  render() {
+    if (this.disposed) return
+    const { renderer, scene, camera } = this
+    renderer.getDrawingBufferSize(this._size)
+    const width = Math.max(1, Math.floor(this._size.x)), height = Math.max(1, Math.floor(this._size.y))
+    if (width !== this.sceneTarget.width || height !== this.sceneTarget.height) this._resize(width, height)
+    let beams = false
+    for (const show of this.shows.keys()) {
+      let visible = show.beams.visible && show.beamIntensity > 0
+      for (let parent = show; parent; parent = parent.parent) visible &&= parent.visible
+      if (visible) { beams = true; break }
+    }
+    const target = renderer.getRenderTarget(), mask = camera.layers.mask, autoClear = renderer.autoClear
+    renderer.autoClear = true
+    camera.layers.disable(this.beamLayer)
+    renderer.setRenderTarget(this.sceneTarget); renderer.render(scene, camera)
+    this.glow.render(renderer, null, this.sceneTarget, 0, false) // adds bloom in place
+    if (beams) {
+      this._depth.cameraNear.value = camera.near; this._depth.cameraFar.value = camera.far; this._depth.orthographic.value = camera.isOrthographicCamera === true
+      const background = scene.background, alpha = renderer.getClearAlpha(); renderer.getClearColor(this._clear)
+      scene.background = null; renderer.setClearColor(0x000000, 0); camera.layers.mask = this._beamLayers.mask
+      renderer.setRenderTarget(this.beamTarget); renderer.render(scene, camera)
+      scene.background = background; renderer.setClearColor(this._clear, alpha)
+      const blur = this._blur.material.uniforms
+      blur.tDiffuse.value = this.beamTarget.texture; blur.direction.value.set(1 / this.beamTarget.width, 0)
+      renderer.setRenderTarget(this.blurTarget); this._blur.render(renderer)
+      blur.tDiffuse.value = this.blurTarget.texture; blur.direction.value.set(0, 1 / this.beamTarget.height)
+      renderer.setRenderTarget(this.beamTarget); this._blur.render(renderer)
+    }
+    camera.layers.mask = mask
+    this._composite.material.uniforms.haze.value = beams ? 1 : 0
+    renderer.setRenderTarget(target); this._composite.render(renderer)
+    renderer.autoClear = autoClear
+  }
+
+  dispose() {
+    if (this.disposed) return
+    for (const show of [...this.shows.keys()]) this.remove(show)
+    this.sceneTarget.depthTexture.dispose(); this.sceneTarget.dispose(); this.beamTarget.dispose(); this.blurTarget.dispose()
+    this.glow.dispose(); this._blur.material.dispose(); this._blur.dispose(); this._composite.material.dispose(); this._composite.dispose()
+    this.disposed = true
+  }
+}

package/src/webgl.js

@@ -0,0 +1,10 @@
+/** @typedef {import('./loaders/ILDALoader.js').ILDAAsset} ILDAAsset */
+/** @typedef {import('./loaders/ILDALoader.js').ILDAFrame} ILDAFrame */
+/** @typedef {import('./core/LaserScanner.js').ScannerParams} ScannerParams */
+/** @typedef {import('./core/LaserShowBase.js').LaserShowOptions} LaserShowOptions */
+/** @typedef {import('./core/LaserShowBase.js').BeamMode} BeamMode */
+/** @typedef {import('./webgl/LaserShowPipeline.js').LaserShowPipelineOptions} LaserShowPipelineOptions */
+export { ILDALoader, ILDA_DEFAULT_PALETTE } from './loaders/ILDALoader.js'
+export { LaserScanner, SCANNER_DEFAULTS, TRAIL_POINTS } from './core/LaserScanner.js'
+export { LaserShow } from './webgl/LaserShow.js'
+export { LaserShowPipeline } from './webgl/LaserShowPipeline.js'

package/types/core/LaserScanner.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @typedef {Object} ScannerParams
+ * @property {number} rate Samples per second.
+ * @property {number} gain Mirror spring constant.
+ * @property {number} dampening Fraction of velocity kept per sample (larger = less damping).
+ * @property {number} blankingOffset Blank-flag offset in points.
+ * @property {number} lightDecay Afterglow factor per 1/60 s.
+ */
+export const TRAIL_POINTS: 2048;
+/** @type {Readonly<ScannerParams>} */
+export const SCANNER_DEFAULTS: Readonly<ScannerParams>;
+/** The demo's per-sample galvo recurrence, with a fixed-size ring instead of shifting/allocating arrays each frame. */
+export class LaserScanner {
+    /**
+     * @param {import('../loaders/ILDALoader.js').ILDAFrame[]} frames Frames of one projector track.
+     * @param {number} [capacity] Ring size in samples.
+     */
+    constructor(frames: import("../loaders/ILDALoader.js").ILDAFrame[], capacity?: number);
+    frames: import("../loaders/ILDALoader.js").ILDAFrame[];
+    capacity: number;
+    starts: number[];
+    total: number;
+    position: Float32Array<ArrayBuffer>;
+    color: Float32Array<ArrayBuffer>;
+    blank: Uint8Array<ArrayBuffer>;
+    born: Float64Array<ArrayBuffer>;
+    output: {
+        position: Float32Array<ArrayBuffer>;
+        color: Float32Array<ArrayBuffer>;
+        blank: Uint8Array<ArrayBuffer>;
+        count: number;
+    };
+    /** @param {number} [frame] */
+    reset(frame?: number): void;
+    frame: any;
+    index: number;
+    lastFrame: any;
+    x: number;
+    y: number;
+    vx: any;
+    vy: any;
+    time: number;
+    fraction: number;
+    write: any;
+    count: any;
+    samples: number;
+    get point(): number;
+    /** @param {number} offset @returns {number} */
+    blankAtOffset(offset: number): number;
+    /** @param {ScannerParams} params @param {number} born */
+    sample(params: ScannerParams, born: number): void;
+    /** @param {number} dt Seconds. @param {ScannerParams} params @returns {number} Samples produced. */
+    advance(dt: number, params: ScannerParams): number;
+    /** @param {number} frame @param {ScannerParams} params */
+    seekFrame(frame: number, params: ScannerParams): void;
+    /** @param {number} lightDecay */
+    snapshot(lightDecay: number): {
+        position: Float32Array<ArrayBuffer>;
+        color: Float32Array<ArrayBuffer>;
+        blank: Uint8Array<ArrayBuffer>;
+        count: number;
+    };
+}
+export type ScannerParams = {
+    /**
+     * Samples per second.
+     */
+    rate: number;
+    /**
+     * Mirror spring constant.
+     */
+    gain: number;
+    /**
+     * Fraction of velocity kept per sample (larger = less damping).
+     */
+    dampening: number;
+    /**
+     * Blank-flag offset in points.
+     */
+    blankingOffset: number;
+    /**
+     * Afterglow factor per 1/60 s.
+     */
+    lightDecay: number;
+};

package/types/core/LaserShowBase.d.ts

@@ -0,0 +1,166 @@
+/** @typedef {import('../loaders/ILDALoader.js').ILDAAsset} ILDAAsset */
+/** @typedef {'Disabled' | 'Front' | 'Back'} BeamMode */
+/**
+ * @typedef {Object} LaserShowOptions
+ * @property {number} [track] Projector track to play; defaults to the first track of the asset.
+ * @property {number} [capacity] Trail length in samples, 2 to 65536 (default 2048).
+ * @property {number} [width] Projection width in local units at zoom 1 (default 4.8).
+ * @property {number} [height] Projection height in local units at zoom 1 (default 3.2).
+ */
+/**
+ * Renderer-independent part of a laser show: scene graph, scanner playback, segment compaction and buffer uploads.
+ * The image lies in local XY at Z=0; Front is +Z, Back is -Z, regardless of the camera.
+ * One instance plays one ILDA projector track. Assets may be shared; playback/GPU buffers are independent.
+ * A subclass supplies the two materials through _createMaterials(); the uniform handles it returns only need a `.value`.
+ */
+export class LaserShowBase extends Group<import("three").Object3DEventMap> {
+    /**
+     * @param {ILDAAsset | null} [asset] Parsed ILDA file; call setData() later when omitted.
+     * @param {LaserShowOptions} [options]
+     */
+    constructor(asset?: ILDAAsset | null, { track, capacity, width, height }?: LaserShowOptions);
+    type: string;
+    isLaserShow: boolean;
+    capacity: number;
+    playing: boolean;
+    disposed: boolean;
+    /** @type {import('./LaserScanner.js').ScannerParams} */
+    _params: import("./LaserScanner.js").ScannerParams;
+    /** @type {BeamMode} */
+    _beamMode: BeamMode;
+    _zoom: number;
+    _dirty: boolean;
+    /** @type {ILDAAsset | null} */ asset: ILDAAsset | null;
+    /** @type {number | undefined} */ track: number | undefined;
+    /** @type {LaserScanner | null} */ scanner: LaserScanner | null;
+    _projectionSize: Vector2;
+    _scale: {
+        value: import("three").Vector3;
+    };
+    _origin: {
+        value: import("three").Vector3;
+    };
+    _clock: {
+        value: number;
+    };
+    _intensity: {
+        value: number;
+    };
+    _beamIntensity: {
+        value: number;
+    };
+    projector: Object3D<import("three").Object3DEventMap>;
+    _linePosition: BufferAttribute<import("three").BufferAttributeEventMap>;
+    _lineColor: BufferAttribute<import("three").BufferAttributeEventMap>;
+    projection: LineSegments<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material<import("three").MaterialEventMap>, import("three").Object3DEventMap>;
+    _beamPosition: BufferAttribute<import("three").BufferAttributeEventMap>;
+    _beamColor: BufferAttribute<import("three").BufferAttributeEventMap>;
+    beams: Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material<import("three").MaterialEventMap>, import("three").Object3DEventMap>;
+    /**
+     * Creates the line and beam materials for one renderer family.
+     * @returns {{ line: import('three').Material, beam: import('three').Material, scale: { value: import('three').Vector3 }, origin: { value: import('three').Vector3 }, clock: { value: number }, intensity: { value: number }, beamIntensity: { value: number } }}
+     */
+    _createMaterials(): {
+        line: import("three").Material;
+        beam: import("three").Material;
+        scale: {
+            value: import("three").Vector3;
+        };
+        origin: {
+            value: import("three").Vector3;
+        };
+        clock: {
+            value: number;
+        };
+        intensity: {
+            value: number;
+        };
+        beamIntensity: {
+            value: number;
+        };
+    };
+    set pointRate(v: number);
+    get pointRate(): number;
+    set gain(v: number);
+    get gain(): number;
+    set dampening(v: number);
+    get dampening(): number;
+    set blankingOffset(v: number);
+    get blankingOffset(): number;
+    set lightDecay(v: number);
+    get lightDecay(): number;
+    set zoom(v: number);
+    get zoom(): number;
+    set intensity(v: number);
+    get intensity(): number;
+    set beamIntensity(v: number);
+    get beamIntensity(): number;
+    /** @param {BeamMode} mode */
+    set beamMode(mode: BeamMode);
+    get beamMode(): BeamMode;
+    get frame(): any;
+    get frameCount(): number;
+    get time(): number;
+    get trackIds(): number[];
+    get projectionSize(): Vector2;
+    /** @param {number} width @param {number} height @returns {this} */
+    setProjectionSize(width: number, height: number): this;
+    _updateScale(): void;
+    _retune(): void;
+    /**
+     * Replaces the played file, building a fresh scanner for one projector track.
+     * @param {ILDAAsset} asset
+     * @param {number} [track] Defaults to the first track of the asset.
+     * @returns {this}
+     */
+    setData(asset: ILDAAsset, track?: number): this;
+    /** @param {number} track @returns {this} */
+    setTrack(track: number): this;
+    /** @param {number} frame @returns {this} */
+    seekFrame(frame: number): this;
+    reset(): this;
+    /**
+     * Advances playback and uploads the trail. Call once per application frame, including while paused to apply parameter changes.
+     * @param {number} [delta] Seconds since the previous call.
+     * @returns {this}
+     */
+    update(delta?: number): this;
+    /**
+     * Clone shares the immutable asset, but copies scanner history and allocates independent GPU resources.
+     * @param {boolean} [recursive]
+     * @returns {this}
+     */
+    clone(recursive?: boolean): this;
+    /** @param {LaserShowBase} source @param {boolean} [recursive] @returns {this} */
+    copy(source: LaserShowBase, recursive?: boolean): this;
+    /** Releases only this instance's GPU resources; shared ILDA data stays usable. */
+    dispose(): void;
+}
+export type ILDAAsset = import("../loaders/ILDALoader.js").ILDAAsset;
+export type BeamMode = "Disabled" | "Front" | "Back";
+export type LaserShowOptions = {
+    /**
+     * Projector track to play; defaults to the first track of the asset.
+     */
+    track?: number;
+    /**
+     * Trail length in samples, 2 to 65536 (default 2048).
+     */
+    capacity?: number;
+    /**
+     * Projection width in local units at zoom 1 (default 4.8).
+     */
+    width?: number;
+    /**
+     * Projection height in local units at zoom 1 (default 3.2).
+     */
+    height?: number;
+};
+import { Group } from 'three';
+import { LaserScanner } from './LaserScanner.js';
+import { Vector2 } from 'three';
+import { Object3D } from 'three';
+import { BufferAttribute } from 'three';
+import { BufferGeometry } from 'three';
+import { LineSegments } from 'three';
+import { Mesh } from 'three';

package/types/index.d.ts

@@ -0,0 +1,10 @@
+export { LaserShow } from "./objects/LaserShow.js";
+export { LaserShowPipeline } from "./postprocessing/LaserShowPipeline.js";
+export type ILDAAsset = import("./loaders/ILDALoader.js").ILDAAsset;
+export type ILDAFrame = import("./loaders/ILDALoader.js").ILDAFrame;
+export type ScannerParams = import("./core/LaserScanner.js").ScannerParams;
+export type LaserShowOptions = import("./core/LaserShowBase.js").LaserShowOptions;
+export type BeamMode = import("./core/LaserShowBase.js").BeamMode;
+export type LaserShowPipelineOptions = import("./postprocessing/LaserShowPipeline.js").LaserShowPipelineOptions;
+export { ILDALoader, ILDA_DEFAULT_PALETTE } from "./loaders/ILDALoader.js";
+export { LaserScanner, SCANNER_DEFAULTS, TRAIL_POINTS } from "./core/LaserScanner.js";

package/types/loaders/ILDALoader.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @typedef {Object} ILDAFrame
+ * @property {number} number Frame number from the file.
+ * @property {string} name Frame name from the file.
+ * @property {number} projector Projector ID from the file (zero-based).
+ * @property {number} count Number of points.
+ * @property {Float32Array} position Interleaved XYZ, normalized by 32768. Z is zero for 2D formats.
+ * @property {Float32Array} color Interleaved RGB in [0, 1], including colors of blanked points.
+ * @property {Uint8Array} blank One flag per point: 1 means laser off.
+ */
+/**
+ * @typedef {Object} ILDAAsset
+ * @property {ILDAFrame[]} frames Point frames in file order; palette records are not frames.
+ * @property {Map<number, ILDAFrame[]>} tracks Frames grouped by projector ID, sharing objects with frames.
+ * @property {number} totalPoints Total number of points in all tracks.
+ * @property {number} blanked Number of blanked points.
+ * @property {number} paletteFallbacks Number of unknown palette indices rendered in white.
+ * @property {boolean} eof Whether an explicit end-of-file record was found.
+ * @property {number} bytes Input size in bytes.
+ * @property {number} parseTimeMs CPU parsing time; excludes downloading and local file reading.
+ */
+/**
+ * ILDA IDTF loader for formats 0, 1, 2, 4 and 5. No renderer, DOM or player dependency.
+ * Uses the standard Three.js LoadingManager, FileLoader and inherited loadAsync().
+ *
+ * @example
+ * const loader = new ILDALoader(manager);
+ * const show = await loader.loadAsync('/shows/example.ild');
+ * const localShow = loader.parse(await file.arrayBuffer());
+ *
+ * @extends Loader
+ */
+export class ILDALoader extends Loader<any, string> {
+    /** @param {import('three').LoadingManager} [manager] */
+    constructor(manager?: import("three").LoadingManager);
+    fallbackPalette: readonly (readonly number[])[];
+    /**
+     * Sets colors for indexed files without a format-2 palette. Embedded palettes always win.
+     * Copies the array; pass null to restore the standard ILDA palette.
+     * @param {ReadonlyArray<ReadonlyArray<number>> | null} palette Between 1 and 256 RGB triplets of integer bytes.
+     * @returns {ILDALoader}
+     */
+    setFallbackPalette(palette: ReadonlyArray<ReadonlyArray<number>> | null): ILDALoader;
+    /**
+     * @param {string} url URL or path, resolved by the loading manager.
+     * @param {(asset: ILDAAsset) => void} onLoad
+     * @param {(event: ProgressEvent) => void} [onProgress]
+     * @param {(error: Error) => void} [onError] Receives download and parsing errors.
+     */
+    load(url: string, onLoad: (asset: ILDAAsset) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: Error) => void): void;
+    /**
+     * Parses already-loaded bytes synchronously. Does not create geometry or apply scanner settings.
+     * @param {ArrayBuffer} buffer
+     * @returns {ILDAAsset}
+     * @throws {Error} On invalid data, unsupported formats or the 32 MiB / 2M point limits.
+     */
+    parse(buffer: ArrayBuffer): ILDAAsset;
+}
+export const ILDA_DEFAULT_PALETTE: readonly (readonly number[])[];
+export type ILDAFrame = {
+    /**
+     * Frame number from the file.
+     */
+    number: number;
+    /**
+     * Frame name from the file.
+     */
+    name: string;
+    /**
+     * Projector ID from the file (zero-based).
+     */
+    projector: number;
+    /**
+     * Number of points.
+     */
+    count: number;
+    /**
+     * Interleaved XYZ, normalized by 32768. Z is zero for 2D formats.
+     */
+    position: Float32Array;
+    /**
+     * Interleaved RGB in [0, 1], including colors of blanked points.
+     */
+    color: Float32Array;
+    /**
+     * One flag per point: 1 means laser off.
+     */
+    blank: Uint8Array;
+};
+export type ILDAAsset = {
+    /**
+     * Point frames in file order; palette records are not frames.
+     */
+    frames: ILDAFrame[];
+    /**
+     * Frames grouped by projector ID, sharing objects with frames.
+     */
+    tracks: Map<number, ILDAFrame[]>;
+    /**
+     * Total number of points in all tracks.
+     */
+    totalPoints: number;
+    /**
+     * Number of blanked points.
+     */
+    blanked: number;
+    /**
+     * Number of unknown palette indices rendered in white.
+     */
+    paletteFallbacks: number;
+    /**
+     * Whether an explicit end-of-file record was found.
+     */
+    eof: boolean;
+    /**
+     * Input size in bytes.
+     */
+    bytes: number;
+    /**
+     * CPU parsing time; excludes downloading and local file reading.
+     */
+    parseTimeMs: number;
+};
+import { Loader } from 'three';

package/types/objects/LaserShow.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Laser show for THREE.WebGPURenderer (the WebGPU / TSL version): node materials with the projection and beam math in TSL.
+ * Playback, buffers and the public API live in LaserShowBase; ../webgl/LaserShow.js is the WebGL 2 version for WebGLRenderer.
+ */
+export class LaserShow extends LaserShowBase {
+    _createMaterials(): {
+        line: LineBasicNodeMaterial;
+        beam: MeshBasicNodeMaterial;
+        scale: import("three/webgpu").UniformNode<"vec3", Vector3>;
+        origin: import("three/webgpu").UniformNode<"vec3", Vector3>;
+        clock: import("three/webgpu").UniformNode<"float", number>;
+        intensity: import("three/webgpu").UniformNode<"float", number>;
+        beamIntensity: import("three/webgpu").UniformNode<"float", number>;
+    };
+}
+import { LaserShowBase } from '../core/LaserShowBase.js';
+import { LineBasicNodeMaterial } from 'three/webgpu';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { Vector3 } from 'three/webgpu';

package/types/postprocessing/LaserShowPipeline.d.ts

@@ -0,0 +1,89 @@
+/** @typedef {import('../core/LaserShowBase.js').LaserShowBase} LaserShowBase */
+/**
+ * @typedef {Object} LaserShowPipelineOptions
+ * @property {number} [beamLayer] Layer reserved for beam meshes, 1 to 31 (default 31).
+ * @property {number} [strength] Bloom strength (default 15).
+ * @property {number} [radius] Bloom radius (default 1).
+ * @property {number} [threshold] Bloom luminance threshold (default 0).
+ * @property {number} [samples] MSAA samples of the scene pass (default 4).
+ * @property {boolean} [inspect] Label the passes for the r185 Inspector (default false).
+ */
+/**
+ * Optional post-processing owned by the host application. Uses its scene, camera and renderer.
+ * Reserves beamLayer (default 31); all other objects keep their normal camera layers.
+ * One pipeline can serve multiple registered LaserShow objects in the same scene.
+ */
+export class LaserShowPipeline {
+    /**
+     * @param {import('three/webgpu').WebGPURenderer} renderer
+     * @param {import('three').Scene} scene
+     * @param {import('three').Camera} camera
+     * @param {LaserShowPipelineOptions} [options]
+     */
+    constructor(renderer: import("three/webgpu").WebGPURenderer, scene: import("three").Scene, camera: import("three").Camera, { beamLayer, strength, radius, threshold, samples, inspect }?: LaserShowPipelineOptions);
+    renderer: import("three/webgpu").WebGPURenderer;
+    camera: import("three").Camera;
+    beamLayer: number;
+    /** @type {Map<LaserShowBase, { mask: number, opacity: unknown, onDispose: () => void }>} */
+    shows: Map<LaserShowBase, {
+        mask: number;
+        opacity: unknown;
+        onDispose: () => void;
+    }>;
+    disposed: boolean;
+    _withBeams: boolean;
+    _baseLayers: Layers;
+    scenePass: PassNode;
+    _near: any;
+    _far: any;
+    _sceneViewZ: import("three/webgpu").Node<"float">;
+    beamPass: BeamPass;
+    glow: import("three/addons/tsl/display/BloomNode.js").default;
+    blur: import("three/addons/tsl/display/GaussianBlurNode.js").default;
+    projectionOutput: any;
+    beamOutput: import("three/webgpu").VarNode<"vec4", import("three/webgpu").ConstNode<"vec4", import("three").Vector4>>;
+    pipeline: RenderPipeline;
+    /** @param {LaserShowBase} show @returns {this} */
+    add(show: LaserShowBase): this;
+    /** @param {LaserShowBase} show @returns {this} */
+    remove(show: LaserShowBase): this;
+    render(): void;
+    dispose(): void;
+}
+export type LaserShowBase = import("../core/LaserShowBase.js").LaserShowBase;
+export type LaserShowPipelineOptions = {
+    /**
+     * Layer reserved for beam meshes, 1 to 31 (default 31).
+     */
+    beamLayer?: number;
+    /**
+     * Bloom strength (default 15).
+     */
+    strength?: number;
+    /**
+     * Bloom radius (default 1).
+     */
+    radius?: number;
+    /**
+     * Bloom luminance threshold (default 0).
+     */
+    threshold?: number;
+    /**
+     * MSAA samples of the scene pass (default 4).
+     */
+    samples?: number;
+    /**
+     * Label the passes for the r185 Inspector (default false).
+     */
+    inspect?: boolean;
+};
+import { Layers } from 'three/webgpu';
+import { PassNode } from 'three/webgpu';
+declare class BeamPass extends PassNode {
+    constructor(scene: any, camera: any);
+    _clear: Color;
+    updateBefore(frame: any): void;
+}
+import { RenderPipeline } from 'three/webgpu';
+import { Color } from 'three/webgpu';
+export {};