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

package/esm2022/shaders/sparkles-material/sparkles-material.mjs

@@ -0,0 +1,47 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const SparklesMaterial = shaderMaterial({ time: 0, pixelRatio: 1 }, 
+// language=GLSL
+`
+uniform float pixelRatio;
+uniform float time;
+
+attribute float size;
+attribute float speed;
+attribute float opacity;
+attribute vec3 noise;
+attribute vec3 color;
+
+varying vec3 vColor;
+varying float vOpacity;
+
+void main() {
+  vec4 modelPosition = modelMatrix * vec4(position, 1.0);
+
+  modelPosition.y += sin(time * speed + modelPosition.x * noise.x * 100.0) * 0.2;
+  modelPosition.z += cos(time * speed + modelPosition.x * noise.y * 100.0) * 0.2;
+  modelPosition.x += cos(time * speed + modelPosition.x * noise.z * 100.0) * 0.2;
+
+  vec4 viewPosition = viewMatrix * modelPosition;
+  vec4 projectionPostion = projectionMatrix * viewPosition;
+
+  gl_Position = projectionPostion;
+  gl_PointSize = size * 25. * pixelRatio;
+  gl_PointSize *= (1.0 / - viewPosition.z);
+
+  vColor = color;
+  vOpacity = opacity;
+}
+  `, 
+// language=GLSL
+`
+varying vec3 vColor;
+varying float vOpacity;
+
+void main() {
+  float distanceToCenter = distance(gl_PointCoord, vec2(0.5));
+  float strength = 0.05 / distanceToCenter - 0.1;
+
+  gl_FragColor = vec4(vColor, strength * vOpacity);
+}
+  `);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/spot-light-material/spot-light-material.mjs

@@ -0,0 +1,86 @@
+import { Color, ShaderMaterial, Vector2, Vector3 } from 'three';
+export class SpotLightMaterial extends ShaderMaterial {
+    constructor() {
+        super({
+            uniforms: {
+                depth: { value: null },
+                opacity: { value: 1 },
+                attenuation: { value: 2.5 },
+                anglePower: { value: 12 },
+                spotPosition: { value: new Vector3(0, 0, 0) },
+                lightColor: { value: new Color('white') },
+                cameraNear: { value: 0 },
+                cameraFar: { value: 1 },
+                resolution: { value: new Vector2(0, 0) },
+            },
+            transparent: true,
+            depthWrite: false,
+            vertexShader: /* glsl */ `
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+      varying float vViewZ;
+      varying float vIntensity;
+      uniform vec3 spotPosition;
+      uniform float attenuation;
+
+      void main() {
+        // compute intensity
+        vNormal = normalize( normalMatrix * normal );
+        vec4 worldPosition	= modelMatrix * vec4( position, 1.0 );
+        vWorldPosition = worldPosition.xyz;
+        vec4 viewPosition = viewMatrix * worldPosition;
+        vViewZ = viewPosition.z;
+        float intensity	= distance(worldPosition.xyz, spotPosition) / attenuation;
+        intensity	= 1.0 - clamp(intensity, 0.0, 1.0);
+        vIntensity = intensity;
+        // set gl_Position
+        gl_Position	= projectionMatrix * viewPosition;
+
+      }`,
+            fragmentShader: /* glsl */ `
+      #include <packing>
+
+      varying vec3 vNormal;
+      varying vec3 vWorldPosition;
+      uniform vec3 lightColor;
+      uniform vec3 spotPosition;
+      uniform float attenuation;
+      uniform float anglePower;
+      uniform sampler2D depth;
+      uniform vec2 resolution;
+      uniform float cameraNear;
+      uniform float cameraFar;
+      varying float vViewZ;
+      varying float vIntensity;
+      uniform float opacity;
+
+      float readDepth( sampler2D depthSampler, vec2 coord ) {
+        float fragCoordZ = texture2D( depthSampler, coord ).x;
+        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
+        return viewZ;
+      }
+
+      void main() {
+        float d = 1.0;
+        bool isSoft = resolution[0] > 0.0 && resolution[1] > 0.0;
+        if (isSoft) {
+          vec2 sUv = gl_FragCoord.xy / resolution;
+          d = readDepth(depth, sUv);
+        }
+        float intensity = vIntensity;
+        vec3 normal	= vec3(vNormal.x, vNormal.y, abs(vNormal.z));
+        float angleIntensity	= pow( dot(normal, vec3(0.0, 0.0, 1.0)), anglePower );
+        intensity	*= angleIntensity;
+        // fades when z is close to sampled depth, meaning the cone is intersecting existing geometry
+        if (isSoft) {
+          intensity	*= smoothstep(0., 1., vViewZ - d);
+        }
+        gl_FragColor = vec4(lightColor, intensity * opacity);
+
+        #include <tonemapping_fragment>
+	      #include <encodings_fragment>
+      }`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shaders/star-field-material/star-field-material.mjs

@@ -0,0 +1,32 @@
+import { shaderMaterial } from '../shader-material/shader-material';
+export const StarFieldMaterial = shaderMaterial({ time: 0.0, fade: 0.0 }, 
+// language=GLSL
+`
+uniform float time;
+attribute float size;
+varying vec3 vColor;
+void main() {
+  vColor = color;
+  vec4 mvPosition = modelViewMatrix * vec4(position, 0.5);
+  gl_PointSize = size * (30.0 / -mvPosition.z) * (3.0 + sin(time + 100.0));
+  gl_Position = projectionMatrix * mvPosition;
+}
+  `, 
+// language=GLSL
+`
+uniform sampler2D pointTexture;
+uniform float fade;
+varying vec3 vColor;
+void main() {
+  float opacity = 1.0;
+  if (fade == 1.0) {
+    float d = distance(gl_PointCoord, vec2(0.5, 0.5));
+    opacity = 1.0 / (1.0 + exp(16.0 * (d - 0.25)));
+  }
+  gl_FragColor = vec4(vColor, opacity);
+
+  #include <tonemapping_fragment>
+  #include <encodings_fragment>
+}
+  `);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Rhci1maWVsZC1tYXRlcmlhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zaGFkZXJzL3NyYy9zdGFyLWZpZWxkLW1hdGVyaWFsL3N0YXItZmllbGQtbWF0ZXJpYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRXBFLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLGNBQWMsQ0FDM0MsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUU7QUFDeEIsZ0JBQWdCO0FBQ2hCOzs7Ozs7Ozs7O0dBVUQ7QUFDQyxnQkFBZ0I7QUFDaEI7Ozs7Ozs7Ozs7Ozs7OztHQWVELENBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHNoYWRlck1hdGVyaWFsIH0gZnJvbSAnLi4vc2hhZGVyLW1hdGVyaWFsL3NoYWRlci1tYXRlcmlhbCc7XG5cbmV4cG9ydCBjb25zdCBTdGFyRmllbGRNYXRlcmlhbCA9IHNoYWRlck1hdGVyaWFsKFxuICAgIHsgdGltZTogMC4wLCBmYWRlOiAwLjAgfSxcbiAgICAvLyBsYW5ndWFnZT1HTFNMXG4gICAgYFxudW5pZm9ybSBmbG9hdCB0aW1lO1xuYXR0cmlidXRlIGZsb2F0IHNpemU7XG52YXJ5aW5nIHZlYzMgdkNvbG9yO1xudm9pZCBtYWluKCkge1xuICB2Q29sb3IgPSBjb2xvcjtcbiAgdmVjNCBtdlBvc2l0aW9uID0gbW9kZWxWaWV3TWF0cml4ICogdmVjNChwb3NpdGlvbiwgMC41KTtcbiAgZ2xfUG9pbnRTaXplID0gc2l6ZSAqICgzMC4wIC8gLW12UG9zaXRpb24ueikgKiAoMy4wICsgc2luKHRpbWUgKyAxMDAuMCkpO1xuICBnbF9Qb3NpdGlvbiA9IHByb2plY3Rpb25NYXRyaXggKiBtdlBvc2l0aW9uO1xufVxuICBgLFxuICAgIC8vIGxhbmd1YWdlPUdMU0xcbiAgICBgXG51bmlmb3JtIHNhbXBsZXIyRCBwb2ludFRleHR1cmU7XG51bmlmb3JtIGZsb2F0IGZhZGU7XG52YXJ5aW5nIHZlYzMgdkNvbG9yO1xudm9pZCBtYWluKCkge1xuICBmbG9hdCBvcGFjaXR5ID0gMS4wO1xuICBpZiAoZmFkZSA9PSAxLjApIHtcbiAgICBmbG9hdCBkID0gZGlzdGFuY2UoZ2xfUG9pbnRDb29yZCwgdmVjMigwLjUsIDAuNSkpO1xuICAgIG9wYWNpdHkgPSAxLjAgLyAoMS4wICsgZXhwKDE2LjAgKiAoZCAtIDAuMjUpKSk7XG4gIH1cbiAgZ2xfRnJhZ0NvbG9yID0gdmVjNCh2Q29sb3IsIG9wYWNpdHkpO1xuXG4gICNpbmNsdWRlIDx0b25lbWFwcGluZ19mcmFnbWVudD5cbiAgI2luY2x1ZGUgPGVuY29kaW5nc19mcmFnbWVudD5cbn1cbiAgYFxuKTtcbiJdfQ==

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

@@ -0,0 +1,283 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, InjectionToken, Input, computed, effect, inject, untracked, } from '@angular/core';
+import { NgtSignalStore, NgtStore, extend, getLocalState, injectBeforeRender, injectNgtRef, requestAnimationInInjectionContext, } 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({ SoftShadowMaterial, Group, Mesh, PlaneGeometry });
+export const NGTS_ACCUMULATIVE_SHADOWS_API = new InjectionToken('NgtsAccumulativeShadows API');
+class NgtsAccumulativeShadows extends NgtSignalStore {
+    /** 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 });
+    }
+    #store;
+    #gl;
+    #scene;
+    #camera;
+    #resolution;
+    #temporal;
+    #blend;
+    #frames;
+    #opacity;
+    #alphaTest;
+    constructor() {
+        super({
+            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.#store = inject(NgtStore);
+        this.#gl = this.#store.select('gl');
+        this.#scene = this.#store.select('scene');
+        this.#camera = this.#store.select('camera');
+        this.#resolution = this.select('resolution');
+        this.#temporal = this.select('temporal');
+        this.#blend = this.select('blend');
+        this.#frames = this.select('frames');
+        this.#opacity = this.select('opacity');
+        this.#alphaTest = this.select('alphaTest');
+        this.accumulativeShadowsScale = this.select('scale');
+        this.accumulativeShadowsToneMapped = this.select('toneMapped');
+        this.accumulativeShadowsColor = this.select('color');
+        this.accumulativeShadowsColorBlend = this.select('colorBlend');
+        this.meshRef = injectNgtRef();
+        this.accumulativeShadowsRef = injectNgtRef();
+        this.pLM = computed(() => new ProgressiveLightMap(untracked(this.#gl), untracked(this.#scene), this.#resolution()));
+        this.api = computed(() => {
+            const pLM = this.pLM();
+            const alphaTest = this.#alphaTest();
+            const opacity = this.#opacity();
+            const camera = this.#camera();
+            return {
+                lights: new Map(),
+                temporal: this.#temporal(),
+                frames: Math.max(2, this.#frames()),
+                blend: Math.max(2, this.#frames() === Infinity ? this.#blend() : this.#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;
+                    this.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 (!this.api().temporal) {
+                        material.opacity = opacity;
+                        material.alphaTest = alphaTest;
+                    }
+                    else {
+                        material.opacity = Math.min(opacity, material.opacity + opacity / this.api().blend);
+                        material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / this.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++) {
+                        this.api().lights.forEach((light) => light().update());
+                        pLM.update(camera, this.api().blend);
+                    }
+                    // Switch lights off
+                    this.accumulativeShadowsRef.nativeElement.visible = false;
+                    // Restore lights and meshes
+                    pLM.finish();
+                },
+            };
+        });
+        requestAnimationInInjectionContext(() => {
+            this.#configure();
+            this.#resetAndUpdate();
+        });
+        injectBeforeRender(this.#onBeforeRender.bind(this));
+    }
+    #onBeforeRender() {
+        const invalidate = this.#store.get('invalidate');
+        const limit = this.get('limit');
+        const api = this.api();
+        if ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {
+            invalidate();
+            api.update();
+            api.count++;
+        }
+    }
+    #configure() {
+        const trigger = computed(() => ({ pLM: this.pLM(), mesh: this.meshRef.nativeElement }));
+        effect(() => {
+            const { pLM, mesh } = trigger();
+            if (!mesh)
+                return;
+            pLM.configure(mesh);
+        });
+    }
+    #resetAndUpdate() {
+        const trigger = computed(() => ({
+            state: this.select()(),
+            objects: getLocalState(this.#store.get('scene')).objects(),
+            mesh: this.meshRef.nativeElement,
+        }));
+        effect(() => {
+            const { mesh } = trigger();
+            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);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsAccumulativeShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", 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: (shadows) => shadows.api,
+                deps: [NgtsAccumulativeShadows],
+            },
+        ], usesInheritance: true, ngImport: i0, template: `
+        <ngt-group ngtCompound>
+            <ngt-group [ref]="accumulativeShadowsRef" [traverse]="nullTraverse">
+                <ng-content />
+            </ngt-group>
+            <ngt-mesh
+                [ref]="meshRef"
+                [receiveShadow]="true"
+                [scale]="accumulativeShadowsScale()"
+                [rotation]="[-Math.PI / 2, 0, 0]"
+            >
+                <ngt-plane-geometry />
+                <ngt-soft-shadow-material
+                    [transparent]="true"
+                    [depthWrite]="false"
+                    [toneMapped]="accumulativeShadowsToneMapped()"
+                    [color]="accumulativeShadowsColor()"
+                    [blend]="accumulativeShadowsColorBlend()"
+                    [map]="pLM().progressiveLightMap2.texture"
+                />
+            </ngt-mesh>
+        </ngt-group>
+    `, isInline: true }); }
+}
+export { NgtsAccumulativeShadows };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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 />
+            </ngt-group>
+            <ngt-mesh
+                [ref]="meshRef"
+                [receiveShadow]="true"
+                [scale]="accumulativeShadowsScale()"
+                [rotation]="[-Math.PI / 2, 0, 0]"
+            >
+                <ngt-plane-geometry />
+                <ngt-soft-shadow-material
+                    [transparent]="true"
+                    [depthWrite]="false"
+                    [toneMapped]="accumulativeShadowsToneMapped()"
+                    [color]="accumulativeShadowsColor()"
+                    [blend]="accumulativeShadowsColorBlend()"
+                    [map]="pLM().progressiveLightMap2.texture"
+                />
+            </ngt-mesh>
+        </ngt-group>
+    `,
+                    providers: [
+                        {
+                            provide: NGTS_ACCUMULATIVE_SHADOWS_API,
+                            useFactory: (shadows) => shadows.api,
+                            deps: [NgtsAccumulativeShadows],
+                        },
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, 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/soba/staging/src/accumulative-shadows/accumulative-shadows.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EACtB,SAAS,EACT,cAAc,EACd,KAAK,EAEL,QAAQ,EACR,MAAM,EACN,MAAM,EACN,SAAS,GACZ,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,cAAc,EACd,QAAQ,EACR,MAAM,EACN,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,kCAAkC,GAErC,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAA4B,MAAM,4BAA4B,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;;AAE9D,MAAM,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;AAwC3D,MAAM,CAAC,MAAM,6BAA6B,GAAG,IAAI,cAAc,CAC3D,6BAA6B,CAChC,CAAC;AAQF,MAmCa,uBAAwB,SAAQ,cAA4C;IAIrF,yFAAyF;IACzF,IAAa,MAAM,CAAC,MAAc;QAC9B,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IAED,mEAAmE;IACnE,IAAa,KAAK,CAAC,KAAa;QAC5B,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,sJAAsJ;IACtJ,IAAa,KAAK,CAAC,KAAa;QAC5B,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,2BAA2B;IAC3B,IAAa,KAAK,CAAC,KAAa;QAC5B,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,+HAA+H;IAC/H,IAAa,QAAQ,CAAC,QAAiB;QACnC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,8BAA8B;IAC9B,IAAa,OAAO,CAAC,OAAe;QAChC,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,kCAAkC;IAClC,IAAa,SAAS,CAAC,SAAiB;QACpC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,0BAA0B;IAC1B,IAAa,KAAK,CAAC,KAAa;QAC5B,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,+DAA+D;IAC/D,IAAa,UAAU,CAAC,UAAkB;QACtC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,8BAA8B;IAC9B,IAAa,UAAU,CAAC,UAAkB;QACtC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,0BAA0B;IAC1B,IAAa,UAAU,CAAC,UAAmB;QACvC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAEQ,MAAM,CAAoB;IAC1B,GAAG,CAA4B;IAC/B,MAAM,CAA+B;IACrC,OAAO,CAAgC;IAEvC,WAAW,CAA6B;IACxC,SAAS,CAA2B;IACpC,MAAM,CAAwB;IAC9B,OAAO,CAAyB;IAChC,QAAQ,CAA0B;IAClC,UAAU,CAA4B;IAkE/C;QACI,KAAK,CAAC;YACF,MAAM,EAAE,EAAE;YACV,KAAK,EAAE,QAAQ;YACf,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,EAAE;YACT,OAAO,EAAE,CAAC;YACV,SAAS,EAAE,IAAI;YACf,KAAK,EAAE,OAAO;YACd,UAAU,EAAE,CAAC;YACb,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;SAClB,CAAC,CAAC;QAnJE,iBAAY,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC;QAC1B,SAAI,GAAG,IAAI,CAAC;QAyDZ,WAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1B,QAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC/B,WAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrC,YAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEvC,gBAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACxC,cAAS,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QACpC,WAAM,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC9B,YAAO,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,aAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAClC,eAAU,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAEtC,6BAAwB,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAChD,kCAA6B,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC1D,6BAAwB,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAChD,kCAA6B,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAE1D,YAAO,GAAG,YAAY,EAAoF,CAAC;QAC3G,2BAAsB,GAAG,YAAY,EAAe,CAAC;QAErD,QAAG,GAAG,QAAQ,CACnB,GAAG,EAAE,CAAC,IAAI,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CACjG,CAAC;QAEO,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE;YACzB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YACpC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAE9B,OAAO;gBACH,MAAM,EAAE,IAAI,GAAG,EAAE;gBACjB,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE;gBAC1B,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;gBACnC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAChF,KAAK,EAAE,CAAC;gBACR,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa;gBACzC,KAAK,EAAE,GAAG,EAAE;oBACR,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa;wBAAE,OAAO;oBACxC,uDAAuD;oBACvD,GAAG,CAAC,KAAK,EAAE,CAAC;oBACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;oBACrD,QAAQ,CAAC,OAAO,GAAG,CAAC,CAAC;oBACrB,QAAQ,CAAC,SAAS,GAAG,CAAC,CAAC;oBACvB,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC;gBACzB,CAAC;gBACD,MAAM,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE;oBACnB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa;wBAAE,OAAO;oBACxC,wDAAwD;oBACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;oBACrD,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;wBACtB,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC;wBAC3B,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC;qBAClC;yBAAM;wBACH,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;wBACpF,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;qBAC/F;oBAED,gCAAgC;oBAChC,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,OAAO,GAAG,IAAI,CAAC;oBACzD,kCAAkC;oBAClC,GAAG,CAAC,OAAO,EAAE,CAAC;oBAEd,kDAAkD;oBAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;wBAC7B,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;wBACvD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;qBACxC;oBACD,oBAAoB;oBACpB,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;oBAC1D,4BAA4B;oBAC5B,GAAG,CAAC,MAAM,EAAE,CAAC;gBACjB,CAAC;aACJ,CAAC;QACN,CAAC,CAAC,CAAC;QAgBC,kCAAkC,CAAC,GAAG,EAAE;YACpC,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,IAAI,CAAC,eAAe,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,kBAAkB,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,eAAe;QACX,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,MAAM,KAAK,QAAQ,CAAC,IAAI,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,KAAK,GAAG,KAAK,EAAE;YAC1F,UAAU,EAAE,CAAC;YACb,GAAG,CAAC,MAAM,EAAE,CAAC;YACb,GAAG,CAAC,KAAK,EAAE,CAAC;SACf;IACL,CAAC;IAED,UAAU;QACN,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;QACxF,MAAM,CAAC,GAAG,EAAE;YACR,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC;YAChC,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,eAAe;QACX,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5B,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE;YACtB,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE;YAC1D,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa;SACnC,CAAC,CAAC,CAAC;QAEJ,MAAM,CAAC,GAAG,EAAE;YACR,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAChC,gCAAgC;YAChC,GAAG,CAAC,KAAK,EAAE,CAAC;YACZ,kBAAkB;YAClB,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,GAAG,CAAC,MAAM,KAAK,QAAQ;gBAAE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxE,CAAC,CAAC,CAAC;IACP,CAAC;8GAhMQ,uBAAuB;kGAAvB,uBAAuB,sTATrB;YACP;gBACI,OAAO,EAAE,6BAA6B;gBACtC,UAAU,EAAE,CAAC,OAAgC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG;gBAC7D,IAAI,EAAE,CAAC,uBAAuB,CAAC;aAClC;SACJ,iDA7BS;;;;;;;;;;;;;;;;;;;;;;KAsBT;;SAUQ,uBAAuB;2FAAvB,uBAAuB;kBAnCnC,SAAS;mBAAC;oBACP,QAAQ,EAAE,2BAA2B;oBACrC,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;KAsBT;oBACD,SAAS,EAAE;wBACP;4BACI,OAAO,EAAE,6BAA6B;4BACtC,UAAU,EAAE,CAAC,OAAgC,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG;4BAC7D,IAAI,EAAE,yBAAyB;yBAClC;qBACJ;oBACD,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACpC;0EAMgB,MAAM;sBAAlB,KAAK;gBAKO,KAAK;sBAAjB,KAAK;gBAKO,KAAK;sBAAjB,KAAK;gBAKO,KAAK;sBAAjB,KAAK;gBAKO,QAAQ;sBAApB,KAAK;gBAKO,OAAO;sBAAnB,KAAK;gBAKO,SAAS;sBAArB,KAAK;gBAKO,KAAK;sBAAjB,KAAK;gBAKO,UAAU;sBAAtB,KAAK;gBAKO,UAAU;sBAAtB,KAAK;gBAKO,UAAU;sBAAtB,KAAK","sourcesContent":["import {\n    CUSTOM_ELEMENTS_SCHEMA,\n    Component,\n    InjectionToken,\n    Input,\n    Signal,\n    computed,\n    effect,\n    inject,\n    untracked,\n} from '@angular/core';\nimport {\n    NgtSignalStore,\n    NgtStore,\n    extend,\n    getLocalState,\n    injectBeforeRender,\n    injectNgtRef,\n    requestAnimationInInjectionContext,\n    type NgtGroup,\n} from 'angular-three';\nimport { SoftShadowMaterial, SoftShadowMaterialInputs } from 'angular-three-soba/shaders';\nimport { Group, Mesh, PlaneGeometry } from 'three';\nimport { ProgressiveLightMap } from './progressive-light-map';\n\nextend({ SoftShadowMaterial, Group, Mesh, PlaneGeometry });\n\nexport interface NgtsAccumulativeShadowsState {\n    /** How many frames it can render, more yields cleaner results but takes more time, 40 */\n    frames: number;\n    /** If frames === Infinity blend controls the refresh ratio, 100 */\n    blend: number;\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    limit: number;\n    /** Scale of the plane,  */\n    scale: number;\n    /** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */\n    temporal: boolean;\n    /** Opacity of the plane, 1 */\n    opacity: number;\n    /** Discards alpha pixels, 0.65 */\n    alphaTest: number;\n    /** Shadow color, black */\n    color: string;\n    /** Colorblend, how much colors turn to black, 0 is black, 2 */\n    colorBlend: number;\n    /** Buffer resolution, 1024 */\n    resolution: number;\n    /** Texture tonemapping */\n    toneMapped: boolean;\n}\n\nexport type NgtsAccumulativeShadowsLightApi = { update: () => void };\n\nexport interface NgtsAccumulativeShadowsApi {\n    lights: Map<string, Signal<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<Signal<NgtsAccumulativeShadowsApi>>(\n    'NgtsAccumulativeShadows API'\n);\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-accumulative-shadows': NgtGroup & NgtsAccumulativeShadowsState;\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            </ngt-group>\n            <ngt-mesh\n                [ref]=\"meshRef\"\n                [receiveShadow]=\"true\"\n                [scale]=\"accumulativeShadowsScale()\"\n                [rotation]=\"[-Math.PI / 2, 0, 0]\"\n            >\n                <ngt-plane-geometry />\n                <ngt-soft-shadow-material\n                    [transparent]=\"true\"\n                    [depthWrite]=\"false\"\n                    [toneMapped]=\"accumulativeShadowsToneMapped()\"\n                    [color]=\"accumulativeShadowsColor()\"\n                    [blend]=\"accumulativeShadowsColorBlend()\"\n                    [map]=\"pLM().progressiveLightMap2.texture\"\n                />\n            </ngt-mesh>\n        </ngt-group>\n    `,\n    providers: [\n        {\n            provide: NGTS_ACCUMULATIVE_SHADOWS_API,\n            useFactory: (shadows: NgtsAccumulativeShadows) => shadows.api,\n            deps: [NgtsAccumulativeShadows],\n        },\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsAccumulativeShadows extends NgtSignalStore<NgtsAccumulativeShadowsState> {\n    readonly nullTraverse = () => null;\n    readonly Math = Math;\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    readonly #store = inject(NgtStore);\n    readonly #gl = this.#store.select('gl');\n    readonly #scene = this.#store.select('scene');\n    readonly #camera = this.#store.select('camera');\n\n    readonly #resolution = this.select('resolution');\n    readonly #temporal = this.select('temporal');\n    readonly #blend = this.select('blend');\n    readonly #frames = this.select('frames');\n    readonly #opacity = this.select('opacity');\n    readonly #alphaTest = this.select('alphaTest');\n\n    readonly accumulativeShadowsScale = this.select('scale');\n    readonly accumulativeShadowsToneMapped = this.select('toneMapped');\n    readonly accumulativeShadowsColor = this.select('color');\n    readonly accumulativeShadowsColorBlend = this.select('colorBlend');\n\n    readonly meshRef = injectNgtRef<THREE.Mesh<THREE.PlaneGeometry, SoftShadowMaterialInputs & THREE.ShaderMaterial>>();\n    readonly accumulativeShadowsRef = injectNgtRef<THREE.Group>();\n\n    readonly pLM = computed(\n        () => new ProgressiveLightMap(untracked(this.#gl), untracked(this.#scene), this.#resolution())\n    );\n\n    readonly api = computed(() => {\n        const pLM = this.pLM();\n        const alphaTest = this.#alphaTest();\n        const opacity = this.#opacity();\n        const camera = this.#camera();\n\n        return {\n            lights: new Map(),\n            temporal: this.#temporal(),\n            frames: Math.max(2, this.#frames()),\n            blend: Math.max(2, this.#frames() === Infinity ? this.#blend() : this.#frames()),\n            count: 0,\n            getMesh: () => this.meshRef.nativeElement,\n            reset: () => {\n                if (!this.meshRef.nativeElement) return;\n                // Clear buffers, reset opacities, set frame count to 0\n                pLM.clear();\n                const material = this.meshRef.nativeElement.material;\n                material.opacity = 0;\n                material.alphaTest = 0;\n                this.api().count = 0;\n            },\n            update: (frames = 1) => {\n                if (!this.meshRef.nativeElement) return;\n                // Adapt the opacity-blend ratio to the number of frames\n                const material = this.meshRef.nativeElement.material;\n                if (!this.api().temporal) {\n                    material.opacity = opacity;\n                    material.alphaTest = alphaTest;\n                } else {\n                    material.opacity = Math.min(opacity, material.opacity + opacity / this.api().blend);\n                    material.alphaTest = Math.min(alphaTest, material.alphaTest + alphaTest / this.api().blend);\n                }\n\n                // Switch accumulative lights on\n                this.accumulativeShadowsRef.nativeElement.visible = true;\n                // Collect scene lights and meshes\n                pLM.prepare();\n\n                // Update the lightmap and the accumulative lights\n                for (let i = 0; i < frames; i++) {\n                    this.api().lights.forEach((light) => light().update());\n                    pLM.update(camera, this.api().blend);\n                }\n                // Switch lights off\n                this.accumulativeShadowsRef.nativeElement.visible = false;\n                // Restore lights and meshes\n                pLM.finish();\n            },\n        };\n    });\n\n    constructor() {\n        super({\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            temporal: false,\n        });\n        requestAnimationInInjectionContext(() => {\n            this.#configure();\n            this.#resetAndUpdate();\n        });\n        injectBeforeRender(this.#onBeforeRender.bind(this));\n    }\n\n    #onBeforeRender() {\n        const invalidate = this.#store.get('invalidate');\n        const limit = this.get('limit');\n        const api = this.api();\n        if ((api.temporal || api.frames === Infinity) && api.count < api.frames && api.count < limit) {\n            invalidate();\n            api.update();\n            api.count++;\n        }\n    }\n\n    #configure() {\n        const trigger = computed(() => ({ pLM: this.pLM(), mesh: this.meshRef.nativeElement }));\n        effect(() => {\n            const { pLM, mesh } = trigger();\n            if (!mesh) return;\n            pLM.configure(mesh);\n        });\n    }\n\n    #resetAndUpdate() {\n        const trigger = computed(() => ({\n            state: this.select()(),\n            objects: getLocalState(this.#store.get('scene')).objects(),\n            mesh: this.meshRef.nativeElement,\n        }));\n\n        effect(() => {\n            const { mesh } = trigger();\n            if (!mesh) return;\n            const api = untracked(this.api);\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"]}

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    return object.isLight;\n}\n\nfunction isGeometry(object: any): object is THREE.Mesh {\n    return !!object.geometry;\n}\n\n// Based on \"Progressive Light Map Accumulator\", by [zalo](https://github.com/zalo/)\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        });\n        this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, {\n            type: format,\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            // 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: THREE.Mesh) {\n        this.object = object;\n    }\n\n    update(camera: THREE.Camera, 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"]}