@triforge/compositor-core 0.1.0 → 0.1.2

package/dist/core/CompositorOutput.d.ts

@@ -67,7 +67,6 @@ export declare class CompositorOutput {
     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

@@ -1 +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"}
+{"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;AAUd,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;IAQf,OAAO,CAAC,aAAa;YA+CP,cAAc;CAiD7B"}

package/dist/core/CompositorOutput.js

@@ -1,4 +1,13 @@
 import { Vector2, WebGLRenderTarget, LinearFilter, RGBAFormat, HalfFloatType, } from 'three';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
+import { FilmPass } from 'three/examples/jsm/postprocessing/FilmPass.js';
+import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
+import { SSAOPass } from 'three/examples/jsm/postprocessing/SSAOPass.js';
+import { SSRPass } from 'three/examples/jsm/postprocessing/SSRPass.js';
 /**
  * CompositorOutput — terminal node of the compositor graph.
  *
@@ -60,7 +69,7 @@ export class CompositorOutput {
             this._composer = await this._compilePmndrs();
         }
         else {
-            this._composer = await this._compileThree();
+            this._composer = this._compileThree();
         }
         this._compiled = true;
     }
@@ -88,31 +97,18 @@ export class CompositorOutput {
         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/"');
-        }
+    _compileThree() {
         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);
+        // Registry built from static imports — compatible with Vite, Webpack, Rollup, esbuild
+        const registry = {
+            ShaderPass,
+            UnrealBloomPass,
+            FilmPass,
+            BokehPass,
+            SSAOPass,
+            SSRPass,
+            RenderPass,
+        };
         const size = new Vector2();
         this._renderer.getSize(size);
         const target = new WebGLRenderTarget(size.x, size.y, {
@@ -121,47 +117,27 @@ export class CompositorOutput {
             format: RGBAFormat,
             type: HalfFloatType,
         });
-        const composer = new EC(this._renderer, target);
+        const composer = new EffectComposer(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
+        // 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');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            pkg = await Function('m', 'return import(m)')('postprocessing');
         }
         catch {
             throw new Error('@st-compositor-core: backend "pmndrs" requires the "postprocessing" package.\n' +

package/dist/core/glslLoopBound.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compile-time GLSL loop-bound sanitizer.
+ *
+ * Several passes bake a JS number directly into a GLSL `for` loop bound, e.g.
+ * `for (int i = 0; i < ${n}; i++)`. Per the root ecosystem rule ("ALWAYS cap
+ * GLSL loop iterations to a compile-time constant"), that number must be a
+ * finite integer within a sane range before it reaches the shader source:
+ *
+ *  - `NaN`/`Infinity` would produce a shader that fails to compile.
+ *  - An absurdly large value (e.g. a mistyped `samples: 1e6`) would compile a
+ *    loop that hangs the GPU.
+ *
+ * This clamps to [min, max] and rounds to an integer, so the emitted bound is
+ * always a small compile-time constant.
+ */
+export declare function glslLoopBound(value: number, min: number, max: number): number;
+//# sourceMappingURL=glslLoopBound.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glslLoopBound.d.ts","sourceRoot":"","sources":["../../src/core/glslLoopBound.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7E"}

package/dist/core/glslLoopBound.js

@@ -0,0 +1,25 @@
+/**
+ * Compile-time GLSL loop-bound sanitizer.
+ *
+ * Several passes bake a JS number directly into a GLSL `for` loop bound, e.g.
+ * `for (int i = 0; i < ${n}; i++)`. Per the root ecosystem rule ("ALWAYS cap
+ * GLSL loop iterations to a compile-time constant"), that number must be a
+ * finite integer within a sane range before it reaches the shader source:
+ *
+ *  - `NaN`/`Infinity` would produce a shader that fails to compile.
+ *  - An absurdly large value (e.g. a mistyped `samples: 1e6`) would compile a
+ *    loop that hangs the GPU.
+ *
+ * This clamps to [min, max] and rounds to an integer, so the emitted bound is
+ * always a small compile-time constant.
+ */
+export function glslLoopBound(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    const rounded = Math.round(value);
+    if (rounded < min)
+        return min;
+    if (rounded > max)
+        return max;
+    return rounded;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"GlareStreaks.d.ts","sourceRoot":"","sources":["../../src/passes/GlareStreaks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD,MAAM,WAAW,mBAAmB;IAClC,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,QAAQ,CAAC,QAAQ,kBAAiB;IAClC,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;gBAErG,IAAI,GAAE,mBAAwB;IAY1C,cAAc;IAEd,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CA8DhE"}
+{"version":3,"file":"GlareStreaks.d.ts","sourceRoot":"","sources":["../../src/passes/GlareStreaks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAGvD,MAAM,WAAW,mBAAmB;IAClC,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,QAAQ,CAAC,QAAQ,kBAAiB;IAClC,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;gBAErG,IAAI,GAAE,mBAAwB;IAY1C,cAAc;IAEd,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO;CAmEhE"}

package/dist/passes/GlareStreaks.js

@@ -1,4 +1,5 @@
 import { BasePass } from '../core/BasePass.js';
+import { glslLoopBound } from '../core/glslLoopBound.js';
 /**
  * GlareStreaks — anamorphic lens streak effect on bright areas.
  * Blender Compositor: Glare node (Streaks type).
@@ -24,7 +25,12 @@ export class GlareStreaks extends BasePass {
         const ShaderPass = reg['ShaderPass'];
         if (!ShaderPass)
             throw new Error('GlareStreaks: ShaderPass not found.');
-        const { threshold, strength, streaks, length, angle, fade } = this.parameters;
+        const { threshold, strength, length, angle, fade } = this.parameters;
+        // Cap both baked loop bounds: streak count (1..16) and per-streak sample
+        // length (1..128) — both are interpolated into generated GLSL / unrolled
+        // JS below, so both must be finite compile-time-bounded integers.
+        const streaks = glslLoopBound(this.parameters.streaks, 1, 16);
+        const sampleLength = glslLoopBound(length, 1, 128);
         // Build direction vectors for each streak
         const dirs = [];
         for (let i = 0; i < streaks; i++) {
@@ -40,41 +46,41 @@ export class GlareStreaks extends BasePass {
                 fade: { value: fade },
                 length: { value: length },
             },
-            vertexShader: `
-        varying vec2 vUv;
-        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+            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 threshold;
-        uniform float strength;
-        uniform float fade;
-        uniform float length;
-        varying vec2 vUv;
-
-        float luminance(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
-
-        vec4 sampleStreak(vec2 dir) {
-          vec4 acc  = vec4(0.0);
-          float att = 1.0;
-          vec2 step = dir / resolution;
-          for (int i = 1; i <= ${Math.max(1, Math.round(length))}; i++) {
-            vec2 uv   = vUv + step * float(i) * strength;
-            vec4 samp = texture2D(tDiffuse, clamp(uv, 0.0, 1.0));
-            float lum = luminance(samp.rgb);
-            if (lum > threshold) acc += samp * att;
-            att *= fade;
-          }
-          return acc;
-        }
-
-        void main() {
-          vec4 base = texture2D(tDiffuse, vUv);
-          vec4 glare = vec4(0.0);
-          ${dirs.map(d => `glare += sampleStreak(${d});`).join('\n          ')}
-          gl_FragColor = base + glare * (1.0 / ${Math.max(1, streaks)}.0);
-        }
+            fragmentShader: `
+        uniform sampler2D tDiffuse;
+        uniform vec2 resolution;
+        uniform float threshold;
+        uniform float strength;
+        uniform float fade;
+        uniform float length;
+        varying vec2 vUv;
+
+        float luminance(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }
+
+        vec4 sampleStreak(vec2 dir) {
+          vec4 acc  = vec4(0.0);
+          float att = 1.0;
+          vec2 step = dir / resolution;
+          for (int i = 1; i <= ${sampleLength}; i++) {
+            vec2 uv   = vUv + step * float(i) * strength;
+            vec4 samp = texture2D(tDiffuse, clamp(uv, 0.0, 1.0));
+            float lum = luminance(samp.rgb);
+            if (lum > threshold) acc += samp * att;
+            att *= fade;
+          }
+          return acc;
+        }
+
+        void main() {
+          vec4 base = texture2D(tDiffuse, vUv);
+          vec4 glare = vec4(0.0);
+          ${dirs.map(d => `glare += sampleStreak(${d});`).join('\n          ')}
+          gl_FragColor = base + glare * (1.0 / ${Math.max(1, streaks)}.0);
+        }
       `,
         };
         return new ShaderPass(shader);

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

@@ -1 +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"}
+{"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;AAGvD,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;CA0EhE"}

package/dist/passes/LensFlare.js

@@ -1,4 +1,5 @@
 import { BasePass } from '../core/BasePass.js';
+import { glslLoopBound } from '../core/glslLoopBound.js';
 /**
  * LensFlare — Blender Compositor: Lens Flare / Glare node (lens reflections type).
  *
@@ -23,7 +24,8 @@ export class LensFlare extends BasePass {
         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));
+        // Cap the baked loop bound: finite, integer, 1..32 ghost reflections.
+        const n = glslLoopBound(ghosts, 1, 32);
         const shader = {
             uniforms: {
                 tDiffuse: { value: null },
@@ -32,59 +34,59 @@ export class LensFlare extends BasePass {
                 haloWidth: { value: haloWidth },
                 chromatic: { value: chromatic },
             },
-            vertexShader: `
-        varying vec2 vUv;
-        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+            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);
-        }
+            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/MotionBlur.d.ts.map

@@ -1 +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"}
+{"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;AAGvD,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;CA+ChE"}

package/dist/passes/MotionBlur.js

@@ -1,4 +1,5 @@
 import { BasePass } from '../core/BasePass.js';
+import { glslLoopBound } from '../core/glslLoopBound.js';
 /**
  * MotionBlur — screen-space radial/directional motion blur.
  * Blender Compositor: Vector Blur node.
@@ -24,7 +25,9 @@ export class MotionBlur extends BasePass {
         if (!ShaderPass)
             throw new Error('MotionBlur: ShaderPass not found.');
         const { samples, velocityScale, maxRadius } = this.parameters;
-        const n = Math.max(1, Math.round(samples));
+        // Cap the baked loop bound: finite, integer, 1..64 (matches typical
+        // real-time motion-blur sample budgets; guards against NaN / huge values).
+        const n = glslLoopBound(samples, 1, 64);
         const shader = {
             uniforms: {
                 tDiffuse: { value: null },
@@ -32,32 +35,32 @@ export class MotionBlur extends BasePass {
                 velocityScale: { value: velocityScale },
                 maxRadius: { value: maxRadius },
             },
-            vertexShader: `
-        varying vec2 vUv;
-        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+            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});
-        }
+            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/package.json

@@ -1,48 +1,54 @@
-{
-  "name": "@triforge/compositor-core",
-  "version": "0.1.0",
-  "description": "Blender-matched compositor node graph for Three.js — backend-agnostic (three/addons or pmndrs/postprocessing)",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "node test/run-tests.js"
-  },
-  "keywords": [
-    "three.js",
-    "post-processing",
-    "compositor",
-    "blender",
-    "effects"
-  ],
-  "author": "Aftab Ibrahim Kazi",
-  "license": "MIT",
-  "peerDependencies": {
-    "three": ">=0.128.0"
-  },
-  "peerDependenciesMeta": {
-    "postprocessing": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@types/three": "^0.156.0",
-    "three": "^0.156.0",
-    "typescript": "^5.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/AftabIbrahimKazi/triforge.git",
-    "directory": "st-compositor-core"
-  },
-  "homepage": "https://github.com/AftabIbrahimKazi/triforge#readme",
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@triforge/compositor-core",
+  "version": "0.1.2",
+  "description": "Blender-matched compositor node graph for Three.js — backend-agnostic (three/addons or pmndrs/postprocessing)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node test/run-tests.js"
+  },
+  "keywords": [
+    "three.js",
+    "post-processing",
+    "compositor",
+    "blender",
+    "effects"
+  ],
+  "author": "Aftab Ibrahim Kazi",
+  "license": "MIT",
+  "peerDependencies": {
+    "three": ">=0.128.0"
+  },
+  "peerDependenciesMeta": {
+    "postprocessing": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/three": "^0.156.0",
+    "three": "^0.156.0",
+    "typescript": "^5.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AftabIbrahimKazi/triforge.git",
+    "directory": "st-compositor-core"
+  },
+  "homepage": "https://github.com/AftabIbrahimKazi/triforge#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  }
+}