@triforge/compositor-core 0.1.0

package/dist/core/BasePass.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Registry resolved by CompositorOutput at compile time.
+ * Contains three/addons or pmndrs constructors keyed by class name,
+ * plus injected scene/camera under '_scene' and '_camera'.
+ */
+export type PassRegistry = Record<string, unknown>;
+/**
+ * Base class for all compositor pass nodes.
+ *
+ * Each subclass represents one Blender compositor node equivalent.
+ * Subclasses implement _buildThree() and optionally _buildPmndrs().
+ *
+ * All scalar inputs live in the public `parameters` object so they are
+ * reachable by GSAP / st-keyframe.
+ */
+export declare abstract class BasePass {
+    abstract readonly passType: string;
+    /** All scalar inputs — GSAP-animatable. */
+    abstract parameters: Record<string, number>;
+    /** Whether this pass is active. Inactive passes are skipped during compile. */
+    enabled: boolean;
+    /**
+     * Build a Three.js pass object.
+     * Called by CompositorOutput with the resolved three/addons constructors.
+     * @param width  Render target width
+     * @param height Render target height
+     * @param reg    Resolved three/addons constructors (e.g. { UnrealBloomPass, ... })
+     */
+    abstract _buildThree(width: number, height: number, reg: PassRegistry): unknown;
+    /**
+     * Build a pmndrs/postprocessing Effect or Pass.
+     * Override in subclasses that support the pmndrs backend.
+     * Default throws a clear error.
+     * @param reg  Resolved postprocessing constructors
+     */
+    _buildPmndrs(_reg: PassRegistry): unknown;
+    /**
+     * True when _buildPmndrs() returns a pmndrs Effect (merged into EffectPass).
+     * False when it returns a standalone Pass added directly to the composer.
+     */
+    get _isPmndrsEffect(): boolean;
+    /**
+     * Names of three/addons postprocessing module files this pass needs loaded.
+     * e.g. ['UnrealBloomPass', 'ShaderPass']
+     * CompositorOutput reads this to pre-load the registry before calling _buildThree().
+     */
+    _threePassDeps(): string[];
+}
+//# sourceMappingURL=BasePass.d.ts.map

package/dist/core/BasePass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasePass.d.ts","sourceRoot":"","sources":["../../src/core/BasePass.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAElD;;;;;;;;GAQG;AACH,8BAAsB,QAAQ;IAC5B,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAElC,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAE3C,+EAA+E;IAC/E,OAAO,UAAO;IAEd;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;IAE/E;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IAOzC;;;OAGG;IACH,IAAI,eAAe,IAAI,OAAO,CAAiB;IAE/C;;;;OAIG;IACH,cAAc,IAAI,MAAM,EAAE;CAC3B"}

package/dist/core/BasePass.js

@@ -0,0 +1,36 @@
+/**
+ * Base class for all compositor pass nodes.
+ *
+ * Each subclass represents one Blender compositor node equivalent.
+ * Subclasses implement _buildThree() and optionally _buildPmndrs().
+ *
+ * All scalar inputs live in the public `parameters` object so they are
+ * reachable by GSAP / st-keyframe.
+ */
+export class BasePass {
+    constructor() {
+        /** Whether this pass is active. Inactive passes are skipped during compile. */
+        this.enabled = true;
+    }
+    /**
+     * Build a pmndrs/postprocessing Effect or Pass.
+     * Override in subclasses that support the pmndrs backend.
+     * Default throws a clear error.
+     * @param reg  Resolved postprocessing constructors
+     */
+    _buildPmndrs(_reg) {
+        throw new Error(`${this.passType}: pmndrs backend is not supported for this pass. ` +
+            `Use backend: 'three' or choose a pass that supports pmndrs.`);
+    }
+    /**
+     * True when _buildPmndrs() returns a pmndrs Effect (merged into EffectPass).
+     * False when it returns a standalone Pass added directly to the composer.
+     */
+    get _isPmndrsEffect() { return false; }
+    /**
+     * Names of three/addons postprocessing module files this pass needs loaded.
+     * e.g. ['UnrealBloomPass', 'ShaderPass']
+     * CompositorOutput reads this to pre-load the registry before calling _buildThree().
+     */
+    _threePassDeps() { return []; }
+}

package/dist/core/CompositorBackend.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Backend selector — controls which post-processing library is used.
+ *
+ * 'three'  (default) — Three.js built-in EffectComposer from three/addons/.
+ *                      No extra install required. One render pass per effect.
+ *
+ * 'pmndrs'           — pmndrs/postprocessing library.
+ *                      Install: npm install postprocessing
+ *                      Single-pass architecture, better performance and quality.
+ */
+export type CompositorBackend = 'three' | 'pmndrs';
+//# sourceMappingURL=CompositorBackend.d.ts.map

package/dist/core/CompositorBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositorBackend.d.ts","sourceRoot":"","sources":["../../src/core/CompositorBackend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,QAAQ,CAAA"}

package/dist/core/CompositorBackend.js

@@ -0,0 +1 @@
+export {};

package/dist/core/CompositorOutput.d.ts

@@ -0,0 +1,73 @@
+import { WebGLRenderer, Scene, Camera } from 'three';
+import type { BasePass } from './BasePass.js';
+import type { CompositorBackend } from './CompositorBackend.js';
+export interface CompositorOutputOptions {
+    /**
+     * Post-processing backend.
+     * 'three'  (default) — three/addons EffectComposer, no extra install needed.
+     * 'pmndrs'           — pmndrs/postprocessing. Run: npm install postprocessing
+     */
+    backend?: CompositorBackend;
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+}
+/**
+ * CompositorOutput — terminal node of the compositor graph.
+ *
+ * Equivalent to Blender's Compositor → Composite node.
+ * Collects all passes, compiles them into an EffectComposer,
+ * and exposes render() which replaces renderer.render() in the loop.
+ *
+ * Backend is 'three' by default. To use pmndrs/postprocessing:
+ *   const comp = new CompositorOutput({ backend: 'pmndrs', renderer, scene, camera })
+ *   // requires: npm install postprocessing
+ *
+ * Usage:
+ *   const comp = new CompositorOutput({ renderer, scene, camera })
+ *   comp.add(new Bloom({ strength: 1.2 }))
+ *      .add(new ChromaticAberration({ offset: 0.002 }))
+ *   await comp.compile()
+ *
+ *   // In animation loop — replaces renderer.render(scene, camera)
+ *   comp.render()
+ *
+ *   // On resize
+ *   comp.setSize(innerWidth, innerHeight)
+ */
+export declare class CompositorOutput {
+    readonly backend: CompositorBackend;
+    private _renderer;
+    private _scene;
+    private _camera;
+    private _passes;
+    private _composer;
+    private _compiled;
+    constructor(opts: CompositorOutputOptions);
+    /** Add a pass node. Chainable. Resets compiled state. */
+    add(pass: BasePass): this;
+    /** Remove a pass node. Chainable. Resets compiled state. */
+    remove(pass: BasePass): this;
+    /** All currently registered passes (read-only view). */
+    get passes(): readonly BasePass[];
+    /** Whether compile() has been called successfully. */
+    get isCompiled(): boolean;
+    /**
+     * Compile the pass chain into an EffectComposer.
+     * Must be called once before render(). Re-call after adding/removing passes.
+     */
+    compile(): Promise<void>;
+    /**
+     * Render one frame through the compositor chain.
+     * Replaces renderer.render(scene, camera) in the animation loop.
+     * Falls back to plain render if compile() has not been called.
+     */
+    render(): void;
+    /** Call on window resize to keep the render target in sync. */
+    setSize(width: number, height: number): void;
+    dispose(): void;
+    private _compileThree;
+    private _loadThreePassModules;
+    private _compilePmndrs;
+}
+//# sourceMappingURL=CompositorOutput.d.ts.map

package/dist/core/CompositorOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositorOutput.d.ts","sourceRoot":"","sources":["../../src/core/CompositorOutput.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAAE,KAAK,EAAE,MAAM,EAE7B,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,EAAE,QAAQ,EAAgB,MAAM,eAAe,CAAA;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAW,wBAAwB,CAAA;AAEpE,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,OAAO,CAAC,EAAG,iBAAiB,CAAA;IAC5B,QAAQ,EAAG,aAAa,CAAA;IACxB,KAAK,EAAM,KAAK,CAAA;IAChB,MAAM,EAAK,MAAM,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IAEnC,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,SAAS,CAAS;gBAEd,IAAI,EAAE,uBAAuB;IAOzC,yDAAyD;IACzD,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAMzB,4DAA4D;IAC5D,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAM5B,wDAAwD;IACxD,IAAI,MAAM,IAAI,SAAS,QAAQ,EAAE,CAAwB;IAEzD,sDAAsD;IACtD,IAAI,UAAU,IAAI,OAAO,CAA0B;IAEnD;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAc9B;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAQd,+DAA+D;IAC/D,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAK5C,OAAO,IAAI,IAAI;YAQD,aAAa;YAgEb,qBAAqB;YA4BrB,cAAc;CAgD7B"}

package/dist/core/CompositorOutput.js

@@ -0,0 +1,201 @@
+import { Vector2, WebGLRenderTarget, LinearFilter, RGBAFormat, HalfFloatType, } from 'three';
+/**
+ * CompositorOutput — terminal node of the compositor graph.
+ *
+ * Equivalent to Blender's Compositor → Composite node.
+ * Collects all passes, compiles them into an EffectComposer,
+ * and exposes render() which replaces renderer.render() in the loop.
+ *
+ * Backend is 'three' by default. To use pmndrs/postprocessing:
+ *   const comp = new CompositorOutput({ backend: 'pmndrs', renderer, scene, camera })
+ *   // requires: npm install postprocessing
+ *
+ * Usage:
+ *   const comp = new CompositorOutput({ renderer, scene, camera })
+ *   comp.add(new Bloom({ strength: 1.2 }))
+ *      .add(new ChromaticAberration({ offset: 0.002 }))
+ *   await comp.compile()
+ *
+ *   // In animation loop — replaces renderer.render(scene, camera)
+ *   comp.render()
+ *
+ *   // On resize
+ *   comp.setSize(innerWidth, innerHeight)
+ */
+export class CompositorOutput {
+    constructor(opts) {
+        this._passes = [];
+        this._composer = null;
+        this._compiled = false;
+        this.backend = opts.backend ?? 'three';
+        this._renderer = opts.renderer;
+        this._scene = opts.scene;
+        this._camera = opts.camera;
+    }
+    /** Add a pass node. Chainable. Resets compiled state. */
+    add(pass) {
+        this._passes.push(pass);
+        this._compiled = false;
+        return this;
+    }
+    /** Remove a pass node. Chainable. Resets compiled state. */
+    remove(pass) {
+        this._passes = this._passes.filter(p => p !== pass);
+        this._compiled = false;
+        return this;
+    }
+    /** All currently registered passes (read-only view). */
+    get passes() { return this._passes; }
+    /** Whether compile() has been called successfully. */
+    get isCompiled() { return this._compiled; }
+    /**
+     * Compile the pass chain into an EffectComposer.
+     * Must be called once before render(). Re-call after adding/removing passes.
+     */
+    async compile() {
+        this._composer?.dispose();
+        this._composer = null;
+        this._compiled = false;
+        if (this.backend === 'pmndrs') {
+            this._composer = await this._compilePmndrs();
+        }
+        else {
+            this._composer = await this._compileThree();
+        }
+        this._compiled = true;
+    }
+    /**
+     * Render one frame through the compositor chain.
+     * Replaces renderer.render(scene, camera) in the animation loop.
+     * Falls back to plain render if compile() has not been called.
+     */
+    render() {
+        if (this._compiled && this._composer) {
+            this._composer.render();
+        }
+        else {
+            this._renderer.render(this._scene, this._camera);
+        }
+    }
+    /** Call on window resize to keep the render target in sync. */
+    setSize(width, height) {
+        this._renderer.setSize(width, height);
+        this._composer?.setSize(width, height);
+    }
+    dispose() {
+        this._composer?.dispose();
+        this._composer = null;
+        this._compiled = false;
+    }
+    // ── Three.js backend ──────────────────────────────────────────────────────
+    async _compileThree() {
+        // Dynamically import three/addons so this package has no hard dependency
+        // on a specific addons path — works with CDN importmap and npm alike.
+        let EC;
+        let RenderPass;
+        let OutputPass;
+        try {
+            const [ecMod, rpMod, opMod] = await Promise.all([
+                import('three/addons/postprocessing/EffectComposer.js'),
+                import('three/addons/postprocessing/RenderPass.js'),
+                import('three/addons/postprocessing/OutputPass.js'),
+            ]);
+            EC = ecMod['EffectComposer'];
+            RenderPass = rpMod['RenderPass'];
+            OutputPass = opMod['OutputPass'];
+        }
+        catch {
+            throw new Error('@st-compositor-core: Could not load three/addons postprocessing modules.\n' +
+                'Make sure "three/addons/" is in your importmap or install three with examples/jsm.\n' +
+                'Example importmap entry:\n' +
+                '  "three/addons/": "https://unpkg.com/three@0.165.0/examples/jsm/"');
+        }
+        const activePasses = this._passes.filter(p => p.enabled);
+        // Load all required per-pass three/addons modules into one registry object
+        const registry = await this._loadThreePassModules(activePasses);
+        const size = new Vector2();
+        this._renderer.getSize(size);
+        const target = new WebGLRenderTarget(size.x, size.y, {
+            minFilter: LinearFilter,
+            magFilter: LinearFilter,
+            format: RGBAFormat,
+            type: HalfFloatType,
+        });
+        const composer = new EC(this._renderer, target);
+        const addPass = (p) => composer.addPass(p);
+        // RenderPass first — renders the scene into the first buffer
+        addPass(new RenderPass(this._scene, this._camera));
+        registry['_renderer'] = this._renderer;
+        registry['_scene'] = this._scene;
+        registry['_camera'] = this._camera;
+        // User passes
+        for (const pass of activePasses) {
+            const built = pass._buildThree(size.x, size.y, registry);
+            if (built !== null)
+                addPass(built);
+        }
+        // OutputPass last — required since Three.js r152 to write to screen correctly
+        addPass(new OutputPass());
+        return composer;
+    }
+    async _loadThreePassModules(passes) {
+        const registry = {};
+        const needed = new Set();
+        for (const pass of passes) {
+            for (const dep of pass._threePassDeps()) {
+                needed.add(dep);
+            }
+        }
+        await Promise.all([...needed].map(async (dep) => {
+            try {
+                const mod = await import(`three/addons/postprocessing/${dep}.js`);
+                Object.assign(registry, mod);
+            }
+            catch {
+                // Pass will throw its own clear error in _buildThree() if dep is missing
+            }
+        }));
+        return registry;
+    }
+    // ── pmndrs backend ────────────────────────────────────────────────────────
+    async _compilePmndrs() {
+        let pkg;
+        try {
+            pkg = await import('postprocessing');
+        }
+        catch {
+            throw new Error('@st-compositor-core: backend "pmndrs" requires the "postprocessing" package.\n' +
+                'Run: npm install postprocessing');
+        }
+        const EC = pkg['EffectComposer'];
+        const RenderPass = pkg['RenderPass'];
+        const EffectPass = pkg['EffectPass'];
+        const composer = new EC(this._renderer);
+        const addPass = (p) => composer.addPass(p);
+        addPass(new RenderPass(this._scene, this._camera));
+        const activePasses = this._passes.filter(p => p.enabled);
+        const effects = [];
+        const standalone = [];
+        for (const pass of activePasses) {
+            // Inject camera into registry so passes that need it (e.g. DepthOfField) can access it
+            const reg = {
+                ...pkg,
+                _camera: this._camera,
+                _scene: this._scene,
+            };
+            const built = pass._buildPmndrs(reg);
+            if (pass._isPmndrsEffect) {
+                effects.push(built);
+            }
+            else {
+                standalone.push(built);
+            }
+        }
+        if (effects.length > 0) {
+            addPass(new EffectPass(this._camera, ...effects));
+        }
+        for (const sp of standalone)
+            addPass(sp);
+        return composer;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+export { BasePass } from './core/BasePass.js';
+export { CompositorOutput } from './core/CompositorOutput.js';
+export type { CompositorBackend } from './core/CompositorBackend.js';
+export type { PassRegistry } from './core/BasePass.js';
+export type { CompositorOutputOptions } from './core/CompositorOutput.js';
+export { Bloom } from './passes/Bloom.js';
+export { DepthOfField } from './passes/DepthOfField.js';
+export { Blur } from './passes/Blur.js';
+export { ChromaticAberration } from './passes/ChromaticAberration.js';
+export { Vignette } from './passes/Vignette.js';
+export { FilmGrain } from './passes/FilmGrain.js';
+export { ColorBalance } from './passes/ColorBalance.js';
+export { HueSaturation } from './passes/HueSaturation.js';
+export { BrightnessContrast } from './passes/BrightnessContrast.js';
+export { Gamma } from './passes/Gamma.js';
+export { Exposure } from './passes/Exposure.js';
+export { Mix } from './passes/Mix.js';
+export { Pixelate } from './passes/Pixelate.js';
+export { Sharpen } from './passes/Sharpen.js';
+export { AlphaOver } from './passes/AlphaOver.js';
+export { SetAlpha } from './passes/SetAlpha.js';
+export { ZCombine } from './passes/ZCombine.js';
+export { SeparateRGBA } from './passes/SeparateRGBA.js';
+export { CombineRGBA } from './passes/CombineRGBA.js';
+export { SSAO } from './passes/SSAO.js';
+export { SSR } from './passes/SSR.js';
+export type { BloomOptions } from './passes/Bloom.js';
+export type { DepthOfFieldOptions } from './passes/DepthOfField.js';
+export type { BlurOptions } from './passes/Blur.js';
+export type { ChromaticAberrationOptions } from './passes/ChromaticAberration.js';
+export type { VignetteOptions } from './passes/Vignette.js';
+export type { FilmGrainOptions } from './passes/FilmGrain.js';
+export type { ColorBalanceOptions } from './passes/ColorBalance.js';
+export type { HueSaturationOptions } from './passes/HueSaturation.js';
+export type { BrightnessContrastOptions } from './passes/BrightnessContrast.js';
+export type { GammaOptions } from './passes/Gamma.js';
+export type { ExposureOptions } from './passes/Exposure.js';
+export type { MixOptions } from './passes/Mix.js';
+export type { PixelateOptions } from './passes/Pixelate.js';
+export type { SharpenOptions } from './passes/Sharpen.js';
+export type { AlphaOverOptions } from './passes/AlphaOver.js';
+export type { SetAlphaOptions } from './passes/SetAlpha.js';
+export type { ZCombineOptions } from './passes/ZCombine.js';
+export type { SeparateRGBAOptions, RGBAChannel } from './passes/SeparateRGBA.js';
+export type { CombineRGBAOptions } from './passes/CombineRGBA.js';
+export type { SSAOOptions } from './passes/SSAO.js';
+export type { SSROptions } from './passes/SSR.js';
+export { RenderLayers } from './passes/RenderLayers.js';
+export { GaussianBlur } from './passes/GaussianBlur.js';
+export { GlareStreaks } from './passes/GlareStreaks.js';
+export { MotionBlur } from './passes/MotionBlur.js';
+export type { RenderLayersOptions } from './passes/RenderLayers.js';
+export type { GaussianBlurOptions } from './passes/GaussianBlur.js';
+export type { GlareStreaksOptions } from './passes/GlareStreaks.js';
+export type { MotionBlurOptions } from './passes/MotionBlur.js';
+export { LensFlare } from './passes/LensFlare.js';
+export { EdgeDetect } from './passes/EdgeDetect.js';
+export type { LensFlareOptions } from './passes/LensFlare.js';
+export type { EdgeDetectOptions } from './passes/EdgeDetect.js';
+export { LUT } from './passes/LUT.js';
+export type { LUTOptions } from './passes/LUT.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,32 @@
+// ── Core ──────────────────────────────────────────────────────────────────────
+export { BasePass } from './core/BasePass.js';
+export { CompositorOutput } from './core/CompositorOutput.js';
+// ── Pass nodes ────────────────────────────────────────────────────────────────
+export { Bloom } from './passes/Bloom.js';
+export { DepthOfField } from './passes/DepthOfField.js';
+export { Blur } from './passes/Blur.js';
+export { ChromaticAberration } from './passes/ChromaticAberration.js';
+export { Vignette } from './passes/Vignette.js';
+export { FilmGrain } from './passes/FilmGrain.js';
+export { ColorBalance } from './passes/ColorBalance.js';
+export { HueSaturation } from './passes/HueSaturation.js';
+export { BrightnessContrast } from './passes/BrightnessContrast.js';
+export { Gamma } from './passes/Gamma.js';
+export { Exposure } from './passes/Exposure.js';
+export { Mix } from './passes/Mix.js';
+export { Pixelate } from './passes/Pixelate.js';
+export { Sharpen } from './passes/Sharpen.js';
+export { AlphaOver } from './passes/AlphaOver.js';
+export { SetAlpha } from './passes/SetAlpha.js';
+export { ZCombine } from './passes/ZCombine.js';
+export { SeparateRGBA } from './passes/SeparateRGBA.js';
+export { CombineRGBA } from './passes/CombineRGBA.js';
+export { SSAO } from './passes/SSAO.js';
+export { SSR } from './passes/SSR.js';
+export { RenderLayers } from './passes/RenderLayers.js';
+export { GaussianBlur } from './passes/GaussianBlur.js';
+export { GlareStreaks } from './passes/GlareStreaks.js';
+export { MotionBlur } from './passes/MotionBlur.js';
+export { LensFlare } from './passes/LensFlare.js';
+export { EdgeDetect } from './passes/EdgeDetect.js';
+export { LUT } from './passes/LUT.js';

package/dist/passes/AlphaOver.d.ts

@@ -0,0 +1,32 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface AlphaOverOptions {
+    /** Background colour as hex string. Default '#000000'. Blender: Alpha Over → Background */
+    background?: string;
+    /** Blend premultiplied alpha. Default false. Blender: Alpha Over → Convert Premul */
+    premul?: boolean;
+    /** Overall mix factor [0–1]. Default 1.0. */
+    fac?: number;
+}
+/**
+ * AlphaOver — Blender Compositor: Alpha Over node.
+ *
+ * Composites the current render over a solid background colour using
+ * the render's alpha channel (standard over operation).
+ * A = current render (foreground), B = background colour.
+ * Result = A.rgb * A.a + B.rgb * (1 - A.a)
+ */
+export declare class AlphaOver extends BasePass {
+    readonly passType = "AlphaOver";
+    parameters: {
+        fac: number;
+        bgR: number;
+        bgG: number;
+        bgB: number;
+        premul: number;
+    };
+    constructor(opts?: AlphaOverOptions);
+    _threePassDeps(): string[];
+    _buildThree(_w: number, _h: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=AlphaOver.d.ts.map

package/dist/passes/AlphaOver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlphaOver.d.ts","sourceRoot":"","sources":["../../src/passes/AlphaOver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,2FAA2F;IAC3F,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAWD;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,QAAQ;IACrC,QAAQ,CAAC,QAAQ,eAAc;IAC/B,UAAU,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;gBAEtE,IAAI,GAAE,gBAAqB;IAUvC,cAAc;IAEd,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CA4BhE"}

package/dist/passes/AlphaOver.js

@@ -0,0 +1,59 @@
+import { BasePass } from '../core/BasePass.js';
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return [
+        parseInt(h.substring(0, 2), 16) / 255,
+        parseInt(h.substring(2, 4), 16) / 255,
+        parseInt(h.substring(4, 6), 16) / 255,
+    ];
+}
+/**
+ * AlphaOver — Blender Compositor: Alpha Over node.
+ *
+ * Composites the current render over a solid background colour using
+ * the render's alpha channel (standard over operation).
+ * A = current render (foreground), B = background colour.
+ * Result = A.rgb * A.a + B.rgb * (1 - A.a)
+ */
+export class AlphaOver extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'AlphaOver';
+        const [bgR, bgG, bgB] = hexToRgb(opts.background ?? '#000000');
+        this.parameters = {
+            fac: opts.fac ?? 1.0,
+            bgR, bgG, bgB,
+            premul: opts.premul ? 1 : 0,
+        };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_w, _h, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('AlphaOver: ShaderPass not found.');
+        const { fac, bgR, bgG, bgB, premul } = this.parameters;
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                fac: { value: fac },
+                bgColor: { value: [bgR, bgG, bgB] },
+                premul: { value: premul },
+            },
+            vertexShader: `varying vec2 vUv; void main(){ vUv=uv; gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0); }`,
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform float fac;
+        uniform vec3 bgColor;
+        uniform float premul;
+        varying vec2 vUv;
+        void main(){
+          vec4 fg = texture2D(tDiffuse, vUv);
+          vec3 fgRgb = premul > 0.5 ? fg.rgb : fg.rgb * fg.a;
+          vec3 result = mix(bgColor, fgRgb + bgColor*(1.0-fg.a), fac);
+          gl_FragColor = vec4(result, 1.0);
+        }
+      `,
+        };
+        return new ShaderPass(shader);
+    }
+}

package/dist/passes/Bloom.d.ts

@@ -0,0 +1,25 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface BloomOptions {
+    /** Luminance threshold — pixels below this are not bloomed. Default 0.8. Blender: Glare → Threshold */
+    threshold?: number;
+    /** Bloom intensity. Default 1.5. Blender: Glare → Strength */
+    strength?: number;
+    /** Bloom spread radius [0–1]. Default 0.4. Blender: Glare → Size */
+    radius?: number;
+}
+/** Bloom — Blender Compositor: Glare node (Bloom type) */
+export declare class Bloom extends BasePass {
+    readonly passType = "Bloom";
+    parameters: {
+        threshold: number;
+        strength: number;
+        radius: number;
+    };
+    constructor(opts?: BloomOptions);
+    _threePassDeps(): string[];
+    _buildThree(width: number, height: number, reg: PassRegistry): unknown;
+    _buildPmndrs(reg: PassRegistry): unknown;
+    get _isPmndrsEffect(): boolean;
+}
+//# sourceMappingURL=Bloom.d.ts.map

package/dist/passes/Bloom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bloom.d.ts","sourceRoot":"","sources":["../../src/passes/Bloom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,YAAY;IAC3B,uGAAuG;IACvG,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,0DAA0D;AAC1D,qBAAa,KAAM,SAAQ,QAAQ;IACjC,QAAQ,CAAC,QAAQ,WAAU;IAC3B,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;gBAEvD,IAAI,GAAE,YAAiB;IASnC,cAAc;IAEd,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;IAW7D,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO;IAUjD,IAAa,eAAe,IAAI,OAAO,CAAgB;CACxD"}

package/dist/passes/Bloom.js

@@ -0,0 +1,32 @@
+import { Vector2 } from 'three';
+import { BasePass } from '../core/BasePass.js';
+/** Bloom — Blender Compositor: Glare node (Bloom type) */
+export class Bloom extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'Bloom';
+        this.parameters = {
+            threshold: opts.threshold ?? 0.8,
+            strength: opts.strength ?? 1.5,
+            radius: opts.radius ?? 0.4,
+        };
+    }
+    _threePassDeps() { return ['UnrealBloomPass']; }
+    _buildThree(width, height, reg) {
+        const Pass = reg['UnrealBloomPass'];
+        if (!Pass)
+            throw new Error('Bloom: UnrealBloomPass not found in three/addons.');
+        return new Pass(new Vector2(width, height), this.parameters.strength, this.parameters.radius, this.parameters.threshold);
+    }
+    _buildPmndrs(reg) {
+        const Effect = reg['BloomEffect'];
+        if (!Effect)
+            throw new Error('Bloom: BloomEffect not found in postprocessing.');
+        return new Effect({
+            intensity: this.parameters.strength,
+            luminanceThreshold: this.parameters.threshold,
+            radius: this.parameters.radius,
+        });
+    }
+    get _isPmndrsEffect() { return true; }
+}