angular-three-soba 1.0.2 → 1.2.0

package/esm2020/staging/index.mjs

@@ -0,0 +1,13 @@
+export { NgtsAccumulativeShadows } from './lib/accumulative-shadows/accumulative-shadows';
+export { NgtsRandomizedLights } from './lib/accumulative-shadows/randomized-lights';
+export * from './lib/bounds/bounds';
+export * from './lib/center/center';
+export * from './lib/contact-shadows/contact-shadows';
+export * from './lib/environment/assets';
+export * from './lib/environment/environment';
+export * from './lib/float/float';
+export * from './lib/sky/sky';
+export * from './lib/sparkles/sparkles';
+export * from './lib/stage/stage';
+export * from './lib/stars/stars';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdGhyZWUtc29iYS9zdGFnaW5nL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpREFBaUQsQ0FBQztBQUMxRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUNwRixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IE5ndHNBY2N1bXVsYXRpdmVTaGFkb3dzIH0gZnJvbSAnLi9saWIvYWNjdW11bGF0aXZlLXNoYWRvd3MvYWNjdW11bGF0aXZlLXNoYWRvd3MnO1xuZXhwb3J0IHsgTmd0c1JhbmRvbWl6ZWRMaWdodHMgfSBmcm9tICcuL2xpYi9hY2N1bXVsYXRpdmUtc2hhZG93cy9yYW5kb21pemVkLWxpZ2h0cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ib3VuZHMvYm91bmRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlbnRlci9jZW50ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udGFjdC1zaGFkb3dzL2NvbnRhY3Qtc2hhZG93cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lbnZpcm9ubWVudC9hc3NldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZW52aXJvbm1lbnQvZW52aXJvbm1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZmxvYXQvZmxvYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2t5L3NreSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zcGFya2xlcy9zcGFya2xlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdGFnZS9zdGFnZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdGFycy9zdGFycyc7XG4iXX0=

package/esm2020/staging/lib/accumulative-shadows/accumulative-shadows.mjs

@@ -0,0 +1,276 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, Directive, inject, InjectionToken, Input } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtRxStore, NgtStore } from 'angular-three';
+import { shaderMaterial } from 'angular-three-soba/shaders';
+import { combineLatest } from 'rxjs';
+import * as THREE from 'three';
+import { Group, Mesh, PlaneGeometry } from 'three';
+import { ProgressiveLightMap } from './progressive-light-map';
+import * as i0 from "@angular/core";
+const SoftShadowMaterial = shaderMaterial({
+    color: new THREE.Color(),
+    blend: 2.0,
+    alphaTest: 0.75,
+    opacity: 0,
+    map: null,
+}, 
+// language=GLSL
+`
+varying vec2 vUv;
+void main() {
+  gl_Position = projectionMatrix * viewMatrix * modeLMatrix * vec4(position, 1.);
+  vUv = uv;
+}
+  `, 
+// language=GLSL
+`
+varying vec2 vUv;
+uniform sampler2D map;
+uniform vec3 color;
+uniform float blend;
+uniform float opacity;
+uniform float alphaTest;
+void main() {
+  vec4 sampleDiffuseColor = texture2D(map, vUv):
+  gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);
+  #include <tonemapping_fragment>
+  #include <encodings_fragment>
+}
+  `);
+extend({ SoftShadowMaterial, Group, Mesh, PlaneGeometry });
+export const NGTS_ACCUMULATIVE_SHADOWS_API = new InjectionToken('NgtsAccumulativeShadows API');
+function accumulativeShadowsApiFactory(accumulativeShadows) {
+    const store = inject(NgtStore);
+    const api = {
+        lights: new Map(),
+        count: 0,
+        getMesh: () => accumulativeShadows.meshRef.nativeElement,
+        reset: () => {
+            accumulativeShadows.pLM.clear();
+            const material = api.getMesh().material;
+            material.opacity = 0;
+            material.alphaTest = 0;
+            api.count = 0;
+        },
+        update: (frames = 1) => {
+            // adapt the opacity blend ratio to the number of frames
+            const material = api.getMesh().material;
+            if (!api.temporal) {
+                material.opacity = accumulativeShadows.get('opacity');
+                material.alphaTest = accumulativeShadows.get('alphaTest');
+            }
+            else {
+                material.opacity = Math.min(accumulativeShadows.get('opacity'), material.opacity + accumulativeShadows.get('opacity') / api.blend);
+                material.alphaTest = Math.min(accumulativeShadows.get('alphaTest'), material.alphaTest + accumulativeShadows.get('alphaTest') / api.blend);
+            }
+            // switch accumulative lights on
+            accumulativeShadows.accumulativeShadowsRef.nativeElement.visible = true;
+            // collect scene lights and meshes
+            accumulativeShadows.pLM.prepare();
+            // update the lightmap and the accumulative lights
+            for (let i = 0; i < frames; i++) {
+                api.lights.forEach((light) => light.update());
+                accumulativeShadows.pLM.update(store.get('camera'), api.blend);
+            }
+            // switch lights off
+            accumulativeShadows.accumulativeShadowsRef.nativeElement.visible = false;
+            // restore lights and meshes
+            accumulativeShadows.pLM.finish();
+        },
+    };
+    Object.defineProperties(api, {
+        temporal: {
+            get: () => !!accumulativeShadows.get('temporal'),
+        },
+        frames: {
+            get: () => Math.max(2, accumulativeShadows.get('frames')),
+        },
+        blend: {
+            get: () => Math.max(2, accumulativeShadows.get('frames') === Infinity
+                ? accumulativeShadows.get('blend')
+                : accumulativeShadows.get('frames')),
+        },
+    });
+    accumulativeShadows.hold(accumulativeShadows.meshRef.$, (mesh) => {
+        accumulativeShadows.pLM.configure(mesh);
+        accumulativeShadows.hold(combineLatest([accumulativeShadows.select(), getLocalState(store.get('scene')).objects]), () => {
+            // reset internals, buffers, ...
+            api.reset();
+            // update lightmap
+            if (!api.temporal && api.frames !== Infinity)
+                api.update(api.blend);
+        });
+    });
+    injectBeforeRender(() => {
+        const limit = accumulativeShadows.get('limit');
+        if (api.getMesh() && (api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {
+            api.update();
+            api.count++;
+        }
+    });
+    return api;
+}
+export class AccumulativeShadowsConsumer {
+    constructor() {
+        inject(NGTS_ACCUMULATIVE_SHADOWS_API);
+    }
+}
+AccumulativeShadowsConsumer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: AccumulativeShadowsConsumer, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AccumulativeShadowsConsumer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.3", type: AccumulativeShadowsConsumer, isStandalone: true, selector: "ngts-accumulative-shadows-consumer", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: AccumulativeShadowsConsumer, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ngts-accumulative-shadows-consumer', standalone: true }]
+        }], ctorParameters: function () { return []; } });
+export class NgtsAccumulativeShadows extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.nullTraverse = () => null;
+        this.Math = Math;
+        this.store = inject(NgtStore);
+        this.pLM = new ProgressiveLightMap(this.store.get('gl'), this.store.get('scene'), this.get('resolution'));
+        this.accumulativeShadowsRef = injectNgtRef();
+        this.meshRef = injectNgtRef();
+    }
+    /** How many frames it can render, more yields cleaner results but takes more time, 40 */
+    set frames(frames) {
+        this.set({ frames });
+    }
+    /** If frames === Infinity blend controls the refresh ratio, 100 */
+    set blend(blend) {
+        this.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.set({ limit });
+    }
+    /** Scale of the plane,  */
+    set scale(scale) {
+        this.set({ scale });
+    }
+    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */
+    set temporal(temporal) {
+        this.set({ temporal });
+    }
+    /** Opacity of the plane, 1 */
+    set opacity(opacity) {
+        this.set({ opacity });
+    }
+    /** Discards alpha pixels, 0.65 */
+    set alphaTest(alphaTest) {
+        this.set({ alphaTest });
+    }
+    /** Shadow color, black */
+    set color(color) {
+        this.set({ color });
+    }
+    /** Colorblend, how much colors turn to black, 0 is black, 2 */
+    set colorBlend(colorBlend) {
+        this.set({ colorBlend });
+    }
+    /** Buffer resolution, 1024 */
+    set resolution(resolution) {
+        this.set({ resolution });
+    }
+    /** Texture tonemapping */
+    set toneMapped(toneMapped) {
+        this.set({ toneMapped });
+    }
+    initialize() {
+        super.initialize();
+        this.set({
+            frames: 40,
+            limit: Infinity,
+            blend: 20,
+            scale: 10,
+            opacity: 1,
+            alphaTest: 0.75,
+            color: 'black',
+            colorBlend: 2,
+            resolution: 1024,
+            toneMapped: true,
+        });
+    }
+}
+NgtsAccumulativeShadows.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsAccumulativeShadows, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NgtsAccumulativeShadows.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.3", type: NgtsAccumulativeShadows, isStandalone: true, selector: "ngts-accumulative-shadows", inputs: { frames: "frames", blend: "blend", limit: "limit", scale: "scale", temporal: "temporal", opacity: "opacity", alphaTest: "alphaTest", color: "color", colorBlend: "colorBlend", resolution: "resolution", toneMapped: "toneMapped" }, providers: [
+        {
+            provide: NGTS_ACCUMULATIVE_SHADOWS_API,
+            useFactory: accumulativeShadowsApiFactory,
+            deps: [NgtsAccumulativeShadows],
+        },
+    ], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound>
+            <ngt-group [ref]="accumulativeShadowsRef" [traverse]="nullTraverse">
+                <ng-content />
+                <ngts-accumulative-shadows-consumer />
+            </ngt-group>
+            <ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="get('scale')" [rotation]="[-Math.PI / 2, 0, 0]">
+                <ngt-plane-geometry />
+                <ngt-soft-shadow-material
+                    [transparent]="true"
+                    [depthWrite]="false"
+                    [color]="get('color')"
+                    [toneMapped]="get('toneMapped')"
+                    [blend]="get('colorBlend')"
+                    [map]="pLM.progressiveLightMap2.texture"
+                />
+            </ngt-mesh>
+        </ngt-group>
+    `, isInline: true, dependencies: [{ kind: "directive", type: AccumulativeShadowsConsumer, selector: "ngts-accumulative-shadows-consumer" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.3", ngImport: i0, type: NgtsAccumulativeShadows, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-accumulative-shadows',
+                    standalone: true,
+                    template: `
+        <ngt-group ngtCompound>
+            <ngt-group [ref]="accumulativeShadowsRef" [traverse]="nullTraverse">
+                <ng-content />
+                <ngts-accumulative-shadows-consumer />
+            </ngt-group>
+            <ngt-mesh [receiveShadow]="true" [ref]="meshRef" [scale]="get('scale')" [rotation]="[-Math.PI / 2, 0, 0]">
+                <ngt-plane-geometry />
+                <ngt-soft-shadow-material
+                    [transparent]="true"
+                    [depthWrite]="false"
+                    [color]="get('color')"
+                    [toneMapped]="get('toneMapped')"
+                    [blend]="get('colorBlend')"
+                    [map]="pLM.progressiveLightMap2.texture"
+                />
+            </ngt-mesh>
+        </ngt-group>
+    `,
+                    imports: [AccumulativeShadowsConsumer],
+                    providers: [
+                        {
+                            provide: NGTS_ACCUMULATIVE_SHADOWS_API,
+                            useFactory: accumulativeShadowsApiFactory,
+                            deps: [NgtsAccumulativeShadows],
+                        },
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], propDecorators: { frames: [{
+                type: Input
+            }], blend: [{
+                type: Input
+            }], limit: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], temporal: [{
+                type: Input
+            }], opacity: [{
+                type: Input
+            }], alphaTest: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], colorBlend: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }], toneMapped: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulative-shadows.js","sourceRoot":"","sources":["../../../../../../../libs/angular-three-soba/staging/src/lib/accumulative-shadows/accumulative-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, Directive, inject, InjectionToken, Input } from '@angular/core';\nimport { extend, getLocalState, injectBeforeRender, injectNgtRef, NgtRxStore, NgtStore } from 'angular-three';\nimport { shaderMaterial } from 'angular-three-soba/shaders';\nimport { combineLatest } from 'rxjs';\nimport * as THREE from 'three';\nimport { Group, Mesh, PlaneGeometry } from 'three';\nimport { ProgressiveLightMap } from './progressive-light-map';\n\nconst SoftShadowMaterial = shaderMaterial(\n    {\n        color: new THREE.Color(),\n        blend: 2.0,\n        alphaTest: 0.75,\n        opacity: 0,\n        map: null,\n    },\n    // language=GLSL\n    `\nvarying vec2 vUv;\nvoid main() {\n  gl_Position = projectionMatrix * viewMatrix * modeLMatrix * vec4(position, 1.);\n  vUv = uv;\n}\n  `,\n    // language=GLSL\n    `\nvarying vec2 vUv;\nuniform sampler2D map;\nuniform vec3 color;\nuniform float blend;\nuniform float opacity;\nuniform float alphaTest;\nvoid main() {\n  vec4 sampleDiffuseColor = texture2D(map, vUv):\n  gl_FragColor = vec4(color * sampledDiffuseColor.r * blend, max(0.0, (1.0 - (sampledDiffuseColor.r + sampledDiffuseColor.g + sampledDiffuseColor.b) / alphaTest)) * opacity);\n  #include <tonemapping_fragment>\n  #include <encodings_fragment>\n}\n  `\n);\n\ntype SoftShadowMaterialInputs = {\n    map: THREE.Texture;\n    color?: THREE.ColorRepresentation;\n    alphaTest?: number;\n    blend?: number;\n};\n\nextend({ SoftShadowMaterial, Group, Mesh, PlaneGeometry });\n\nexport type NgtsAccumulativeShadowsLightApi = { update: () => void };\n\nexport type NgtsAccumulativeShadowsApi = {\n    lights: Map<string, NgtsAccumulativeShadowsLightApi>;\n    temporal: boolean;\n    frames: number;\n    blend: number;\n    count: number;\n    getMesh: () => THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialInputs & THREE.ShaderMaterial>;\n    reset: () => void;\n    update: (frames?: number) => void;\n};\n\nexport const NGTS_ACCUMULATIVE_SHADOWS_API = new InjectionToken<NgtsAccumulativeShadowsApi>(\n    'NgtsAccumulativeShadows API'\n);\n\nfunction accumulativeShadowsApiFactory(accumulativeShadows: NgtsAccumulativeShadows) {\n    const store = inject(NgtStore);\n\n    const api = {\n        lights: new Map(),\n        count: 0,\n        getMesh: () =>\n            accumulativeShadows.meshRef.nativeElement as THREE.Mesh<\n                THREE.PlaneGeometry,\n                SoftShadowMaterialInputs & THREE.ShaderMaterial\n            >,\n        reset: () => {\n            accumulativeShadows.pLM.clear();\n            const material = api.getMesh().material;\n            material.opacity = 0;\n            material.alphaTest = 0;\n            api.count = 0;\n        },\n        update: (frames = 1) => {\n            // adapt the opacity blend ratio to the number of frames\n            const material = api.getMesh().material;\n            if (!api.temporal) {\n                material.opacity = accumulativeShadows.get('opacity');\n                material.alphaTest = accumulativeShadows.get('alphaTest');\n            } else {\n                material.opacity = Math.min(\n                    accumulativeShadows.get('opacity'),\n                    material.opacity + accumulativeShadows.get('opacity') / api.blend\n                );\n                material.alphaTest = Math.min(\n                    accumulativeShadows.get('alphaTest'),\n                    material.alphaTest + accumulativeShadows.get('alphaTest') / api.blend\n                );\n            }\n\n            // switch accumulative lights on\n            accumulativeShadows.accumulativeShadowsRef.nativeElement.visible = true;\n            // collect scene lights and meshes\n            accumulativeShadows.pLM.prepare();\n\n            // update the lightmap and the accumulative lights\n            for (let i = 0; i < frames; i++) {\n                api.lights.forEach((light) => light.update());\n                accumulativeShadows.pLM.update(store.get('camera'), api.blend);\n            }\n\n            // switch lights off\n            accumulativeShadows.accumulativeShadowsRef.nativeElement.visible = false;\n            // restore lights and meshes\n            accumulativeShadows.pLM.finish();\n        },\n    } as NgtsAccumulativeShadowsApi;\n\n    Object.defineProperties(api, {\n        temporal: {\n            get: () => !!accumulativeShadows.get('temporal'),\n        },\n        frames: {\n            get: () => Math.max(2, accumulativeShadows.get('frames')),\n        },\n        blend: {\n            get: () =>\n                Math.max(\n                    2,\n                    accumulativeShadows.get('frames') === Infinity\n                        ? accumulativeShadows.get('blend')\n                        : accumulativeShadows.get('frames')\n                ),\n        },\n    });\n\n    accumulativeShadows.hold(accumulativeShadows.meshRef.$, (mesh) => {\n        accumulativeShadows.pLM.configure(mesh);\n\n        accumulativeShadows.hold(\n            combineLatest([accumulativeShadows.select(), getLocalState(store.get('scene')).objects]),\n            () => {\n                // reset internals, buffers, ...\n                api.reset();\n                // update lightmap\n                if (!api.temporal && api.frames !== Infinity) api.update(api.blend);\n            }\n        );\n    });\n\n    injectBeforeRender(() => {\n        const limit = accumulativeShadows.get('limit');\n        if (api.getMesh() && (api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {\n            api.update();\n            api.count++;\n        }\n    });\n\n    return api;\n}\n\n@Directive({ selector: 'ngts-accumulative-shadows-consumer', standalone: true })\nexport class AccumulativeShadowsConsumer {\n    constructor() {\n        inject(NGTS_ACCUMULATIVE_SHADOWS_API);\n    }\n}\n\n@Component({\n    selector: 'ngts-accumulative-shadows',\n    standalone: true,\n    template: `\n        <ngt-group ngtCompound>\n            <ngt-group [ref]=\"accumulativeShadowsRef\" [traverse]=\"nullTraverse\">\n                <ng-content />\n                <ngts-accumulative-shadows-consumer />\n            </ngt-group>\n            <ngt-mesh [receiveShadow]=\"true\" [ref]=\"meshRef\" [scale]=\"get('scale')\" [rotation]=\"[-Math.PI / 2, 0, 0]\">\n                <ngt-plane-geometry />\n                <ngt-soft-shadow-material\n                    [transparent]=\"true\"\n                    [depthWrite]=\"false\"\n                    [color]=\"get('color')\"\n                    [toneMapped]=\"get('toneMapped')\"\n                    [blend]=\"get('colorBlend')\"\n                    [map]=\"pLM.progressiveLightMap2.texture\"\n                />\n            </ngt-mesh>\n        </ngt-group>\n    `,\n    imports: [AccumulativeShadowsConsumer],\n    providers: [\n        {\n            provide: NGTS_ACCUMULATIVE_SHADOWS_API,\n            useFactory: accumulativeShadowsApiFactory,\n            deps: [NgtsAccumulativeShadows],\n        },\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsAccumulativeShadows extends NgtRxStore {\n    readonly nullTraverse = () => null;\n    readonly Math = Math;\n\n    private readonly store = inject(NgtStore);\n\n    readonly pLM = new ProgressiveLightMap(this.store.get('gl'), this.store.get('scene'), this.get('resolution'));\n\n    readonly accumulativeShadowsRef = injectNgtRef<THREE.Group>();\n    readonly meshRef = injectNgtRef<THREE.Mesh>();\n\n    /** How many frames it can render, more yields cleaner results but takes more time, 40 */\n    @Input() set frames(frames: number) {\n        this.set({ frames });\n    }\n\n    /** If frames === Infinity blend controls the refresh ratio, 100 */\n    @Input() set blend(blend: number) {\n        this.set({ blend });\n    }\n\n    /** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */\n    @Input() set limit(limit: number) {\n        this.set({ limit });\n    }\n\n    /** Scale of the plane,  */\n    @Input() set scale(scale: number) {\n        this.set({ scale });\n    }\n\n    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */\n    @Input() set temporal(temporal: boolean) {\n        this.set({ temporal });\n    }\n\n    /** Opacity of the plane, 1 */\n    @Input() set opacity(opacity: number) {\n        this.set({ opacity });\n    }\n\n    /** Discards alpha pixels, 0.65 */\n    @Input() set alphaTest(alphaTest: number) {\n        this.set({ alphaTest });\n    }\n\n    /** Shadow color, black */\n    @Input() set color(color: string) {\n        this.set({ color });\n    }\n\n    /** Colorblend, how much colors turn to black, 0 is black, 2 */\n    @Input() set colorBlend(colorBlend: number) {\n        this.set({ colorBlend });\n    }\n\n    /** Buffer resolution, 1024 */\n    @Input() set resolution(resolution: number) {\n        this.set({ resolution });\n    }\n\n    /** Texture tonemapping */\n    @Input() set toneMapped(toneMapped: boolean) {\n        this.set({ toneMapped });\n    }\n\n    override initialize(): void {\n        super.initialize();\n        this.set({\n            frames: 40,\n            limit: Infinity,\n            blend: 20,\n            scale: 10,\n            opacity: 1,\n            alphaTest: 0.75,\n            color: 'black',\n            colorBlend: 2,\n            resolution: 1024,\n            toneMapped: true,\n        });\n    }\n}\n"]}

package/esm2020/staging/lib/accumulative-shadows/progressive-light-map.mjs

@@ -0,0 +1,109 @@
+import { shaderMaterial } from 'angular-three-soba/shaders';
+import * as THREE from 'three';
+function isLight(object) {
+    return object.isLight;
+}
+function isGeometry(object) {
+    return !!object.geometry;
+}
+const DiscardMaterial = shaderMaterial({}, 'void main() { gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }', 'void main() { discard; }');
+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,
+            encoding: renderer.outputEncoding,
+        });
+        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {
+            type: format,
+            encoding: renderer.outputEncoding,
+        });
+        // 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
+            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/angular-three-soba/staging/src/lib/accumulative-shadows/progressive-light-map.ts"],"names":[],"mappings":"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","sourcesContent":["import { shaderMaterial } from 'angular-three-soba/shaders';\nimport * as THREE from 'three';\n\nfunction isLight(object: any): object is THREE.Light {\n    return object.isLight;\n}\n\nfunction isGeometry(object: any): object is THREE.Mesh {\n    return !!object.geometry;\n}\n\nconst DiscardMaterial = shaderMaterial(\n    {},\n    'void main() { gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }',\n    'void main() { discard; }'\n);\n\nexport class ProgressiveLightMap {\n    renderer: THREE.WebGLRenderer;\n    res: number;\n    scene: THREE.Scene;\n    object: THREE.Mesh | null;\n    buffer1Active: boolean;\n    progressiveLightMap1: THREE.WebGLRenderTarget;\n    progressiveLightMap2: THREE.WebGLRenderTarget;\n    discardMat: THREE.ShaderMaterial;\n    targetMat: THREE.MeshLambertMaterial;\n    previousShadowMap: { value: THREE.Texture };\n    averagingWindow: { value: number };\n    clearColor: THREE.Color;\n    clearAlpha: number;\n    lights: { object: THREE.Light; intensity: number }[];\n    meshes: { object: THREE.Mesh; material: THREE.Material | THREE.Material[] }[];\n\n    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, res: number = 1024) {\n        this.renderer = renderer;\n        this.res = res;\n        this.scene = scene;\n        this.buffer1Active = false;\n        this.lights = [];\n        this.meshes = [];\n        this.object = null;\n        this.clearColor = new THREE.Color();\n        this.clearAlpha = 0;\n\n        // Create the Progressive LightMap Texture\n        const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? THREE.HalfFloatType : THREE.FloatType;\n        this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, {\n            type: format,\n            encoding: renderer.outputEncoding,\n        });\n        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {\n            type: format,\n            encoding: renderer.outputEncoding,\n        });\n\n        // Inject some spicy new logic into a standard phong material\n        this.discardMat = new DiscardMaterial();\n        this.targetMat = new THREE.MeshLambertMaterial({ fog: false });\n        this.previousShadowMap = { value: this.progressiveLightMap1.texture };\n        this.averagingWindow = { value: 100 };\n        this.targetMat.onBeforeCompile = (shader) => {\n            // Vertex Shader: Set Vertex Positions to the Unwrapped UV Positions\n            shader.vertexShader =\n                'varying vec2 vUv;\\n' +\n                shader.vertexShader.slice(0, -1) +\n                'vUv = uv; gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }';\n\n            // Fragment Shader: Set Pixels to average in the Previous frame's Shadows\n            const bodyStart = shader.fragmentShader.indexOf('void main() {');\n            shader.fragmentShader =\n                'varying vec2 vUv;\\n' +\n                shader.fragmentShader.slice(0, bodyStart) +\n                'uniform sampler2D previousShadowMap;\\n\tuniform float averagingWindow;\\n' +\n                shader.fragmentShader.slice(bodyStart - 1, -1) +\n                `\\nvec3 texelOld = texture2D(previousShadowMap, vUv).rgb;\n        gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/ averagingWindow);\n      }`;\n\n            // Set the Previous Frame's Texture Buffer and Averaging Window\n            shader.uniforms['previousShadowMap'] = this.previousShadowMap;\n            shader.uniforms['averagingWindow'] = this.averagingWindow;\n        };\n    }\n\n    clear() {\n        this.renderer.getClearColor(this.clearColor);\n        this.clearAlpha = this.renderer.getClearAlpha();\n        this.renderer.setClearColor('black', 1);\n        this.renderer.setRenderTarget(this.progressiveLightMap1);\n        this.renderer.clear();\n        this.renderer.setRenderTarget(this.progressiveLightMap2);\n        this.renderer.clear();\n        this.renderer.setRenderTarget(null);\n        this.renderer.setClearColor(this.clearColor, this.clearAlpha);\n\n        this.lights = [];\n        this.meshes = [];\n        this.scene.traverse((object) => {\n            if (isGeometry(object)) {\n                this.meshes.push({ object, material: object.material });\n            } else if (isLight(object)) {\n                this.lights.push({ object, intensity: object.intensity });\n            }\n        });\n    }\n\n    prepare() {\n        this.lights.forEach((light) => (light.object.intensity = 0));\n        this.meshes.forEach((mesh) => (mesh.object.material = this.discardMat));\n    }\n\n    finish() {\n        this.lights.forEach((light) => (light.object.intensity = light.intensity));\n        this.meshes.forEach((mesh) => (mesh.object.material = mesh.material));\n    }\n\n    configure(object: any) {\n        this.object = object;\n    }\n\n    update(camera: any, blendWindow = 100) {\n        if (!this.object) return;\n        // Set each object's material to the UV Unwrapped Surface Mapping Version\n        this.averagingWindow.value = blendWindow;\n        this.object.material = this.targetMat;\n        // Ping-pong two surface buffers for reading/writing\n        const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;\n        const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;\n        // Render the object's surface maps\n        const oldBg = this.scene.background;\n        this.scene.background = null;\n        this.renderer.setRenderTarget(activeMap);\n        this.previousShadowMap.value = inactiveMap.texture;\n        this.buffer1Active = !this.buffer1Active;\n        this.renderer.render(this.scene, camera);\n        this.renderer.setRenderTarget(null);\n        this.scene.background = oldBg;\n    }\n}\n"]}