angular-three-soba 1.14.0 → 2.0.0-beta.10

package/esm2022/staging/accumulative-shadows/accumulative-shadows.mjs

@@ -0,0 +1,267 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, forwardRef, Input, untracked, } from '@angular/core';
+import { createInjectionToken, extend, getLocalState, injectBeforeRender, injectNgtRef, injectNgtStore, signalStore, } from 'angular-three';
+import { SoftShadowMaterial } from 'angular-three-soba/shaders';
+import { Group, Mesh, PlaneGeometry } from 'three';
+import { ProgressiveLightMap } from './progressive-light-map';
+import * as i0 from "@angular/core";
+extend({ Group, SoftShadowMaterial, Mesh, PlaneGeometry });
+export const [injectNgtsAccumulativeShadowsApi, provideNgtsAccumulativeShadowsApi] = createInjectionToken((shadows) => shadows.api, { isRoot: false, deps: [forwardRef(() => NgtsAccumulativeShadows)] });
+export class NgtsAccumulativeShadows {
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    set _frames(frames) {
+        this.inputs.set({ frames });
+    }
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    set _blend(blend) {
+        this.inputs.set({ blend });
+    }
+    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */
+    set _limit(limit) {
+        this.inputs.set({ limit });
+    }
+    /** Scale of the plane,  */
+    set _scale(scale) {
+        this.inputs.set({ scale });
+    }
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    set _temporal(temporal) {
+        this.inputs.set({ temporal });
+    }
+    /** Opacity of the plane, 1 */
+    set _opacity(opacity) {
+        this.inputs.set({ opacity });
+    }
+    /** Discards alpha pixels, 0.65 */
+    set _alphaTest(alphaTest) {
+        this.inputs.set({ alphaTest });
+    }
+    /** Shadow color, black */
+    set _color(color) {
+        this.inputs.set({ color });
+    }
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    set _colorBlend(colorBlend) {
+        this.inputs.set({ colorBlend });
+    }
+    /** Buffer resolution, 1024 */
+    set _resolution(resolution) {
+        this.inputs.set({ resolution });
+    }
+    /** Texture tonemapping */
+    set _toneMapped(toneMapped) {
+        this.inputs.set({ toneMapped });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            frames: 40,
+            limit: Infinity,
+            blend: 20,
+            scale: 10,
+            opacity: 1,
+            alphaTest: 0.75,
+            color: 'black',
+            colorBlend: 2,
+            resolution: 1024,
+            toneMapped: true,
+            temporal: false,
+        });
+        this.nullTraverse = () => null;
+        this.Math = Math;
+        this.accumulativeShadowsRef = injectNgtRef();
+        this.meshRef = injectNgtRef();
+        this.store = injectNgtStore();
+        this.gl = this.store.select('gl');
+        this.scene = this.store.select('scene');
+        this.camera = this.store.select('camera');
+        this.invalidate = this.store.select('invalidate');
+        this.resolution = this.inputs.select('resolution');
+        this.alphaTest = this.inputs.select('alphaTest');
+        this.opacity = this.inputs.select('opacity');
+        this.temporal = this.inputs.select('temporal');
+        this.blend = this.inputs.select('blend');
+        this.frames = this.inputs.select('frames');
+        this.pLM = computed(() => new ProgressiveLightMap(untracked(this.gl), untracked(this.scene), this.resolution()));
+        this.scale = this.inputs.select('scale');
+        this.toneMapped = this.inputs.select('toneMapped');
+        this.color = this.inputs.select('color');
+        this.colorBlend = this.inputs.select('colorBlend');
+        this.map = computed(() => this.pLM().progressiveLightMap2.texture);
+        this.api = computed(() => {
+            const [pLM, alphaTest, opacity, camera, temporal, blend, frames] = [
+                this.pLM(),
+                this.alphaTest(),
+                this.opacity(),
+                this.camera(),
+                this.temporal(),
+                this.blend(),
+                this.frames(),
+            ];
+            const api = {
+                lights: new Map(),
+                temporal,
+                frames: Math.max(2, frames),
+                blend: Math.max(2, frames === Infinity ? blend : frames),
+                count: 0,
+                getMesh: () => this.meshRef.nativeElement,
+                reset: () => {
+                    if (!this.meshRef.nativeElement)
+                        return;
+                    // Clear buffers, reset opacities, set frame count to 0
+                    pLM.clear();
+                    const material = this.meshRef.nativeElement.material;
+                    material.opacity = 0;
+                    material.alphaTest = 0;
+                    api.count = 0;
+                },
+                update: (frames = 1) => {
+                    if (!this.meshRef.nativeElement)
+                        return;
+                    // Adapt the opacity-blend ratio to the number of frames
+                    const material = this.meshRef.nativeElement.material;
+                    if (!api.temporal) {
+                        material.opacity = opacity;
+                        material.alphaTest = alphaTest;
+                    }
+                    else {
+                        material.opacity = Math.min(opacity, material.opacity + opacity / api.blend);
+                        material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / api.blend);
+                    }
+                    // Switch accumulative lights on
+                    this.accumulativeShadowsRef.nativeElement.visible = true;
+                    // Collect scene lights and meshes
+                    pLM.prepare();
+                    // Update the lightmap and the accumulative lights
+                    for (let i = 0; i < frames; i++) {
+                        api.lights.forEach((light) => light().update());
+                        pLM.update(camera, api.blend);
+                    }
+                    // Switch lights off
+                    this.accumulativeShadowsRef.nativeElement.visible = false;
+                    // Restore lights and meshes
+                    pLM.finish();
+                },
+            };
+            return api;
+        });
+        this.configure();
+        this.resetAndUpdate();
+        this.beforeRender();
+    }
+    configure() {
+        effect(() => {
+            const [pLM, mesh] = [this.pLM(), this.meshRef.nativeElement];
+            if (!mesh)
+                return;
+            pLM.configure(mesh);
+        });
+    }
+    resetAndUpdate() {
+        effect(() => {
+            const [, , mesh] = [
+                this.inputs.state(),
+                getLocalState(untracked(this.scene)).objects(),
+                this.meshRef.nativeElement,
+            ];
+            if (!mesh)
+                return;
+            const api = untracked(this.api);
+            // Reset internals, buffers, ...
+            api.reset();
+            // Update lightmap
+            if (!api.temporal && api.frames !== Infinity)
+                api.update(api.blend);
+        });
+    }
+    beforeRender() {
+        injectBeforeRender(() => {
+            const [api, limit] = [this.api(), this.inputs.get('limit')];
+            if ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {
+                this.invalidate();
+                api.update();
+                api.count++;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAccumulativeShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: NgtsAccumulativeShadows, isStandalone: true, selector: "ngts-accumulative-shadows", inputs: { accumulativeShadowsRef: "accumulativeShadowsRef", _frames: ["frames", "_frames"], _blend: ["blend", "_blend"], _limit: ["limit", "_limit"], _scale: ["scale", "_scale"], _temporal: ["temporal", "_temporal"], _opacity: ["opacity", "_opacity"], _alphaTest: ["alphaTest", "_alphaTest"], _color: ["color", "_color"], _colorBlend: ["colorBlend", "_colorBlend"], _resolution: ["resolution", "_resolution"], _toneMapped: ["toneMapped", "_toneMapped"] }, providers: [provideNgtsAccumulativeShadowsApi()], ngImport: i0, template: `
+		<ngt-group ngtCompound>
+			<ngt-group [traverse]="nullTraverse" [ref]="accumulativeShadowsRef">
+				<ng-content />
+			</ngt-group>
+			<ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]">
+				<ngt-plane-geometry />
+				<ngt-soft-shadow-material
+					[transparent]="true"
+					[depthWrite]="false"
+					[toneMapped]="toneMapped()"
+					[color]="color()"
+					[blend]="colorBlend()"
+					[map]="map()"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: NgtsAccumulativeShadows, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-accumulative-shadows',
+                    standalone: true,
+                    template: `
+		<ngt-group ngtCompound>
+			<ngt-group [traverse]="nullTraverse" [ref]="accumulativeShadowsRef">
+				<ng-content />
+			</ngt-group>
+			<ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]">
+				<ngt-plane-geometry />
+				<ngt-soft-shadow-material
+					[transparent]="true"
+					[depthWrite]="false"
+					[toneMapped]="toneMapped()"
+					[color]="color()"
+					[blend]="colorBlend()"
+					[map]="map()"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+	`,
+                    providers: [provideNgtsAccumulativeShadowsApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { accumulativeShadowsRef: [{
+                type: Input
+            }], _frames: [{
+                type: Input,
+                args: [{ alias: 'frames' }]
+            }], _blend: [{
+                type: Input,
+                args: [{ alias: 'blend' }]
+            }], _limit: [{
+                type: Input,
+                args: [{ alias: 'limit' }]
+            }], _scale: [{
+                type: Input,
+                args: [{ alias: 'scale' }]
+            }], _temporal: [{
+                type: Input,
+                args: [{ alias: 'temporal' }]
+            }], _opacity: [{
+                type: Input,
+                args: [{ alias: 'opacity' }]
+            }], _alphaTest: [{
+                type: Input,
+                args: [{ alias: 'alphaTest' }]
+            }], _color: [{
+                type: Input,
+                args: [{ alias: 'color' }]
+            }], _colorBlend: [{
+                type: Input,
+                args: [{ alias: 'colorBlend' }]
+            }], _resolution: [{
+                type: Input,
+                args: [{ alias: 'resolution' }]
+            }], _toneMapped: [{
+                type: Input,
+                args: [{ alias: 'toneMapped' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulative-shadows.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/accumulative-shadows/accumulative-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\teffect,\n\tforwardRef,\n\tInput,\n\tSignal,\n\tuntracked,\n} from '@angular/core';\nimport {\n\tcreateInjectionToken,\n\textend,\n\tgetLocalState,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tsignalStore,\n\ttype NgtGroup,\n} from 'angular-three';\nimport { SoftShadowMaterial, type NgtSoftShadowMaterialState } from 'angular-three-soba/shaders';\nimport { Group, Mesh, PlaneGeometry } from 'three';\nimport { ProgressiveLightMap } from './progressive-light-map';\n\nextend({ Group, SoftShadowMaterial, Mesh, PlaneGeometry });\n\nexport type NgtsAccumulativeShadowsState = {\n\t/** How many frames it can render, more yields cleaner results but takes more time, 40 */\n\tframes: number;\n\t/** If frames === Infinity blend controls the refresh ratio, 100 */\n\tblend: number;\n\t/** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */\n\tlimit: number;\n\t/** Scale of the plane,  */\n\tscale: number;\n\t/** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */\n\ttemporal: boolean;\n\t/** Opacity of the plane, 1 */\n\topacity: number;\n\t/** Discards alpha pixels, 0.65 */\n\talphaTest: number;\n\t/** Shadow color, black */\n\tcolor: string;\n\t/** Colorblend, how much colors turn to black, 0 is black, 2 */\n\tcolorBlend: number;\n\t/** Buffer resolution, 1024 */\n\tresolution: number;\n\t/** Texture tonemapping */\n\ttoneMapped: boolean;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends ngt-group\n\t\t */\n\t\t'ngts-accumulative-shadows': NgtsAccumulativeShadowsState & NgtGroup;\n\t}\n}\n\nexport type NgtsAccumulativeShadowsLightApi = { update: () => void };\n\nexport const [injectNgtsAccumulativeShadowsApi, provideNgtsAccumulativeShadowsApi] = createInjectionToken(\n\t(shadows: NgtsAccumulativeShadows) => shadows.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtsAccumulativeShadows)] },\n);\n\n@Component({\n\tselector: 'ngts-accumulative-shadows',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group ngtCompound>\n\t\t\t<ngt-group [traverse]=\"nullTraverse\" [ref]=\"accumulativeShadowsRef\">\n\t\t\t\t<ng-content />\n\t\t\t</ngt-group>\n\t\t\t<ngt-mesh [receiveShadow]=\"true\" [ref]=\"meshRef\" [scale]=\"scale()\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n\t\t\t\t<ngt-plane-geometry />\n\t\t\t\t<ngt-soft-shadow-material\n\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t[depthWrite]=\"false\"\n\t\t\t\t\t[toneMapped]=\"toneMapped()\"\n\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t[blend]=\"colorBlend()\"\n\t\t\t\t\t[map]=\"map()\"\n\t\t\t\t/>\n\t\t\t</ngt-mesh>\n\t\t</ngt-group>\n\t`,\n\tproviders: [provideNgtsAccumulativeShadowsApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsAccumulativeShadows {\n\tprivate inputs = signalStore<NgtsAccumulativeShadowsState>({\n\t\tframes: 40,\n\t\tlimit: Infinity,\n\t\tblend: 20,\n\t\tscale: 10,\n\t\topacity: 1,\n\t\talphaTest: 0.75,\n\t\tcolor: 'black',\n\t\tcolorBlend: 2,\n\t\tresolution: 1024,\n\t\ttoneMapped: true,\n\t\ttemporal: false,\n\t});\n\n\tnullTraverse = () => null;\n\tMath = Math;\n\n\t@Input() accumulativeShadowsRef = injectNgtRef<THREE.Group>();\n\n\t/** How many frames it can render, more yields cleaner results but takes more time, 40 */\n\t@Input({ alias: 'frames' }) set _frames(frames: number) {\n\t\tthis.inputs.set({ frames });\n\t}\n\n\t/** If frames === Infinity blend controls the refresh ratio, 100 */\n\t@Input({ alias: 'blend' }) set _blend(blend: number) {\n\t\tthis.inputs.set({ blend });\n\t}\n\n\t/** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */\n\t@Input({ alias: 'limit' }) set _limit(limit: number) {\n\t\tthis.inputs.set({ limit });\n\t}\n\n\t/** Scale of the plane,  */\n\t@Input({ alias: 'scale' }) set _scale(scale: number) {\n\t\tthis.inputs.set({ scale });\n\t}\n\n\t/** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */\n\t@Input({ alias: 'temporal' }) set _temporal(temporal: boolean) {\n\t\tthis.inputs.set({ temporal });\n\t}\n\n\t/** Opacity of the plane, 1 */\n\t@Input({ alias: 'opacity' }) set _opacity(opacity: number) {\n\t\tthis.inputs.set({ opacity });\n\t}\n\n\t/** Discards alpha pixels, 0.65 */\n\t@Input({ alias: 'alphaTest' }) set _alphaTest(alphaTest: number) {\n\t\tthis.inputs.set({ alphaTest });\n\t}\n\n\t/** Shadow color, black */\n\t@Input({ alias: 'color' }) set _color(color: string) {\n\t\tthis.inputs.set({ color });\n\t}\n\n\t/** Colorblend, how much colors turn to black, 0 is black, 2 */\n\t@Input({ alias: 'colorBlend' }) set _colorBlend(colorBlend: number) {\n\t\tthis.inputs.set({ colorBlend });\n\t}\n\n\t/** Buffer resolution, 1024 */\n\t@Input({ alias: 'resolution' }) set _resolution(resolution: number) {\n\t\tthis.inputs.set({ resolution });\n\t}\n\n\t/** Texture tonemapping */\n\t@Input({ alias: 'toneMapped' }) set _toneMapped(toneMapped: boolean) {\n\t\tthis.inputs.set({ toneMapped });\n\t}\n\n\tmeshRef = injectNgtRef<THREE.Mesh<THREE.PlaneGeometry, NgtSoftShadowMaterialState & THREE.ShaderMaterial>>();\n\n\tprivate store = injectNgtStore();\n\tprivate gl = this.store.select('gl');\n\tprivate scene = this.store.select('scene');\n\tprivate camera = this.store.select('camera');\n\tprivate invalidate = this.store.select('invalidate');\n\n\tprivate resolution = this.inputs.select('resolution');\n\tprivate alphaTest = this.inputs.select('alphaTest');\n\tprivate opacity = this.inputs.select('opacity');\n\tprivate temporal = this.inputs.select('temporal');\n\tprivate blend = this.inputs.select('blend');\n\tprivate frames = this.inputs.select('frames');\n\n\tpLM = computed(() => new ProgressiveLightMap(untracked(this.gl), untracked(this.scene), this.resolution()));\n\n\tscale = this.inputs.select('scale');\n\ttoneMapped = this.inputs.select('toneMapped');\n\tcolor = this.inputs.select('color');\n\tcolorBlend = this.inputs.select('colorBlend');\n\tmap = computed(() => this.pLM().progressiveLightMap2.texture);\n\n\tapi = computed(() => {\n\t\tconst [pLM, alphaTest, opacity, camera, temporal, blend, frames] = [\n\t\t\tthis.pLM(),\n\t\t\tthis.alphaTest(),\n\t\t\tthis.opacity(),\n\t\t\tthis.camera(),\n\t\t\tthis.temporal(),\n\t\t\tthis.blend(),\n\t\t\tthis.frames(),\n\t\t];\n\t\tconst api = {\n\t\t\tlights: new Map<string, Signal<NgtsAccumulativeShadowsLightApi>>(),\n\t\t\ttemporal,\n\t\t\tframes: Math.max(2, frames),\n\t\t\tblend: Math.max(2, frames === Infinity ? blend : frames),\n\t\t\tcount: 0,\n\t\t\tgetMesh: () => this.meshRef.nativeElement,\n\t\t\treset: () => {\n\t\t\t\tif (!this.meshRef.nativeElement) return;\n\t\t\t\t// Clear buffers, reset opacities, set frame count to 0\n\t\t\t\tpLM.clear();\n\t\t\t\tconst material = this.meshRef.nativeElement.material;\n\t\t\t\tmaterial.opacity = 0;\n\t\t\t\tmaterial.alphaTest = 0;\n\t\t\t\tapi.count = 0;\n\t\t\t},\n\t\t\tupdate: (frames = 1) => {\n\t\t\t\tif (!this.meshRef.nativeElement) return;\n\t\t\t\t// Adapt the opacity-blend ratio to the number of frames\n\t\t\t\tconst material = this.meshRef.nativeElement.material;\n\t\t\t\tif (!api.temporal) {\n\t\t\t\t\tmaterial.opacity = opacity;\n\t\t\t\t\tmaterial.alphaTest = alphaTest;\n\t\t\t\t} else {\n\t\t\t\t\tmaterial.opacity = Math.min(opacity, material.opacity + opacity / api.blend);\n\t\t\t\t\tmaterial.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / api.blend);\n\t\t\t\t}\n\n\t\t\t\t// Switch accumulative lights on\n\t\t\t\tthis.accumulativeShadowsRef.nativeElement.visible = true;\n\t\t\t\t// Collect scene lights and meshes\n\t\t\t\tpLM.prepare();\n\n\t\t\t\t// Update the lightmap and the accumulative lights\n\t\t\t\tfor (let i = 0; i < frames; i++) {\n\t\t\t\t\tapi.lights.forEach((light) => light().update());\n\t\t\t\t\tpLM.update(camera, api.blend);\n\t\t\t\t}\n\n\t\t\t\t// Switch lights off\n\t\t\t\tthis.accumulativeShadowsRef.nativeElement.visible = false;\n\t\t\t\t// Restore lights and meshes\n\t\t\t\tpLM.finish();\n\t\t\t},\n\t\t};\n\n\t\treturn api;\n\t});\n\n\tconstructor() {\n\t\tthis.configure();\n\t\tthis.resetAndUpdate();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate configure() {\n\t\teffect(() => {\n\t\t\tconst [pLM, mesh] = [this.pLM(), this.meshRef.nativeElement];\n\t\t\tif (!mesh) return;\n\t\t\tpLM.configure(mesh);\n\t\t});\n\t}\n\n\tprivate resetAndUpdate() {\n\t\teffect(() => {\n\t\t\tconst [, , mesh] = [\n\t\t\t\tthis.inputs.state(),\n\t\t\t\tgetLocalState(untracked(this.scene)).objects(),\n\t\t\t\tthis.meshRef.nativeElement,\n\t\t\t];\n\t\t\tif (!mesh) return;\n\t\t\tconst api = untracked(this.api);\n\t\t\t// Reset internals, buffers, ...\n\t\t\tapi.reset();\n\t\t\t// Update lightmap\n\t\t\tif (!api.temporal && api.frames !== Infinity) api.update(api.blend);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [api, limit] = [this.api(), this.inputs.get('limit')];\n\t\t\tif ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {\n\t\t\t\tthis.invalidate();\n\t\t\t\tapi.update();\n\t\t\t\tapi.count++;\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/staging/accumulative-shadows/progressive-light-map.mjs

@@ -0,0 +1,108 @@
+import { DiscardMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+function isLight(object) {
+    return object.isLight;
+}
+function isGeometry(object) {
+    return !!object.geometry;
+}
+// Based on "Progressive Light Map Accumulator", by [zalo](https://github.com/zalo/)
+export class ProgressiveLightMap {
+    constructor(renderer, scene, res = 1024) {
+        this.renderer = renderer;
+        this.res = res;
+        this.scene = scene;
+        this.buffer1Active = false;
+        this.lights = [];
+        this.meshes = [];
+        this.object = null;
+        this.clearColor = new THREE.Color();
+        this.clearAlpha = 0;
+        // Create the Progressive LightMap Texture
+        const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;
+        this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {
+            type: format,
+        });
+        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {
+            type: format,
+        });
+        // Inject some spicy new logic into a standard phong material
+        this.discardMat = new DiscardMaterial();
+        this.targetMat = new THREE.MeshLambertMaterial({ fog: false });
+        this.previousShadowMap = { value: this.progressiveLightMap1.texture };
+        this.averagingWindow = { value: 100 };
+        this.targetMat.onBeforeCompile = (shader) => {
+            // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions
+            shader.vertexShader =
+                'varying vec2 vUv;\n' +
+                    shader.vertexShader.slice(0, -1) +
+                    'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';
+            // Fragment Shader: Set Pixels to average in the Previous frame's Shadows
+            const bodyStart = shader.fragmentShader.indexOf('void main() {');
+            shader.fragmentShader =
+                'varying vec2 vUv;\n' +
+                    shader.fragmentShader.slice(0, bodyStart) +
+                    'uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n' +
+                    shader.fragmentShader.slice(bodyStart - 1, -1) +
+                    `\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;
+        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);
+      }`;
+            // Set the Previous Frame's Texture Buffer and Averaging Window
+            // Set the Previous Frame's Texture Buffer and Averaging Window
+            shader.uniforms['previousShadowMap'] = this.previousShadowMap;
+            shader.uniforms['averagingWindow'] = this.averagingWindow;
+        };
+    }
+    clear() {
+        this.renderer.getClearColor(this.clearColor);
+        this.clearAlpha = this.renderer.getClearAlpha();
+        this.renderer.setClearColor('black', 1);
+        this.renderer.setRenderTarget(this.progressiveLightMap1);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(this.progressiveLightMap2);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(null);
+        this.renderer.setClearColor(this.clearColor, this.clearAlpha);
+        this.lights = [];
+        this.meshes = [];
+        this.scene.traverse((object) => {
+            if (isGeometry(object)) {
+                this.meshes.push({ object, material: object.material });
+            }
+            else if (isLight(object)) {
+                this.lights.push({ object, intensity: object.intensity });
+            }
+        });
+    }
+    prepare() {
+        this.lights.forEach((light) => (light.object.intensity = 0));
+        this.meshes.forEach((mesh) => (mesh.object.material = this.discardMat));
+    }
+    finish() {
+        this.lights.forEach((light) => (light.object.intensity = light.intensity));
+        this.meshes.forEach((mesh) => (mesh.object.material = mesh.material));
+    }
+    configure(object) {
+        this.object = object;
+    }
+    update(camera, blendWindow = 100) {
+        if (!this.object)
+            return;
+        // Set each object's material to the UV Unwrapped Surface Mapping Version
+        this.averagingWindow.value = blendWindow;
+        this.object.material = this.targetMat;
+        // Ping-pong two surface buffers for reading/writing
+        const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+        const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
+        // Render the object's surface maps
+        const oldBg = this.scene.background;
+        this.scene.background = null;
+        this.renderer.setRenderTarget(activeMap);
+        this.previousShadowMap.value = inactiveMap.texture;
+        this.buffer1Active = !this.buffer1Active;
+        this.renderer.render(this.scene, camera);
+        this.renderer.setRenderTarget(null);
+        this.scene.background = oldBg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progressive-light-map.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/accumulative-shadows/progressive-light-map.ts"],"names":[],"mappings":"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","sourcesContent":["import { DiscardMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\n\nfunction isLight(object: any): object is THREE.Light {\n\treturn object.isLight;\n}\n\nfunction isGeometry(object: any): object is THREE.Mesh {\n\treturn !!object.geometry;\n}\n\n// Based on \"Progressive Light Map Accumulator\", by [zalo](https://github.com/zalo/)\nexport class ProgressiveLightMap {\n\trenderer: THREE.WebGLRenderer;\n\tres: number;\n\tscene: THREE.Scene;\n\tobject: THREE.Mesh | null;\n\tbuffer1Active: boolean;\n\tprogressiveLightMap1: THREE.WebGLRenderTarget;\n\tprogressiveLightMap2: THREE.WebGLRenderTarget;\n\tdiscardMat: THREE.ShaderMaterial;\n\ttargetMat: THREE.MeshLambertMaterial;\n\tpreviousShadowMap: { value: THREE.Texture };\n\taveragingWindow: { value: number };\n\tclearColor: THREE.Color;\n\tclearAlpha: number;\n\tlights: { object: THREE.Light; intensity: number }[];\n\tmeshes: { object: THREE.Mesh; material: THREE.Material | THREE.Material[] }[];\n\n\tconstructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, res: number = 1024) {\n\t\tthis.renderer = renderer;\n\t\tthis.res = res;\n\t\tthis.scene = scene;\n\t\tthis.buffer1Active = false;\n\t\tthis.lights = [];\n\t\tthis.meshes = [];\n\t\tthis.object = null;\n\t\tthis.clearColor = new THREE.Color();\n\t\tthis.clearAlpha = 0;\n\n\t\t// Create the Progressive LightMap Texture\n\t\tconst format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;\n\t\tthis.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {\n\t\t\ttype: format,\n\t\t});\n\t\tthis.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {\n\t\t\ttype: format,\n\t\t});\n\n\t\t// Inject some spicy new logic into a standard phong material\n\t\tthis.discardMat = new DiscardMaterial();\n\t\tthis.targetMat = new THREE.MeshLambertMaterial({ fog: false });\n\t\tthis.previousShadowMap = { value: this.progressiveLightMap1.texture };\n\t\tthis.averagingWindow = { value: 100 };\n\t\tthis.targetMat.onBeforeCompile = (shader) => {\n\t\t\t// Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions\n\t\t\tshader.vertexShader =\n\t\t\t\t'varying vec2 vUv;\\n' +\n\t\t\t\tshader.vertexShader.slice(0, -1) +\n\t\t\t\t'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';\n\n\t\t\t// Fragment Shader: Set Pixels to average in the Previous frame's Shadows\n\t\t\tconst bodyStart = shader.fragmentShader.indexOf('void main() {');\n\t\t\tshader.fragmentShader =\n\t\t\t\t'varying vec2 vUv;\\n' +\n\t\t\t\tshader.fragmentShader.slice(0, bodyStart) +\n\t\t\t\t'uniform sampler2D previousShadowMap;\\n\tuniform float averagingWindow;\\n' +\n\t\t\t\tshader.fragmentShader.slice(bodyStart - 1, -1) +\n\t\t\t\t`\\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;\n        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);\n      }`;\n\n\t\t\t// Set the Previous Frame's Texture Buffer and Averaging Window\n\t\t\t// Set the Previous Frame's Texture Buffer and Averaging Window\n\t\t\tshader.uniforms['previousShadowMap'] = this.previousShadowMap;\n\t\t\tshader.uniforms['averagingWindow'] = this.averagingWindow;\n\t\t};\n\t}\n\n\tclear() {\n\t\tthis.renderer.getClearColor(this.clearColor);\n\t\tthis.clearAlpha = this.renderer.getClearAlpha();\n\t\tthis.renderer.setClearColor('black', 1);\n\t\tthis.renderer.setRenderTarget(this.progressiveLightMap1);\n\t\tthis.renderer.clear();\n\t\tthis.renderer.setRenderTarget(this.progressiveLightMap2);\n\t\tthis.renderer.clear();\n\t\tthis.renderer.setRenderTarget(null);\n\t\tthis.renderer.setClearColor(this.clearColor, this.clearAlpha);\n\n\t\tthis.lights = [];\n\t\tthis.meshes = [];\n\t\tthis.scene.traverse((object) => {\n\t\t\tif (isGeometry(object)) {\n\t\t\t\tthis.meshes.push({ object, material: object.material });\n\t\t\t} else if (isLight(object)) {\n\t\t\t\tthis.lights.push({ object, intensity: object.intensity });\n\t\t\t}\n\t\t});\n\t}\n\n\tprepare() {\n\t\tthis.lights.forEach((light) => (light.object.intensity = 0));\n\t\tthis.meshes.forEach((mesh) => (mesh.object.material = this.discardMat));\n\t}\n\n\tfinish() {\n\t\tthis.lights.forEach((light) => (light.object.intensity = light.intensity));\n\t\tthis.meshes.forEach((mesh) => (mesh.object.material = mesh.material));\n\t}\n\n\tconfigure(object: THREE.Mesh) {\n\t\tthis.object = object;\n\t}\n\n\tupdate(camera: THREE.Camera, blendWindow = 100) {\n\t\tif (!this.object) return;\n\t\t// Set each object's material to the UV Unwrapped Surface Mapping Version\n\t\tthis.averagingWindow.value = blendWindow;\n\t\tthis.object.material = this.targetMat;\n\t\t// Ping-pong two surface buffers for reading/writing\n\t\tconst activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;\n\t\tconst inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;\n\t\t// Render the object's surface maps\n\t\tconst oldBg = this.scene.background;\n\t\tthis.scene.background = null;\n\t\tthis.renderer.setRenderTarget(activeMap);\n\t\tthis.previousShadowMap.value = inactiveMap.texture;\n\t\tthis.buffer1Active = !this.buffer1Active;\n\t\tthis.renderer.render(this.scene, camera);\n\t\tthis.renderer.setRenderTarget(null);\n\t\tthis.scene.background = oldBg;\n\t}\n}\n"]}