@treasuryspatial/viewer-kit 0.2.31

package/dist/systems/environmentSystem.js

@@ -0,0 +1,277 @@
+import * as THREE from "three";
+import { HDRLoader } from "three/examples/jsm/loaders/HDRLoader.js";
+export class EnvironmentSystem {
+    scene;
+    renderer;
+    assetResolver;
+    pmremGenerator = null;
+    currentObjects = [];
+    currentBackground = null;
+    currentEnvironment = null;
+    objectUrls = [];
+    loadToken = 0;
+    state = { mode: "none", backgroundEnabled: false, lightingEnabled: false };
+    fallbackGradient = {
+        topColor: "#f8fafc",
+        horizonColor: "#e2e8f0",
+        sunPosition: [0.3, 0.8, 0.4],
+        sunIntensity: 0.12,
+        sunSize: 0.06,
+    };
+    constructor(scene, renderer, assetResolver) {
+        this.scene = scene;
+        this.renderer = renderer;
+        this.assetResolver = assetResolver;
+    }
+    getState() {
+        return { ...this.state };
+    }
+    async apply(preset) {
+        const sky = preset.sky;
+        this.disposeCurrent();
+        if (!sky || sky.mode === "none") {
+            this.scene.background = null;
+            this.scene.environment = null;
+            this.state = { mode: "none", backgroundEnabled: false, lightingEnabled: false };
+            return;
+        }
+        if (sky.mode === "gradient") {
+            this.applyGradientSky(sky.gradient);
+            this.state = { mode: "gradient", backgroundEnabled: true, lightingEnabled: false };
+            return;
+        }
+        if (sky.mode === "hdr") {
+            try {
+                await this.applyHdrSky(sky.hdr);
+            }
+            catch (error) {
+                console.warn("[viewer-kit] HDR sky failed, falling back to gradient.", error);
+                this.applyGradientSky(this.fallbackGradient);
+                this.state = { mode: "gradient", backgroundEnabled: true, lightingEnabled: false };
+            }
+            return;
+        }
+        if (sky.mode === "cube") {
+            try {
+                await this.applyCubeSky(sky.cube);
+            }
+            catch (error) {
+                console.warn("[viewer-kit] Cube sky failed, falling back to gradient.", error);
+                this.applyGradientSky(this.fallbackGradient);
+                this.state = { mode: "gradient", backgroundEnabled: true, lightingEnabled: false };
+            }
+        }
+    }
+    dispose() {
+        this.disposeCurrent();
+        if (this.pmremGenerator) {
+            this.pmremGenerator.dispose();
+            this.pmremGenerator = null;
+        }
+    }
+    disposeCurrent() {
+        this.currentObjects.forEach((obj) => {
+            if (obj.parent)
+                obj.parent.remove(obj);
+            if (obj instanceof THREE.Mesh) {
+                obj.geometry.dispose();
+                const material = obj.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material.dispose?.();
+                }
+            }
+        });
+        this.currentObjects = [];
+        if (this.scene.background === this.currentBackground) {
+            this.scene.background = null;
+        }
+        if (this.scene.environment === this.currentEnvironment) {
+            this.scene.environment = null;
+        }
+        const anyScene = this.scene;
+        if (anyScene.backgroundRotation?.set)
+            anyScene.backgroundRotation.set(0, 0, 0);
+        if (anyScene.environmentRotation?.set)
+            anyScene.environmentRotation.set(0, 0, 0);
+        if (this.currentBackground)
+            this.currentBackground.dispose();
+        if (this.currentEnvironment && this.currentEnvironment !== this.currentBackground) {
+            this.currentEnvironment.dispose();
+        }
+        this.currentBackground = null;
+        this.currentEnvironment = null;
+        this.objectUrls.forEach((url) => URL.revokeObjectURL(url));
+        this.objectUrls = [];
+    }
+    applyGradientSky(gradient) {
+        const skyGeometry = new THREE.SphereGeometry(300, 64, 64);
+        const skyMaterial = new THREE.ShaderMaterial({
+            uniforms: {
+                topColor: { value: new THREE.Color(gradient.topColor) },
+                horizonColor: { value: new THREE.Color(gradient.horizonColor) },
+                sunPosition: { value: new THREE.Vector3(...gradient.sunPosition) },
+                sunIntensity: { value: gradient.sunIntensity },
+                sunSize: { value: gradient.sunSize },
+            },
+            vertexShader: `
+        varying vec3 vPosition;
+        void main() {
+          vPosition = position;
+          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+        }
+      `,
+            fragmentShader: `
+        uniform vec3 topColor;
+        uniform vec3 horizonColor;
+        uniform vec3 sunPosition;
+        uniform float sunIntensity;
+        uniform float sunSize;
+        varying vec3 vPosition;
+        void main() {
+          vec3 direction = normalize(vPosition);
+          float h = direction.y;
+          float gradientFactor = smoothstep(-0.1, 0.4, h);
+          vec3 color = mix(horizonColor, topColor, gradientFactor);
+          vec3 sunDir = normalize(sunPosition);
+          float sunDist = distance(direction, sunDir);
+          float sun = smoothstep(sunSize, 0.0, sunDist) * sunIntensity;
+          color = mix(color, topColor, sun);
+          gl_FragColor = vec4(color, 1.0);
+        }
+      `,
+            side: THREE.BackSide,
+            depthWrite: false,
+        });
+        const sky = new THREE.Mesh(skyGeometry, skyMaterial);
+        sky.renderOrder = -1;
+        this.scene.add(sky);
+        this.currentObjects.push(sky);
+    }
+    async resolveAsset(src, kind) {
+        if (!this.assetResolver)
+            return src;
+        const { url, headers } = await this.assetResolver(src, kind);
+        if (!headers || Object.keys(headers).length === 0)
+            return url;
+        const response = await fetch(url, { headers });
+        if (!response.ok)
+            throw new Error(`Asset fetch failed: ${response.status}`);
+        const blob = await response.blob();
+        const objectUrl = URL.createObjectURL(blob);
+        this.objectUrls.push(objectUrl);
+        return objectUrl;
+    }
+    async applyHdrSky(hdr) {
+        const token = ++this.loadToken;
+        const backgroundEnabled = hdr.showBackground !== false;
+        const lightingEnabled = hdr.showLighting !== false;
+        const usePmrem = hdr.usePmrem ?? false;
+        const resolved = await this.resolveAsset(hdr.src, "hdr");
+        if (token !== this.loadToken)
+            return;
+        const loader = new HDRLoader();
+        const texture = await loader.loadAsync(resolved);
+        if (token !== this.loadToken) {
+            texture.dispose();
+            return;
+        }
+        texture.mapping = THREE.EquirectangularReflectionMapping;
+        texture.colorSpace = THREE.LinearSRGBColorSpace;
+        texture.magFilter = THREE.LinearFilter;
+        texture.minFilter = THREE.LinearFilter;
+        texture.needsUpdate = true;
+        texture.center = new THREE.Vector2(0.5, 0.5);
+        if (typeof hdr.rotationY === "number") {
+            texture.rotation = hdr.rotationY;
+        }
+        this.applyRotationToScene(hdr.rotation, hdr.rotationY);
+        let environmentTexture = null;
+        if (lightingEnabled) {
+            if (usePmrem) {
+                if (!this.pmremGenerator) {
+                    this.pmremGenerator = new THREE.PMREMGenerator(this.renderer);
+                    this.pmremGenerator.compileEquirectangularShader();
+                }
+                environmentTexture = this.pmremGenerator.fromEquirectangular(texture).texture;
+            }
+            else {
+                environmentTexture = texture;
+            }
+        }
+        if (backgroundEnabled) {
+            this.scene.background = texture;
+            this.currentBackground = texture;
+        }
+        if (environmentTexture) {
+            this.scene.environment = environmentTexture;
+            this.currentEnvironment = environmentTexture;
+            if (environmentTexture !== texture) {
+                this.currentEnvironment = environmentTexture;
+            }
+        }
+        this.state = { mode: "hdr", backgroundEnabled, lightingEnabled };
+    }
+    async applyCubeSky(cube) {
+        const token = ++this.loadToken;
+        const backgroundEnabled = cube.showBackground !== false;
+        const lightingEnabled = cube.showLighting !== false;
+        const usePmrem = cube.usePmrem ?? false;
+        const faces = await Promise.all([
+            this.resolveAsset(cube.px, "cubeface"),
+            this.resolveAsset(cube.nx, "cubeface"),
+            this.resolveAsset(cube.py, "cubeface"),
+            this.resolveAsset(cube.ny, "cubeface"),
+            this.resolveAsset(cube.pz, "cubeface"),
+            this.resolveAsset(cube.nz, "cubeface"),
+        ]);
+        if (token !== this.loadToken)
+            return;
+        const loader = new THREE.CubeTextureLoader();
+        const texture = await loader.loadAsync(faces);
+        if (token !== this.loadToken) {
+            texture.dispose();
+            return;
+        }
+        texture.colorSpace = THREE.SRGBColorSpace;
+        texture.magFilter = THREE.LinearFilter;
+        texture.minFilter = THREE.LinearFilter;
+        texture.needsUpdate = true;
+        this.applyRotationToScene(cube.rotation, cube.rotationY);
+        let environmentTexture = null;
+        if (lightingEnabled) {
+            if (usePmrem) {
+                if (!this.pmremGenerator) {
+                    this.pmremGenerator = new THREE.PMREMGenerator(this.renderer);
+                }
+                environmentTexture = this.pmremGenerator.fromCubemap(texture).texture;
+            }
+            else {
+                environmentTexture = texture;
+            }
+        }
+        if (backgroundEnabled) {
+            this.scene.background = texture;
+            this.currentBackground = texture;
+        }
+        if (environmentTexture) {
+            this.scene.environment = environmentTexture;
+            this.currentEnvironment = environmentTexture;
+        }
+        this.state = { mode: "cube", backgroundEnabled, lightingEnabled };
+    }
+    applyRotationToScene(rotation, rotationY) {
+        const yaw = rotation?.yaw ?? rotationY ?? 0;
+        const pitch = rotation?.pitch ?? 0;
+        const roll = rotation?.roll ?? 0;
+        const anyScene = this.scene;
+        if (anyScene.backgroundRotation?.set) {
+            anyScene.backgroundRotation.set(pitch, yaw, roll);
+        }
+        if (anyScene.environmentRotation?.set) {
+            anyScene.environmentRotation.set(pitch, yaw, roll);
+        }
+    }
+}

package/dist/systems/lightingSystem.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+import type { RenderPresetDefinition } from "../engine/types";
+export declare class LightingSystem {
+    private scene;
+    private lights;
+    private targets;
+    constructor(scene: THREE.Scene);
+    apply(preset: RenderPresetDefinition): void;
+    dispose(): void;
+    private add;
+    private addTarget;
+    private clear;
+    private configureShadow;
+}
+//# sourceMappingURL=lightingSystem.d.ts.map

package/dist/systems/lightingSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightingSystem.d.ts","sourceRoot":"","sources":["../../src/systems/lightingSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAqB,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAUjF,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,OAAO,CAAwB;gBAE3B,KAAK,EAAE,KAAK,CAAC,KAAK;IAI9B,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAuD3C,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,GAAG;IAKX,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,eAAe;CAcxB"}

package/dist/systems/lightingSystem.js

@@ -0,0 +1,100 @@
+import * as THREE from "three";
+const DEFAULT_LIGHTING = {
+    rig: "studio",
+    ambient: { color: "#ffffff", intensity: 0.8 },
+    hemisphere: { skyColor: "#ffffff", groundColor: "#f4f4f4", intensity: 1.0 },
+    key: { color: "#ffffff", intensity: 1.4, position: [10, 15, 5], castShadow: true },
+    fill: { color: "#ffffff", intensity: 0.5, position: [-10, 10, -5] },
+};
+export class LightingSystem {
+    scene;
+    lights = [];
+    targets = [];
+    constructor(scene) {
+        this.scene = scene;
+    }
+    apply(preset) {
+        this.clear();
+        const config = preset.lighting ?? DEFAULT_LIGHTING;
+        const lightTarget = preset.sceneExtras?.lightTarget ?? [0, 1.5, 0];
+        if (config.rig === "none")
+            return;
+        const ambient = config.ambient ?? DEFAULT_LIGHTING.ambient;
+        if (ambient && ambient.intensity > 0) {
+            const light = new THREE.AmbientLight(new THREE.Color(ambient.color), ambient.intensity);
+            this.add(light);
+        }
+        const hemi = config.hemisphere ?? DEFAULT_LIGHTING.hemisphere;
+        if (hemi && hemi.intensity > 0) {
+            const light = new THREE.HemisphereLight(new THREE.Color(hemi.skyColor), new THREE.Color(hemi.groundColor), hemi.intensity);
+            this.add(light);
+        }
+        const key = config.key ?? DEFAULT_LIGHTING.key;
+        if (key && key.intensity > 0) {
+            const light = new THREE.DirectionalLight(new THREE.Color(key.color), key.intensity);
+            light.position.set(...key.position);
+            light.castShadow = key.castShadow ?? false;
+            if (light.castShadow) {
+                this.configureShadow(light, config.shadow);
+            }
+            light.target.position.set(lightTarget[0], lightTarget[1], lightTarget[2]);
+            this.addTarget(light.target);
+            this.add(light);
+        }
+        const fill = config.fill ?? DEFAULT_LIGHTING.fill;
+        if (fill && fill.intensity > 0) {
+            const light = new THREE.DirectionalLight(new THREE.Color(fill.color), fill.intensity);
+            light.position.set(...fill.position);
+            light.target.position.set(lightTarget[0], lightTarget[1], lightTarget[2]);
+            this.addTarget(light.target);
+            this.add(light);
+        }
+        if (preset.interiorLights?.length) {
+            preset.interiorLights.forEach((interior) => {
+                const color = interior.color ? new THREE.Color(interior.color) : new THREE.Color("#ffffff");
+                const distance = typeof interior.distance === "number" ? interior.distance : 40;
+                const point = new THREE.PointLight(color, interior.intensity, distance);
+                point.position.set(...interior.position);
+                this.add(point);
+            });
+        }
+    }
+    dispose() {
+        this.clear();
+    }
+    add(light) {
+        this.scene.add(light);
+        this.lights.push(light);
+    }
+    addTarget(target) {
+        this.scene.add(target);
+        this.targets.push(target);
+    }
+    clear() {
+        this.lights.forEach((light) => {
+            if (light.parent)
+                light.parent.remove(light);
+        });
+        this.lights = [];
+        this.targets.forEach((target) => {
+            if (target.parent)
+                target.parent.remove(target);
+        });
+        this.targets = [];
+    }
+    configureShadow(light, config) {
+        if (!light.shadow)
+            return;
+        const cameraSize = config?.cameraSize ?? 25;
+        light.shadow.camera.left = -cameraSize;
+        light.shadow.camera.right = cameraSize;
+        light.shadow.camera.top = cameraSize;
+        light.shadow.camera.bottom = -cameraSize;
+        light.shadow.camera.near = config?.near ?? 0.1;
+        light.shadow.camera.far = config?.far ?? 60;
+        const mapSize = config?.mapSize ?? 2048;
+        light.shadow.mapSize.set(mapSize, mapSize);
+        light.shadow.bias = config?.bias ?? -0.0001;
+        light.shadow.radius = config?.radius ?? 3;
+    }
+}

package/dist/systems/postfxSystem.d.ts

@@ -0,0 +1,31 @@
+import * as THREE from "three";
+import type { PostFxConfig } from "../engine/types";
+export declare class PostFxSystem {
+    private renderer;
+    private scene;
+    private camera;
+    private composer;
+    private renderPass;
+    private aoPass;
+    private effectPass;
+    private bloomEffect;
+    private vignetteEffect;
+    private enabled;
+    private lastWidth;
+    private lastHeight;
+    private pendingConfig;
+    private currentConfig;
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.PerspectiveCamera);
+    apply(config?: PostFxConfig): void;
+    render(): void;
+    resize(width: number, height: number): void;
+    private getDrawingBufferSize;
+    dispose(): void;
+    invalidate(): void;
+    getState(): {
+        aoEnabled: boolean;
+        bloomEnabled: boolean;
+        vignetteEnabled: boolean;
+    };
+}
+//# sourceMappingURL=postfxSystem.d.ts.map

package/dist/systems/postfxSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postfxSystem.d.ts","sourceRoot":"","sources":["../../src/systems/postfxSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,aAAa,CAA6B;gBAEtC,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,iBAAiB;IAM9F,KAAK,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI;IAiHlC,MAAM,IAAI,IAAI;IAoBd,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAwB3C,OAAO,CAAC,oBAAoB;IAS5B,OAAO,IAAI,IAAI;IAaf,UAAU,IAAI,IAAI;IAqBlB,QAAQ,IAAI;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,OAAO,CAAC;QAAC,eAAe,EAAE,OAAO,CAAA;KAAE;CAOpF"}

package/dist/systems/postfxSystem.js

@@ -0,0 +1,220 @@
+import * as THREE from "three";
+import { BloomEffect, EffectComposer, EffectPass, RenderPass, VignetteEffect } from "postprocessing";
+import { N8AOPostPass } from "n8ao";
+export class PostFxSystem {
+    renderer;
+    scene;
+    camera;
+    composer = null;
+    renderPass = null;
+    aoPass = null;
+    effectPass = null;
+    bloomEffect = null;
+    vignetteEffect = null;
+    enabled = false;
+    lastWidth = 0;
+    lastHeight = 0;
+    pendingConfig = null;
+    currentConfig = null;
+    constructor(renderer, scene, camera) {
+        this.renderer = renderer;
+        this.scene = scene;
+        this.camera = camera;
+    }
+    apply(config) {
+        const ao = config?.ao;
+        const bloom = config?.bloom;
+        const vignette = config?.vignette;
+        const shouldEnable = Boolean(ao?.enabled || bloom?.enabled || vignette?.enabled);
+        this.currentConfig = config ?? null;
+        if (!shouldEnable) {
+            this.enabled = false;
+            this.pendingConfig = null;
+            if (this.aoPass)
+                this.aoPass.enabled = false;
+            if (this.effectPass)
+                this.effectPass.enabled = false;
+            return;
+        }
+        this.pendingConfig = config ?? null;
+        if (this.lastWidth < 2 || this.lastHeight < 2) {
+            this.enabled = false;
+            return;
+        }
+        if (!this.composer) {
+            this.composer = new EffectComposer(this.renderer);
+            this.renderPass = new RenderPass(this.scene, this.camera);
+            this.renderPass.clearPass && (this.renderPass.clearPass.overrideClearAlpha = 1);
+            this.composer.addPass(this.renderPass);
+            this.composer.setSize(this.lastWidth, this.lastHeight);
+        }
+        this.composer.autoRenderToScreen = false;
+        if (!this.aoPass) {
+            const buffer = this.getDrawingBufferSize();
+            this.aoPass = new N8AOPostPass(this.scene, this.camera, buffer.width, buffer.height);
+            this.composer.addPass(this.aoPass);
+        }
+        else {
+            const buffer = this.getDrawingBufferSize();
+            this.aoPass.setSize(buffer.width, buffer.height);
+        }
+        if (!this.bloomEffect) {
+            this.bloomEffect = new BloomEffect({
+                intensity: bloom?.intensity ?? 0.0,
+                radius: bloom?.radius ?? 0.85,
+                luminanceThreshold: bloom?.threshold ?? 1.0,
+                luminanceSmoothing: bloom?.smoothing ?? 0.03,
+            });
+        }
+        if (!this.vignetteEffect) {
+            this.vignetteEffect = new VignetteEffect({
+                offset: vignette?.offset ?? 0.5,
+                darkness: vignette?.darkness ?? 0.5,
+            });
+        }
+        const enableEffectPass = Boolean(bloom?.enabled || vignette?.enabled);
+        if (enableEffectPass && !this.effectPass) {
+            this.effectPass = new EffectPass(this.camera, this.bloomEffect, this.vignetteEffect);
+            this.composer.addPass(this.effectPass);
+        }
+        this.enabled = true;
+        this.pendingConfig = null;
+        if (this.aoPass) {
+            this.aoPass.enabled = Boolean(ao?.enabled);
+            if (ao?.intensity !== undefined)
+                this.aoPass.configuration.intensity = ao.intensity;
+            if (ao?.radius !== undefined)
+                this.aoPass.configuration.aoRadius = ao.radius;
+            if (ao?.distanceFalloff !== undefined)
+                this.aoPass.configuration.distanceFalloff = ao.distanceFalloff;
+            if (ao?.halfRes !== undefined)
+                this.aoPass.configuration.halfRes = ao.halfRes;
+            const quality = (ao?.quality ?? "high").toLowerCase();
+            const qualityMode = quality === "low" ? "Low" : quality === "medium" ? "Medium" : "High";
+            this.aoPass.setQualityMode(qualityMode);
+            if (ao?.color) {
+                this.aoPass.configuration.color = new THREE.Color(ao.color);
+            }
+            this.aoPass.firstFrame?.();
+        }
+        if (this.bloomEffect) {
+            this.bloomEffect.intensity = bloom?.enabled ? bloom?.intensity ?? 1.0 : 0.0;
+            if (bloom?.radius !== undefined) {
+                this.bloomEffect.mipmapBlurPass.radius = bloom.radius;
+            }
+            if (bloom?.threshold !== undefined)
+                this.bloomEffect.luminanceMaterial.threshold = bloom.threshold;
+            if (bloom?.smoothing !== undefined)
+                this.bloomEffect.luminanceMaterial.smoothing = bloom.smoothing;
+        }
+        if (this.vignetteEffect) {
+            const offset = vignette?.offset ?? 0.5;
+            const darkness = vignette?.enabled ? vignette.darkness ?? 0.5 : 0.0;
+            this.vignetteEffect.offset = offset;
+            this.vignetteEffect.darkness = darkness;
+        }
+        if (this.effectPass) {
+            this.effectPass.enabled = enableEffectPass;
+        }
+        // Ensure the last enabled pass renders to screen.
+        const passes = [this.renderPass, this.aoPass, this.effectPass].filter(Boolean);
+        passes.forEach((pass) => {
+            pass.renderToScreen = false;
+        });
+        const enabledPasses = passes.filter((pass) => pass.enabled);
+        const lastPass = enabledPasses[enabledPasses.length - 1];
+        if (lastPass) {
+            lastPass.renderToScreen = true;
+        }
+        this.invalidate();
+    }
+    render() {
+        if (this.enabled && this.composer) {
+            // EffectComposer disables autoClear; force a clean frame on the default framebuffer.
+            this.renderer.setRenderTarget(null);
+            this.renderer.clear(true, true, true);
+            if (this.aoPass) {
+                const aoPassAny = this.aoPass;
+                if (aoPassAny.accumulationRenderTarget) {
+                    const prevTarget = this.renderer.getRenderTarget();
+                    this.renderer.setRenderTarget(aoPassAny.accumulationRenderTarget);
+                    this.renderer.clear(true, true, true);
+                    this.renderer.setRenderTarget(prevTarget);
+                }
+            }
+            this.composer.render();
+            return;
+        }
+        this.renderer.render(this.scene, this.camera);
+    }
+    resize(width, height) {
+        this.lastWidth = width;
+        this.lastHeight = height;
+        if (this.composer) {
+            // Full rebuild to avoid stale postprocessing buffers after resize.
+            this.composer.dispose();
+            this.composer = null;
+            this.renderPass = null;
+            this.aoPass = null;
+            this.effectPass = null;
+            this.enabled = false;
+        }
+        if (this.currentConfig) {
+            const config = this.currentConfig;
+            this.currentConfig = null;
+            this.apply(config);
+        }
+        if (this.pendingConfig) {
+            const pending = this.pendingConfig;
+            this.pendingConfig = null;
+            this.apply(pending);
+        }
+    }
+    getDrawingBufferSize() {
+        const size = new THREE.Vector2();
+        this.renderer.getDrawingBufferSize(size);
+        return {
+            width: Math.max(1, Math.round(size.x)),
+            height: Math.max(1, Math.round(size.y)),
+        };
+    }
+    dispose() {
+        if (this.composer) {
+            this.composer.dispose();
+        }
+        this.renderPass = null;
+        this.aoPass = null;
+        this.effectPass = null;
+        this.bloomEffect = null;
+        this.vignetteEffect = null;
+        this.composer = null;
+        this.enabled = false;
+    }
+    invalidate() {
+        if (this.aoPass) {
+            this.aoPass.firstFrame?.();
+            const aoPassAny = this.aoPass;
+            if (aoPassAny.accumulationRenderTarget) {
+                const prevTarget = this.renderer.getRenderTarget();
+                this.renderer.setRenderTarget(aoPassAny.accumulationRenderTarget);
+                this.renderer.clear(true, true, true);
+                this.renderer.setRenderTarget(prevTarget);
+            }
+        }
+        if (this.composer) {
+            const prevTarget = this.renderer.getRenderTarget();
+            this.renderer.setRenderTarget(this.composer.inputBuffer);
+            this.renderer.clear(true, true, true);
+            this.renderer.setRenderTarget(this.composer.outputBuffer);
+            this.renderer.clear(true, true, true);
+            this.renderer.setRenderTarget(prevTarget);
+        }
+    }
+    getState() {
+        return {
+            aoEnabled: Boolean(this.aoPass?.enabled),
+            bloomEnabled: Boolean(this.effectPass?.enabled && this.bloomEffect && this.bloomEffect.intensity > 0),
+            vignetteEnabled: Boolean(this.effectPass?.enabled && this.vignetteEffect && this.vignetteEffect.darkness > 0),
+        };
+    }
+}

package/dist/systems/rendererSystem.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from "three";
+import type { RendererConfig } from "../engine/types";
+export declare function applyRendererConfig(renderer: THREE.WebGLRenderer, config?: RendererConfig): void;
+//# sourceMappingURL=rendererSystem.d.ts.map

package/dist/systems/rendererSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendererSystem.d.ts","sourceRoot":"","sources":["../../src/systems/rendererSystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAmB,MAAM,iBAAiB,CAAC;AAsBvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAuBhG"}