@triforge/compositor-core 0.1.0

package/dist/passes/LUT.js

@@ -0,0 +1,140 @@
+import { BasePass } from '../core/BasePass.js';
+/**
+ * LUT — 3-D Look-Up Table colour grading pass.
+ * Blender Compositor: Color Balance node (via a baked LUT).
+ *
+ * Usage:
+ * ```typescript
+ * const lut = new LUT({ intensity: 1 })
+ * comp.add(lut)
+ * await comp.compile()
+ *
+ * // Apply a custom grade — warm highlights + cool shadows
+ * lut.setLUT(LUT.createFromFn(32, (r, g, b) => [
+ *   r * 1.1 + b * 0.05,
+ *   g,
+ *   b * 1.1 + r * 0.02,
+ * ]))
+ * ```
+ *
+ * The LUT texture is a Data3DTexture (Three.js r137+).
+ * Use `LUT.createNeutral(N)` for a passthrough LUT, then modify the data.
+ * Use `LUT.createFromFn(N, fn)` to build from a mapping function.
+ */
+export class LUT extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'LUT';
+        /** The Three.js Data3DTexture (or null until setLUT() is called). */
+        this.lutTexture = null;
+        this._pass = null;
+        this.parameters = {
+            intensity: opts.intensity ?? 1,
+            lutSize: opts.lutSize ?? 32,
+        };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_w, _h, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('LUT: ShaderPass not found.');
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                lut3d: { value: this.lutTexture ?? null },
+                intensity: { value: this.parameters.intensity },
+                lutSize: { value: this.parameters.lutSize },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+      `,
+            fragmentShader: `
+        precision highp float;
+        precision highp sampler3D;
+        uniform sampler2D tDiffuse;
+        uniform sampler3D lut3d;
+        uniform float     intensity;
+        uniform float     lutSize;
+        varying vec2 vUv;
+
+        void main() {
+          vec4 base = texture2D(tDiffuse, vUv);
+          if (intensity < 0.001 || lutSize < 2.0) { gl_FragColor = base; return; }
+          // Scale to [0.5/N, 1-0.5/N] to hit texel centres
+          float scale  = (lutSize - 1.0) / lutSize;
+          float offset = 0.5 / lutSize;
+          vec3  coord  = clamp(base.rgb, 0.0, 1.0) * scale + offset;
+          vec4  graded = texture(lut3d, coord);
+          gl_FragColor = vec4(mix(base.rgb, graded.rgb, intensity), base.a);
+        }
+      `,
+        };
+        this._pass = new ShaderPass(shader);
+        return this._pass;
+    }
+    /**
+     * Replace the active LUT texture at runtime.
+     * Pass a Three.js Data3DTexture — see `LUT.createNeutral` / `LUT.createFromFn`.
+     */
+    setLUT(tex) {
+        this.lutTexture = tex;
+        if (this._pass) {
+            const uniforms = this._pass['uniforms'];
+            if (uniforms?.['lut3d'])
+                uniforms['lut3d'].value = tex;
+        }
+    }
+    // ── Static helpers ────────────────────────────────────────────────────────
+    /**
+     * Create a neutral (identity) N³ LUT Data3DTexture.
+     * Requires a Three.js instance — pass in the THREE namespace.
+     */
+    static createNeutral(THREE, N = 32) {
+        const data = new Uint8Array(N * N * N * 4);
+        for (let b = 0; b < N; b++) {
+            for (let g = 0; g < N; g++) {
+                for (let r = 0; r < N; r++) {
+                    const i = (b * N * N + g * N + r) * 4;
+                    data[i] = Math.round(r / (N - 1) * 255);
+                    data[i + 1] = Math.round(g / (N - 1) * 255);
+                    data[i + 2] = Math.round(b / (N - 1) * 255);
+                    data[i + 3] = 255;
+                }
+            }
+        }
+        return LUT._makeData3DTexture(THREE, data, N);
+    }
+    /**
+     * Create a Data3DTexture from a mapping function `(r,g,b) => [r,g,b]`
+     * where all channels are in [0, 1].
+     */
+    static createFromFn(THREE, N, fn) {
+        const data = new Uint8Array(N * N * N * 4);
+        for (let b = 0; b < N; b++) {
+            for (let g = 0; g < N; g++) {
+                for (let r = 0; r < N; r++) {
+                    const [or, og, ob] = fn(r / (N - 1), g / (N - 1), b / (N - 1));
+                    const i = (b * N * N + g * N + r) * 4;
+                    data[i] = Math.round(Math.max(0, Math.min(1, or)) * 255);
+                    data[i + 1] = Math.round(Math.max(0, Math.min(1, og)) * 255);
+                    data[i + 2] = Math.round(Math.max(0, Math.min(1, ob)) * 255);
+                    data[i + 3] = 255;
+                }
+            }
+        }
+        return LUT._makeData3DTexture(THREE, data, N);
+    }
+    static _makeData3DTexture(THREE, data, N) {
+        const Cls = THREE['Data3DTexture'];
+        if (!Cls)
+            throw new Error('LUT: THREE.Data3DTexture not available (requires Three.js r137+).');
+        const tex = new Cls(data, N, N, N);
+        const texObj = tex;
+        texObj['minFilter'] = 1006; // LinearFilter
+        texObj['magFilter'] = 1006;
+        texObj['unpackAlignment'] = 1;
+        texObj['needsUpdate'] = true;
+        return tex;
+    }
+}

package/dist/passes/LensFlare.d.ts

@@ -0,0 +1,34 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface LensFlareOptions {
+    /** Number of flare ghosts. Default 6. */
+    ghosts?: number;
+    /** Overall flare intensity. Default 0.5. */
+    strength?: number;
+    /** Luminance threshold — only bright pixels generate flares. Default 0.9. */
+    threshold?: number;
+    /** Halo size as fraction of screen width. Default 0.4. */
+    haloWidth?: number;
+    /** Chromatic dispersion amount for ghost colouring [0–1]. Default 0.5. */
+    chromatic?: number;
+}
+/**
+ * LensFlare — Blender Compositor: Lens Flare / Glare node (lens reflections type).
+ *
+ * Simulates camera lens flare: bright highlight ghosts reflected along the
+ * screen diagonal and a halo ring around bright sources.
+ */
+export declare class LensFlare extends BasePass {
+    readonly passType = "LensFlare";
+    parameters: {
+        ghosts: number;
+        strength: number;
+        threshold: number;
+        haloWidth: number;
+        chromatic: number;
+    };
+    constructor(opts?: LensFlareOptions);
+    _threePassDeps(): string[];
+    _buildThree(_w: number, _h: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=LensFlare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LensFlare.d.ts","sourceRoot":"","sources":["../../src/passes/LensFlare.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,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;GAKG;AACH,qBAAa,SAAU,SAAQ,QAAQ;IACrC,QAAQ,CAAC,QAAQ,eAAc;IAC/B,UAAU,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;gBAE7F,IAAI,GAAE,gBAAqB;IAWvC,cAAc;IAEd,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CAyEhE"}

package/dist/passes/LensFlare.js

@@ -0,0 +1,92 @@
+import { BasePass } from '../core/BasePass.js';
+/**
+ * LensFlare — Blender Compositor: Lens Flare / Glare node (lens reflections type).
+ *
+ * Simulates camera lens flare: bright highlight ghosts reflected along the
+ * screen diagonal and a halo ring around bright sources.
+ */
+export class LensFlare extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'LensFlare';
+        this.parameters = {
+            ghosts: opts.ghosts ?? 6,
+            strength: opts.strength ?? 0.5,
+            threshold: opts.threshold ?? 0.9,
+            haloWidth: opts.haloWidth ?? 0.4,
+            chromatic: opts.chromatic ?? 0.5,
+        };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_w, _h, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('LensFlare: ShaderPass not found.');
+        const { ghosts, strength, threshold, haloWidth, chromatic } = this.parameters;
+        const n = Math.max(1, Math.round(ghosts));
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                strength: { value: strength },
+                threshold: { value: threshold },
+                haloWidth: { value: haloWidth },
+                chromatic: { value: chromatic },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+      `,
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform float strength;
+        uniform float threshold;
+        uniform float haloWidth;
+        uniform float chromatic;
+        varying vec2 vUv;
+
+        float luminance(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
+
+        vec3 sampleChromatic(vec2 uv, vec2 offset) {
+          vec2 r = clamp(uv + offset * (1.0 + chromatic * 0.1), 0.0, 1.0);
+          vec2 b = clamp(uv + offset * (1.0 - chromatic * 0.1), 0.0, 1.0);
+          return vec3(
+            texture2D(tDiffuse, r).r,
+            texture2D(tDiffuse, clamp(uv + offset, 0.0, 1.0)).g,
+            texture2D(tDiffuse, b).b
+          );
+        }
+
+        void main() {
+          vec4 base = texture2D(tDiffuse, vUv);
+          vec3 flare = vec3(0.0);
+          vec2 ghost = vec2(0.5) - vUv;  // vector to screen centre
+
+          // Ghost reflections along the screen diagonal
+          for (int i = 1; i <= ${n}; i++) {
+            float fi    = float(i);
+            float disp  = 0.3 + fi * 0.25;
+            vec2  guv   = vUv + ghost * disp;
+            vec3  samp  = sampleChromatic(guv, ghost * 0.01 * fi);
+            float lum   = luminance(samp);
+            if (lum > threshold) {
+              vec3 tint = mix(vec3(1.0, 0.8, 0.6), vec3(0.6, 0.8, 1.0), fract(fi * 0.37));
+              flare += samp * tint * (lum - threshold) * strength / fi;
+            }
+          }
+
+          // Halo ring
+          float dist    = length(ghost);
+          float haloBias = abs(dist - haloWidth);
+          float halo    = smoothstep(0.05, 0.0, haloBias) * strength * 0.5;
+          vec4  haloCentre = texture2D(tDiffuse, clamp(vec2(0.5) + normalize(-ghost) * haloWidth, 0.0, 1.0));
+          if (luminance(haloCentre.rgb) > threshold) {
+            flare += haloCentre.rgb * halo;
+          }
+
+          gl_FragColor = vec4(base.rgb + flare, base.a);
+        }
+      `,
+        };
+        return new ShaderPass(shader);
+    }
+}

package/dist/passes/Mix.d.ts

@@ -0,0 +1,23 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface MixOptions {
+    /** Blend factor [0–1]. 0 = pass A only, 1 = pass B only. Default 0.5. Blender: Mix → Fac */
+    fac?: number;
+}
+/**
+ * Mix — Blender Compositor: Mix node.
+ *
+ * Blends the current compositor output with a saved texture snapshot.
+ * In practice this wraps a simple alpha-blend shader over the render target.
+ * For full A/B compositing, use two separate CompositorOutput chains.
+ */
+export declare class Mix extends BasePass {
+    readonly passType = "Mix";
+    parameters: {
+        fac: number;
+    };
+    constructor(opts?: MixOptions);
+    _threePassDeps(): string[];
+    _buildThree(_width: number, _height: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=Mix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mix.d.ts","sourceRoot":"","sources":["../../src/passes/Mix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,UAAU;IACzB,4FAA4F;IAC5F,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED;;;;;;GAMG;AACH,qBAAa,GAAI,SAAQ,QAAQ;IAC/B,QAAQ,CAAC,QAAQ,SAAQ;IACzB,UAAU,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;gBAEf,IAAI,GAAE,UAAe;IAKjC,cAAc;IAEd,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CAyBzE"}

package/dist/passes/Mix.js

@@ -0,0 +1,41 @@
+import { BasePass } from '../core/BasePass.js';
+/**
+ * Mix — Blender Compositor: Mix node.
+ *
+ * Blends the current compositor output with a saved texture snapshot.
+ * In practice this wraps a simple alpha-blend shader over the render target.
+ * For full A/B compositing, use two separate CompositorOutput chains.
+ */
+export class Mix extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'Mix';
+        this.parameters = { fac: opts.fac ?? 0.5 };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_width, _height, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('Mix: ShaderPass not found in three/addons.');
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                fac: { value: this.parameters.fac },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+      `,
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform float fac;
+        varying vec2 vUv;
+        void main() {
+          vec4 col = texture2D(tDiffuse, vUv);
+          gl_FragColor = vec4(col.rgb, col.a * (1.0 - fac) + fac);
+        }
+      `,
+        };
+        return new ShaderPass(shader);
+    }
+}

package/dist/passes/MotionBlur.d.ts

@@ -0,0 +1,37 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface MotionBlurOptions {
+    /** Number of accumulation samples. Higher = smoother but slower. Default 8. */
+    samples?: number;
+    /**
+     * Velocity scale — how far samples are spread from the velocity vector.
+     * Blender: Vector Blur → Speed. Default 1.0.
+     */
+    velocityScale?: number;
+    /**
+     * Maximum blur radius in pixels. Clamps per-pixel blur length.
+     * Default 20.
+     */
+    maxRadius?: number;
+}
+/**
+ * MotionBlur — screen-space radial/directional motion blur.
+ * Blender Compositor: Vector Blur node.
+ *
+ * Screen-space approximation: samples radially from screen centre,
+ * simulating camera shake / fast-pan motion blur.
+ * For true per-object motion blur, a velocity buffer is required
+ * (beyond single-pass EffectComposer scope — this is a visual approximation).
+ */
+export declare class MotionBlur extends BasePass {
+    readonly passType = "MotionBlur";
+    parameters: {
+        samples: number;
+        velocityScale: number;
+        maxRadius: number;
+    };
+    constructor(opts?: MotionBlurOptions);
+    _threePassDeps(): string[];
+    _buildThree(_w: number, _h: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=MotionBlur.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MotionBlur.d.ts","sourceRoot":"","sources":["../../src/passes/MotionBlur.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC,QAAQ,CAAC,QAAQ,gBAAe;IAChC,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;gBAE7D,IAAI,GAAE,iBAAsB;IASxC,cAAc;IAEd,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CA6ChE"}

package/dist/passes/MotionBlur.js

@@ -0,0 +1,65 @@
+import { BasePass } from '../core/BasePass.js';
+/**
+ * MotionBlur — screen-space radial/directional motion blur.
+ * Blender Compositor: Vector Blur node.
+ *
+ * Screen-space approximation: samples radially from screen centre,
+ * simulating camera shake / fast-pan motion blur.
+ * For true per-object motion blur, a velocity buffer is required
+ * (beyond single-pass EffectComposer scope — this is a visual approximation).
+ */
+export class MotionBlur extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'MotionBlur';
+        this.parameters = {
+            samples: opts.samples ?? 8,
+            velocityScale: opts.velocityScale ?? 1.0,
+            maxRadius: opts.maxRadius ?? 20,
+        };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_w, _h, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('MotionBlur: ShaderPass not found.');
+        const { samples, velocityScale, maxRadius } = this.parameters;
+        const n = Math.max(1, Math.round(samples));
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                resolution: { value: [1920, 1080] },
+                velocityScale: { value: velocityScale },
+                maxRadius: { value: maxRadius },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+      `,
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform vec2 resolution;
+        uniform float velocityScale;
+        uniform float maxRadius;
+        varying vec2 vUv;
+
+        void main() {
+          // Screen-space radial blur toward centre
+          vec2 centre = vec2(0.5);
+          vec2 vel    = (centre - vUv) * velocityScale;
+          float len   = length(vel * resolution);
+          if (len > maxRadius) vel = vel * (maxRadius / max(len, 0.001));
+
+          vec4 acc = vec4(0.0);
+          for (int i = 0; i < ${n}; i++) {
+            float t  = float(i) / float(${n - 1});
+            vec2  uv = clamp(vUv + vel * t / resolution, 0.0, 1.0);
+            acc += texture2D(tDiffuse, uv);
+          }
+          gl_FragColor = acc / float(${n});
+        }
+      `,
+        };
+        return new ShaderPass(shader);
+    }
+}

package/dist/passes/Pixelate.d.ts

@@ -0,0 +1,19 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface PixelateOptions {
+    /** Pixel block size in screen pixels. Default 8. Blender: Pixelate node */
+    pixelSize?: number;
+}
+/** Pixelate — Blender Compositor: Pixelate node */
+export declare class Pixelate extends BasePass {
+    readonly passType = "Pixelate";
+    parameters: {
+        pixelSize: number;
+    };
+    constructor(opts?: PixelateOptions);
+    _threePassDeps(): string[];
+    _buildThree(_width: number, _height: number, reg: PassRegistry): unknown;
+    _buildPmndrs(reg: PassRegistry): unknown;
+    get _isPmndrsEffect(): boolean;
+}
+//# sourceMappingURL=Pixelate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Pixelate.d.ts","sourceRoot":"","sources":["../../src/passes/Pixelate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,mDAAmD;AACnD,qBAAa,QAAS,SAAQ,QAAQ;IACpC,QAAQ,CAAC,QAAQ,cAAa;IAC9B,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;gBAErB,IAAI,GAAE,eAAoB;IAKtC,cAAc;IAEd,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;IA6B/D,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO;IAMjD,IAAa,eAAe,IAAI,OAAO,CAAgB;CACxD"}

package/dist/passes/Pixelate.js

@@ -0,0 +1,45 @@
+import { BasePass } from '../core/BasePass.js';
+/** Pixelate — Blender Compositor: Pixelate node */
+export class Pixelate extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'Pixelate';
+        this.parameters = { pixelSize: opts.pixelSize ?? 8 };
+    }
+    _threePassDeps() { return ['ShaderPass']; }
+    _buildThree(_width, _height, reg) {
+        const ShaderPass = reg['ShaderPass'];
+        if (!ShaderPass)
+            throw new Error('Pixelate: ShaderPass not found in three/addons.');
+        const shader = {
+            uniforms: {
+                tDiffuse: { value: null },
+                resolution: { value: [_width, _height] },
+                pixelSize: { value: this.parameters.pixelSize },
+            },
+            vertexShader: `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+      `,
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform vec2 resolution;
+        uniform float pixelSize;
+        varying vec2 vUv;
+        void main() {
+          vec2 dxy = pixelSize / resolution;
+          vec2 uv  = dxy * floor(vUv / dxy);
+          gl_FragColor = texture2D(tDiffuse, uv);
+        }
+      `,
+        };
+        return new ShaderPass(shader);
+    }
+    _buildPmndrs(reg) {
+        const Effect = reg['PixelationEffect'];
+        if (!Effect)
+            throw new Error('Pixelate: PixelationEffect not found in postprocessing.');
+        return new Effect(this.parameters.pixelSize);
+    }
+    get _isPmndrsEffect() { return true; }
+}

package/dist/passes/RenderLayers.d.ts

@@ -0,0 +1,31 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface RenderLayersOptions {
+    /** Three.js layer mask to render. Default 0xffffffff (all layers). */
+    layerMask?: number;
+}
+/**
+ * RenderLayers — render a specific Three.js layer mask into the buffer.
+ * Blender Compositor: Render Layers node.
+ *
+ * Replaces the default RenderPass with one that temporarily sets
+ * camera.layers to the given mask, then restores it.
+ *
+ * Usage:
+ *   // Render only layer 1
+ *   comp.add(new RenderLayers({ layerMask: 2 }))
+ *
+ * Note: because EffectComposer always prepends its own RenderPass,
+ * this pass renders an additional layer-filtered pass on top.
+ * For full control, set layerMask = 0xffffffff to render all layers.
+ */
+export declare class RenderLayers extends BasePass {
+    readonly passType = "RenderLayers";
+    parameters: {
+        layerMask: number;
+    };
+    constructor(opts?: RenderLayersOptions);
+    _threePassDeps(): string[];
+    _buildThree(_width: number, _height: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=RenderLayers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderLayers.d.ts","sourceRoot":"","sources":["../../src/passes/RenderLayers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,QAAQ,CAAC,QAAQ,kBAAiB;IAClC,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;gBAErB,IAAI,GAAE,mBAAwB;IAK1C,cAAc;IAEd,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CA8BzE"}

package/dist/passes/RenderLayers.js

@@ -0,0 +1,45 @@
+import { BasePass } from '../core/BasePass.js';
+/**
+ * RenderLayers — render a specific Three.js layer mask into the buffer.
+ * Blender Compositor: Render Layers node.
+ *
+ * Replaces the default RenderPass with one that temporarily sets
+ * camera.layers to the given mask, then restores it.
+ *
+ * Usage:
+ *   // Render only layer 1
+ *   comp.add(new RenderLayers({ layerMask: 2 }))
+ *
+ * Note: because EffectComposer always prepends its own RenderPass,
+ * this pass renders an additional layer-filtered pass on top.
+ * For full control, set layerMask = 0xffffffff to render all layers.
+ */
+export class RenderLayers extends BasePass {
+    constructor(opts = {}) {
+        super();
+        this.passType = 'RenderLayers';
+        this.parameters = { layerMask: opts.layerMask ?? 0xffffffff };
+    }
+    _threePassDeps() { return ['RenderPass']; }
+    _buildThree(_width, _height, reg) {
+        const RenderPass = reg['RenderPass'];
+        if (!RenderPass)
+            throw new Error('RenderLayers: RenderPass not found in three/addons.');
+        const scene = reg['_scene'];
+        const camera = reg['_camera'];
+        if (!scene || !camera)
+            throw new Error('RenderLayers: scene/camera not injected into registry.');
+        const mask = this.parameters.layerMask;
+        // Build a custom RenderPass wrapper that applies the layer mask
+        const pass = new RenderPass(scene, camera);
+        const origRender = pass['render'];
+        pass['render'] = function (renderer, writeBuffer, readBuffer, ...rest) {
+            const layers = camera['layers'];
+            const savedMask = layers.mask;
+            layers.mask = mask;
+            origRender.call(this, renderer, writeBuffer, readBuffer, ...rest);
+            layers.mask = savedMask;
+        };
+        return pass;
+    }
+}

package/dist/passes/SSAO.d.ts

@@ -0,0 +1,34 @@
+import { BasePass } from '../core/BasePass.js';
+import type { PassRegistry } from '../core/BasePass.js';
+export interface SSAOOptions {
+    /** AO sample radius in world units. Default 0.5. Blender: Ambient Occlusion → Distance */
+    radius?: number;
+    /** Minimum depth difference to generate occlusion. Default 0.005. */
+    minDistance?: number;
+    /** Maximum depth difference to generate occlusion. Default 0.1. */
+    maxDistance?: number;
+}
+/**
+ * SSAO — Screen Space Ambient Occlusion.
+ * Blender Compositor: Ambient Occlusion pass.
+ *
+ * Wraps Three.js SSAOPass from three/addons.
+ * Requires scene and camera — injected automatically by CompositorOutput.
+ *
+ * Post-compile injection needed:
+ * ```typescript
+ * comp.compile(renderer, scene, camera)
+ * ```
+ */
+export declare class SSAO extends BasePass {
+    readonly passType = "SSAO";
+    parameters: {
+        radius: number;
+        minDistance: number;
+        maxDistance: number;
+    };
+    constructor(opts?: SSAOOptions);
+    _threePassDeps(): string[];
+    _buildThree(width: number, height: number, reg: PassRegistry): unknown;
+}
+//# sourceMappingURL=SSAO.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SSAO.d.ts","sourceRoot":"","sources":["../../src/passes/SSAO.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,WAAW;IAC1B,0FAA0F;IAC1F,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,IAAK,SAAQ,QAAQ;IAChC,QAAQ,CAAC,QAAQ,UAAS;IAC1B,UAAU,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;gBAE5D,IAAI,GAAE,WAAgB;IASlC,cAAc;IAEd,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CAcvE"}