angular-three 0.0.2 → 0.0.3

package/esm2020/lib/utils/loop.mjs

@@ -0,0 +1,139 @@
+import { is } from './is';
+function createSubs(callback, subs) {
+    const sub = { callback };
+    subs.add(sub);
+    return () => void subs.delete(sub);
+}
+const globalEffects = new Set();
+const globalAfterEffects = new Set();
+const globalTailEffects = new Set();
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export const addEffect = (callback) => createSubs(callback, globalEffects);
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export const addAfterEffect = (callback) => createSubs(callback, globalAfterEffects);
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+export const addTail = (callback) => createSubs(callback, globalTailEffects);
+function run(effects, timestamp) {
+    if (!effects.size)
+        return;
+    for (const { callback } of effects.values()) {
+        callback(timestamp);
+    }
+}
+export function flushGlobalEffects(type, timestamp) {
+    switch (type) {
+        case 'before':
+            return run(globalEffects, timestamp);
+        case 'after':
+            return run(globalAfterEffects, timestamp);
+        case 'tail':
+            return run(globalTailEffects, timestamp);
+    }
+}
+function render(timestamp, stateFactory, frame) {
+    const state = stateFactory();
+    // Run local effects
+    let delta = state.clock.getDelta();
+    // In frameloop='never' mode, clock times are updated using the provided timestamp
+    if (state.frameloop === 'never' && typeof timestamp === 'number') {
+        delta = timestamp - state.clock.elapsedTime;
+        state.clock.oldTime = state.clock.elapsedTime;
+        state.clock.elapsedTime = timestamp;
+    }
+    // Call subscribers (useFrame)
+    // subscribers = state.internal.subscribers;
+    for (let i = 0; i < state.internal.subscribers.length; i++) {
+        const subscriber = state.internal.subscribers[i];
+        const object = is.ref(subscriber.obj) ? subscriber.obj.value : subscriber.obj;
+        subscriber.callback({ ...state, delta, frame }, object);
+    }
+    // Render content
+    if (!state.internal.priority && state.gl.render)
+        state.gl.render(state.scene, state.camera);
+    // Decrease frame count
+    state.internal.frames = Math.max(0, state.internal.frames - 1);
+    return state.frameloop === 'always' ? 1 : state.internal.frames;
+}
+export function createLoop(roots) {
+    let running = false;
+    let repeat;
+    let frame;
+    let state;
+    function loop(timestamp) {
+        frame = requestAnimationFrame(loop);
+        running = true;
+        repeat = 0;
+        // Run effects
+        flushGlobalEffects('before', timestamp);
+        // Render all roots
+        for (const root of roots.values()) {
+            state = root();
+            // If the frameloop is invalidated, do not run another frame
+            if (state.internal.active &&
+                (state.frameloop === 'always' || state.internal.frames > 0) &&
+                !state.gl.xr?.isPresenting) {
+                repeat += render(timestamp, root);
+            }
+        }
+        // Run after-effects
+        flushGlobalEffects('after', timestamp);
+        // Stop the loop if nothing invalidates it
+        if (repeat === 0) {
+            // Tail call effects, they are called when rendering stops
+            flushGlobalEffects('tail', timestamp);
+            // Flag end of operation
+            running = false;
+            return cancelAnimationFrame(frame);
+        }
+    }
+    function invalidate(stateFactory, frames = 1) {
+        const stateToInvalidate = stateFactory?.();
+        if (!stateToInvalidate)
+            return roots.forEach((root) => invalidate(root, frames));
+        if (stateToInvalidate.gl.xr?.isPresenting ||
+            !stateToInvalidate.internal.active ||
+            stateToInvalidate.frameloop === 'never')
+            return;
+        // Increase frames, do not go higher than 60
+        stateToInvalidate.internal.frames = Math.min(60, stateToInvalidate.internal.frames + frames);
+        // If the render-loop isn't active, start it
+        if (!running) {
+            running = true;
+            requestAnimationFrame(loop);
+        }
+    }
+    function advance(timestamp, runGlobalEffects = true, stateFactory, frame) {
+        if (runGlobalEffects)
+            flushGlobalEffects('before', timestamp);
+        if (!stateFactory)
+            for (const root of roots.values())
+                render(timestamp, root);
+        else
+            render(timestamp, stateFactory, frame);
+        if (runGlobalEffects)
+            flushGlobalEffects('after', timestamp);
+    }
+    return {
+        loop,
+        /**
+         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+         */
+        invalidate,
+        /**
+         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+         */
+        advance,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loop.js","sourceRoot":"","sources":["../../../../../../packages/angular-three/src/lib/utils/loop.ts"],"names":[],"mappings":"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","sourcesContent":["import type { NgtState, NgtStateFactory } from '../types';\nimport { is } from './is';\n\nexport type NgtGlobalRenderCallback = (timeStamp: number) => void;\ntype NgtSubItem = { callback: NgtGlobalRenderCallback };\n\nfunction createSubs(callback: NgtGlobalRenderCallback, subs: Set<NgtSubItem>): () => void {\n    const sub = { callback };\n    subs.add(sub);\n    return () => void subs.delete(sub);\n}\n\nconst globalEffects: Set<NgtSubItem> = new Set();\nconst globalAfterEffects: Set<NgtSubItem> = new Set();\nconst globalTailEffects: Set<NgtSubItem> = new Set();\n\n/**\n * Adds a global render callback which is called each frame.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect\n */\nexport const addEffect = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalEffects);\n\n/**\n * Adds a global after-render callback which is called each frame.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect\n */\nexport const addAfterEffect = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalAfterEffects);\n\n/**\n * Adds a global callback which is called when rendering stops.\n * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail\n */\nexport const addTail = (callback: NgtGlobalRenderCallback) => createSubs(callback, globalTailEffects);\n\nfunction run(effects: Set<NgtSubItem>, timestamp: number) {\n    if (!effects.size) return;\n    for (const { callback } of effects.values()) {\n        callback(timestamp);\n    }\n}\n\nexport type GlobalEffectType = 'before' | 'after' | 'tail';\n\nexport function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void {\n    switch (type) {\n        case 'before':\n            return run(globalEffects, timestamp);\n        case 'after':\n            return run(globalAfterEffects, timestamp);\n        case 'tail':\n            return run(globalTailEffects, timestamp);\n    }\n}\n\nfunction render(timestamp: number, stateFactory: NgtStateFactory, frame?: XRFrame) {\n    const state = stateFactory();\n    // Run local effects\n    let delta = state.clock.getDelta();\n    // In frameloop='never' mode, clock times are updated using the provided timestamp\n    if (state.frameloop === 'never' && typeof timestamp === 'number') {\n        delta = timestamp - state.clock.elapsedTime;\n        state.clock.oldTime = state.clock.elapsedTime;\n        state.clock.elapsedTime = timestamp;\n    }\n    // Call subscribers (useFrame)\n    // subscribers = state.internal.subscribers;\n    for (let i = 0; i < state.internal.subscribers.length; i++) {\n        const subscriber = state.internal.subscribers[i];\n        const object = is.ref(subscriber.obj) ? subscriber.obj.value : subscriber.obj;\n        subscriber.callback({ ...state, delta, frame }, object);\n    }\n    // Render content\n    if (!state.internal.priority && state.gl.render) state.gl.render(state.scene, state.camera);\n    // Decrease frame count\n    state.internal.frames = Math.max(0, state.internal.frames - 1);\n    return state.frameloop === 'always' ? 1 : state.internal.frames;\n}\n\nexport function createLoop<TCanvas>(roots: Map<TCanvas, NgtStateFactory>) {\n    let running = false;\n    let repeat: number;\n    let frame: number;\n    let state: NgtState;\n\n    function loop(timestamp: number): void {\n        frame = requestAnimationFrame(loop);\n        running = true;\n        repeat = 0;\n\n        // Run effects\n        flushGlobalEffects('before', timestamp);\n\n        // Render all roots\n        for (const root of roots.values()) {\n            state = root();\n            // If the frameloop is invalidated, do not run another frame\n            if (\n                state.internal.active &&\n                (state.frameloop === 'always' || state.internal.frames > 0) &&\n                !state.gl.xr?.isPresenting\n            ) {\n                repeat += render(timestamp, root);\n            }\n        }\n\n        // Run after-effects\n        flushGlobalEffects('after', timestamp);\n\n        // Stop the loop if nothing invalidates it\n        if (repeat === 0) {\n            // Tail call effects, they are called when rendering stops\n            flushGlobalEffects('tail', timestamp);\n\n            // Flag end of operation\n            running = false;\n            return cancelAnimationFrame(frame);\n        }\n    }\n\n    function invalidate(stateFactory?: NgtStateFactory, frames = 1): void {\n        const stateToInvalidate = stateFactory?.();\n        if (!stateToInvalidate) return roots.forEach((root) => invalidate(root, frames));\n        if (\n            stateToInvalidate.gl.xr?.isPresenting ||\n            !stateToInvalidate.internal.active ||\n            stateToInvalidate.frameloop === 'never'\n        )\n            return;\n        // Increase frames, do not go higher than 60\n        stateToInvalidate.internal.frames = Math.min(60, stateToInvalidate.internal.frames + frames);\n        // If the render-loop isn't active, start it\n        if (!running) {\n            running = true;\n            requestAnimationFrame(loop);\n        }\n    }\n\n    function advance(\n        timestamp: number,\n        runGlobalEffects: boolean = true,\n        stateFactory?: NgtStateFactory,\n        frame?: XRFrame\n    ): void {\n        if (runGlobalEffects) flushGlobalEffects('before', timestamp);\n        if (!stateFactory) for (const root of roots.values()) render(timestamp, root);\n        else render(timestamp, stateFactory, frame);\n        if (runGlobalEffects) flushGlobalEffects('after', timestamp);\n    }\n\n    return {\n        loop,\n        /**\n         * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.\n         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate\n         */\n        invalidate,\n        /**\n         * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop=\"never\"`.\n         * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance\n         */\n        advance,\n    };\n}\n"]}

package/esm2020/lib/utils/make.mjs

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+const idCache = {};
+export function makeId(event) {
+    if (event) {
+        return (event.eventObject || event.object).uuid + '/' + event.index + event.instanceId;
+    }
+    const newId = THREE.MathUtils.generateUUID();
+    // ensure not already used
+    if (!idCache[newId]) {
+        idCache[newId] = true;
+        return newId;
+    }
+    return makeId();
+}
+export function makeDpr(dpr, window) {
+    const target = window?.devicePixelRatio || 1;
+    return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr;
+}
+export function make(type, input) {
+    if (!input)
+        return new type();
+    if (input instanceof type) {
+        return input;
+    }
+    if (!Array.isArray(input)) {
+        input = typeof input === 'number' ? [input, input, input, input] : [input];
+    }
+    return new type(...input);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/mutate.mjs

@@ -0,0 +1,24 @@
+import { applyProps } from './apply-props';
+export function mutate(object, value, paths = []) {
+    const [base, ...remaining] = paths;
+    if (!base)
+        return;
+    if (remaining.length === 0) {
+        applyProps(object, { [base]: value });
+    }
+    else {
+        // assign an empty object in order to spread object if undefined
+        assignEmpty(object, base);
+        // recursion
+        mutate(object[base], value, remaining);
+    }
+}
+function assignEmpty(obj, base) {
+    if (
+    // @ts-ignore
+    (!Object.hasOwn(obj, base) && Reflect && !!Reflect.has && !Reflect.has(obj, base)) ||
+        obj[base] === undefined) {
+        obj[base] = {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/proxy.mjs

@@ -0,0 +1,99 @@
+import { inject, NgZone } from '@angular/core';
+import { isObservable } from 'rxjs';
+import { injectInstance, injectInstanceRef, NGT_PROXY_INSTANCE } from '../instance';
+import { tapEffect } from '../stores/component-store';
+import { NgtStore } from '../stores/store';
+import { applyProps } from './apply-props';
+import { capitalize } from './capitalize';
+import { prepare } from './instance';
+export function proxify(instance, proxifyOptions = {}) {
+    const ngtInstance = injectInstance({ host: true });
+    const store = inject(NgtStore);
+    const zone = inject(NgZone);
+    const parentInstance = injectInstanceRef({ skipSelf: true, optional: true });
+    return zone.runOutsideAngular(() => {
+        // prep the instance w/ local state
+        instance = prepare(instance, store.read, store.rootStateFactory, parentInstance?.(), ngtInstance.instanceValue ? ngtInstance.instanceRef : undefined, !!proxifyOptions.primitive);
+        let storeReadySubscription;
+        const newValueSubscriptionMap = new Map();
+        function setProp(obj, prop, newValue) {
+            const capitalizedProp = `set${capitalize(prop)}`;
+            if (isObservable(newValue)) {
+                const sub = newValue.subscribe((val) => {
+                    if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {
+                        obj[capitalizedProp](val);
+                    }
+                    else {
+                        applyProps(obj, { [prop]: val });
+                    }
+                    ngtInstance.write({ [prop]: val });
+                });
+                return () => sub.unsubscribe();
+            }
+            if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {
+                obj[capitalizedProp](newValue);
+            }
+            else {
+                applyProps(obj, { [prop]: newValue });
+            }
+            ngtInstance.write({ [prop]: newValue });
+            return;
+        }
+        const handler = {
+            get(target, p, receiver) {
+                if (p === 'instanceRef')
+                    return ngtInstance.instanceRef;
+                if (p === 'instance')
+                    return ngtInstance;
+                if (p === NGT_PROXY_INSTANCE)
+                    return target;
+                const capitalizedProp = `get${capitalize(p)}`;
+                if (target[capitalizedProp] && typeof target[capitalizedProp] === 'function') {
+                    return target[capitalizedProp]();
+                }
+                return Reflect.get(target, p, receiver);
+            },
+            set(target, p, newValue, receiver) {
+                const prop = p;
+                if (storeReadySubscription)
+                    storeReadySubscription.unsubscribe();
+                if (newValueSubscriptionMap.has(prop))
+                    newValueSubscriptionMap.get(prop)();
+                // Angular sets this property
+                if (p === '__ngContext__')
+                    return Reflect.set(target, p, newValue, receiver);
+                return zone.runOutsideAngular(() => {
+                    // TODO: figure out what else we need to handle
+                    // we should handle if newValue is an Observable as well
+                    if (store.read((s) => s.ready)) {
+                        const cleanUp = setProp(instance, prop, newValue);
+                        if (cleanUp)
+                            newValueSubscriptionMap.set(prop, cleanUp);
+                    }
+                    else {
+                        storeReadySubscription = store.onReady(() => setProp(instance, prop, newValue));
+                    }
+                    // schedule updateCallback on next event loop
+                    queueMicrotask(() => {
+                        if (ngtInstance.updateCallback)
+                            ngtInstance.updateCallback(instance);
+                    });
+                    return true;
+                });
+            },
+        };
+        ngtInstance.effect(tapEffect(() => () => {
+            if (storeReadySubscription)
+                storeReadySubscription.unsubscribe();
+            newValueSubscriptionMap.forEach((cleanUp) => cleanUp());
+        }))();
+        const proxied = new Proxy(instance, handler);
+        if (proxifyOptions.attach)
+            ngtInstance.attach = proxifyOptions.attach;
+        if (proxifyOptions.created)
+            proxifyOptions.created(proxied, store.read, ngtInstance);
+        ngtInstance.instanceRef.set(proxied);
+        return proxied;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../../../../packages/angular-three/src/lib/utils/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, NgZone } from '@angular/core';\nimport { isObservable, Subscription } from 'rxjs';\nimport { injectInstance, injectInstanceRef, NGT_PROXY_INSTANCE, NgtInstance } from '../instance';\nimport { tapEffect } from '../stores/component-store';\nimport { NgtStore } from '../stores/store';\nimport { NgtAnyFunction, NgtAttachFunction, NgtStateFactory } from '../types';\nimport { applyProps } from './apply-props';\nimport { capitalize } from './capitalize';\nimport { prepare } from './instance';\n\nexport function proxify<T extends object>(\n    instance: T,\n    proxifyOptions: {\n        attach?: string | string[] | NgtAttachFunction<T>;\n        created?: (instance: T, stateFactory: NgtStateFactory, ngtInstance: NgtInstance) => void;\n        primitive?: boolean;\n    } = {}\n): T {\n    const ngtInstance = injectInstance<T>({ host: true });\n    const store = inject(NgtStore);\n    const zone = inject(NgZone);\n    const parentInstance = injectInstanceRef({ skipSelf: true, optional: true });\n\n    return zone.runOutsideAngular(() => {\n        // prep the instance w/ local state\n        instance = prepare(\n            instance,\n            store.read,\n            store.rootStateFactory,\n            parentInstance?.(),\n            ngtInstance.instanceValue ? ngtInstance.instanceRef : undefined,\n            !!proxifyOptions.primitive\n        );\n\n        let storeReadySubscription: Subscription;\n        const newValueSubscriptionMap = new Map<string, () => void>();\n\n        function setProp(obj: T, prop: string, newValue: any): (() => void) | undefined {\n            const capitalizedProp = `set${capitalize(prop)}` as keyof T;\n\n            if (isObservable(newValue)) {\n                const sub = newValue.subscribe((val) => {\n                    if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {\n                        (obj[capitalizedProp] as NgtAnyFunction)(val);\n                    } else {\n                        applyProps(obj, { [prop]: val });\n                    }\n\n                    ngtInstance.write({ [prop]: val });\n                });\n                return () => sub.unsubscribe();\n            }\n\n            if (obj[capitalizedProp] && typeof obj[capitalizedProp] === 'function') {\n                (obj[capitalizedProp] as NgtAnyFunction)(newValue);\n            } else {\n                applyProps(obj, { [prop]: newValue });\n            }\n            ngtInstance.write({ [prop]: newValue });\n            return;\n        }\n\n        const handler: ProxyHandler<T> = {\n            get(target: T, p: string | symbol, receiver: any): any {\n                if (p === 'instanceRef') return ngtInstance.instanceRef;\n                if (p === 'instance') return ngtInstance;\n                if (p === NGT_PROXY_INSTANCE) return target;\n\n                const capitalizedProp = `get${capitalize(p as string)}`;\n                if (target[capitalizedProp as keyof T] && typeof target[capitalizedProp as keyof T] === 'function') {\n                    return (target[capitalizedProp as keyof T] as Function)();\n                }\n\n                return Reflect.get(target, p, receiver);\n            },\n            set(target: T, p: string | symbol, newValue: any, receiver: any): boolean {\n                const prop = p as string;\n\n                if (storeReadySubscription) storeReadySubscription.unsubscribe();\n                if (newValueSubscriptionMap.has(prop)) newValueSubscriptionMap.get(prop)!();\n\n                // Angular sets this property\n                if (p === '__ngContext__') return Reflect.set(target, p, newValue, receiver);\n\n                return zone.runOutsideAngular(() => {\n                    // TODO: figure out what else we need to handle\n                    // we should handle if newValue is an Observable as well\n                    if (store.read((s) => s.ready)) {\n                        const cleanUp = setProp(instance, prop, newValue);\n                        if (cleanUp) newValueSubscriptionMap.set(prop, cleanUp);\n                    } else {\n                        storeReadySubscription = store.onReady(() => setProp(instance, prop, newValue));\n                    }\n\n                    // schedule updateCallback on next event loop\n                    queueMicrotask(() => {\n                        if (ngtInstance.updateCallback) ngtInstance.updateCallback(instance);\n                    });\n\n                    return true;\n                });\n            },\n        };\n\n        ngtInstance.effect<void>(\n            tapEffect(() => () => {\n                if (storeReadySubscription) storeReadySubscription.unsubscribe();\n                newValueSubscriptionMap.forEach((cleanUp) => cleanUp());\n            })\n        )();\n\n        const proxied = new Proxy(instance, handler);\n\n        if (proxifyOptions.attach) ngtInstance.attach = proxifyOptions.attach;\n        if (proxifyOptions.created) proxifyOptions.created(proxied, store.read, ngtInstance);\n\n        ngtInstance.instanceRef.set(proxied);\n\n        return proxied;\n    });\n}\n"]}

package/esm2020/lib/utils/renderer.mjs

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+export function createRenderer(glOptions, canvasElement) {
+    const customRenderer = (typeof glOptions === 'function' ? glOptions(canvasElement) : glOptions);
+    if (customRenderer?.render != null) {
+        return customRenderer;
+    }
+    return new THREE.WebGLRenderer({
+        powerPreference: 'high-performance',
+        canvas: canvasElement,
+        antialias: true,
+        alpha: true,
+        ...(glOptions || {}),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVuZGVyZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyLXRocmVlL3NyYy9saWIvdXRpbHMvcmVuZGVyZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFHL0IsTUFBTSxVQUFVLGNBQWMsQ0FBQyxTQUF1QixFQUFFLGFBQWdDO0lBQ3BGLE1BQU0sY0FBYyxHQUFHLENBQ25CLE9BQU8sU0FBUyxLQUFLLFVBQVUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQ2xELENBQUM7SUFFekIsSUFBSSxjQUFjLEVBQUUsTUFBTSxJQUFJLElBQUksRUFBRTtRQUNoQyxPQUFPLGNBQWMsQ0FBQztLQUN6QjtJQUVELE9BQU8sSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDO1FBQzNCLGVBQWUsRUFBRSxrQkFBa0I7UUFDbkMsTUFBTSxFQUFFLGFBQWE7UUFDckIsU0FBUyxFQUFFLElBQUk7UUFDZixLQUFLLEVBQUUsSUFBSTtRQUNYLEdBQUcsQ0FBQyxTQUFTLElBQUksRUFBRSxDQUFDO0tBQ3ZCLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBUSFJFRSBmcm9tICd0aHJlZSc7XG5pbXBvcnQgdHlwZSB7IE5ndEdMT3B0aW9ucyB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVJlbmRlcmVyKGdsT3B0aW9uczogTmd0R0xPcHRpb25zLCBjYW52YXNFbGVtZW50OiBIVE1MQ2FudmFzRWxlbWVudCk6IFRIUkVFLldlYkdMUmVuZGVyZXIge1xuICAgIGNvbnN0IGN1c3RvbVJlbmRlcmVyID0gKFxuICAgICAgICB0eXBlb2YgZ2xPcHRpb25zID09PSAnZnVuY3Rpb24nID8gZ2xPcHRpb25zKGNhbnZhc0VsZW1lbnQpIDogZ2xPcHRpb25zXG4gICAgKSBhcyBUSFJFRS5XZWJHTFJlbmRlcmVyO1xuXG4gICAgaWYgKGN1c3RvbVJlbmRlcmVyPy5yZW5kZXIgIT0gbnVsbCkge1xuICAgICAgICByZXR1cm4gY3VzdG9tUmVuZGVyZXI7XG4gICAgfVxuXG4gICAgcmV0dXJuIG5ldyBUSFJFRS5XZWJHTFJlbmRlcmVyKHtcbiAgICAgICAgcG93ZXJQcmVmZXJlbmNlOiAnaGlnaC1wZXJmb3JtYW5jZScsXG4gICAgICAgIGNhbnZhczogY2FudmFzRWxlbWVudCxcbiAgICAgICAgYW50aWFsaWFzOiB0cnVlLFxuICAgICAgICBhbHBoYTogdHJ1ZSxcbiAgICAgICAgLi4uKGdsT3B0aW9ucyB8fCB7fSksXG4gICAgfSk7XG59XG4iXX0=

package/esm2020/lights/angular-three-lights.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1saWdodHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyLXRocmVlL2xpZ2h0cy9zcmMvYW5ndWxhci10aHJlZS1saWdodHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/lights/index.mjs

@@ -0,0 +1,11 @@
+// GENERATED - AngularThree v1.0.0
+export * from './lib/light-probe/light-probe';
+export * from './lib/ambient-light/ambient-light';
+export * from './lib/ambient-light-probe/ambient-light-probe';
+export * from './lib/hemisphere-light/hemisphere-light';
+export * from './lib/hemisphere-light-probe/hemisphere-light-probe';
+export * from './lib/directional-light/directional-light';
+export * from './lib/point-light/point-light';
+export * from './lib/spot-light/spot-light';
+export * from './lib/rect-area-light/rect-area-light';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyLXRocmVlL2xpZ2h0cy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0NBQWtDO0FBQ2xDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLCtDQUErQyxDQUFDO0FBQzlELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxxREFBcUQsQ0FBQztBQUNwRSxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIC0gQW5ndWxhclRocmVlIHYxLjAuMFxuZXhwb3J0ICogZnJvbSAnLi9saWIvbGlnaHQtcHJvYmUvbGlnaHQtcHJvYmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYW1iaWVudC1saWdodC9hbWJpZW50LWxpZ2h0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2FtYmllbnQtbGlnaHQtcHJvYmUvYW1iaWVudC1saWdodC1wcm9iZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9oZW1pc3BoZXJlLWxpZ2h0L2hlbWlzcGhlcmUtbGlnaHQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaGVtaXNwaGVyZS1saWdodC1wcm9iZS9oZW1pc3BoZXJlLWxpZ2h0LXByb2JlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGlvbmFsLWxpZ2h0L2RpcmVjdGlvbmFsLWxpZ2h0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BvaW50LWxpZ2h0L3BvaW50LWxpZ2h0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Nwb3QtbGlnaHQvc3BvdC1saWdodCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZWN0LWFyZWEtbGlnaHQvcmVjdC1hcmVhLWxpZ2h0JztcbiJdfQ==

package/esm2020/lights/lib/ambient-light/ambient-light.mjs

@@ -0,0 +1,68 @@
+// GENERATED - AngularThree v1.0.0
+import * as THREE from 'three';
+import { Component } from '@angular/core';
+import { injectArgs, NGT_INSTANCE_INPUTS, NGT_INSTANCE_OUTPUTS, NgtInstance, provideInstanceRef, proxify, } from 'angular-three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export class NgtAmbientLight extends THREE.AmbientLight {
+    constructor() {
+        super(...(injectArgs({ optional: true }) || []));
+        return proxify(this);
+    }
+}
+NgtAmbientLight.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtAmbientLight, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtAmbientLight.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtAmbientLight, isStandalone: true, selector: "ngt-ambient-light", inputs: { color: "color", intensity: "intensity", hex: "hex", shadow: "shadow", shadowCameraFov: "shadowCameraFov", shadowCameraLeft: "shadowCameraLeft", shadowCameraRight: "shadowCameraRight", shadowCameraTop: "shadowCameraTop", shadowCameraBottom: "shadowCameraBottom", shadowCameraNear: "shadowCameraNear", shadowCameraFar: "shadowCameraFar", shadowBias: "shadowBias", shadowMapWidth: "shadowMapWidth", shadowMapHeight: "shadowMapHeight", name: "name", position: "position", rotation: "rotation", quaternion: "quaternion", scale: "scale", modelViewMatrix: "modelViewMatrix", normalMatrix: "normalMatrix", matrix: "matrix", matrixWorld: "matrixWorld", matrixAutoUpdate: "matrixAutoUpdate", matrixWorldAutoUpdate: "matrixWorldAutoUpdate", matrixWorldNeedsUpdate: "matrixWorldNeedsUpdate", layers: "layers", visible: "visible", castShadow: "castShadow", receiveShadow: "receiveShadow", frustumCulled: "frustumCulled", renderOrder: "renderOrder", animations: "animations", userData: "userData", customDepthMaterial: "customDepthMaterial", customDistanceMaterial: "customDistanceMaterial", onBeforeRender: "onBeforeRender", onAfterRender: "onAfterRender" }, providers: [provideInstanceRef(NgtAmbientLight)], usesInheritance: true, hostDirectives: [{ directive: i1.NgtInstance }], ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtAmbientLight, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-ambient-light',
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    hostDirectives: [{ directive: NgtInstance, inputs: NGT_INSTANCE_INPUTS, outputs: NGT_INSTANCE_OUTPUTS }],
+                    providers: [provideInstanceRef(NgtAmbientLight)],
+                    inputs: [...getInputs()],
+                }]
+        }], ctorParameters: function () { return []; } });
+function getInputs() {
+    return [
+        'color',
+        'intensity',
+        'hex',
+        'shadow',
+        'shadowCameraFov',
+        'shadowCameraLeft',
+        'shadowCameraRight',
+        'shadowCameraTop',
+        'shadowCameraBottom',
+        'shadowCameraNear',
+        'shadowCameraFar',
+        'shadowBias',
+        'shadowMapWidth',
+        'shadowMapHeight',
+        'name',
+        'position',
+        'rotation',
+        'quaternion',
+        'scale',
+        'modelViewMatrix',
+        'normalMatrix',
+        'matrix',
+        'matrixWorld',
+        'matrixAutoUpdate',
+        'matrixWorldAutoUpdate',
+        'matrixWorldNeedsUpdate',
+        'layers',
+        'visible',
+        'castShadow',
+        'receiveShadow',
+        'frustumCulled',
+        'renderOrder',
+        'animations',
+        'userData',
+        'customDepthMaterial',
+        'customDistanceMaterial',
+        'onBeforeRender',
+        'onAfterRender',
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ambient-light.js","sourceRoot":"","sources":["../../../../../../../packages/angular-three/lights/src/lib/ambient-light/ambient-light.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EACH,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,OAAO,GAOV,MAAM,eAAe,CAAC;;;AAUvB,MAAM,OAAO,eAAgB,SAAQ,KAAK,CAAC,YAAY;IACnD;QACI,KAAK,CAAC,GAAG,CAAC,UAAU,CAA4B,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAC5E,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;;4GAJQ,eAAe;gGAAf,eAAe,osCAHb,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC,kGAFtC,2BAA2B;2FAK5B,eAAe;kBAR3B,SAAS;mBAAC;oBACP,QAAQ,EAAE,mBAAmB;oBAC7B,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,2BAA2B;oBACrC,cAAc,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;oBACxG,SAAS,EAAE,CAAC,kBAAkB,iBAAiB,CAAC;oBAChD,MAAM,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC;iBAC3B;;AAiED,SAAS,SAAS;IACd,OAAO;QACH,OAAO;QACP,WAAW;QACX,KAAK;QACL,QAAQ;QACR,iBAAiB;QACjB,kBAAkB;QAClB,mBAAmB;QACnB,iBAAiB;QACjB,oBAAoB;QACpB,kBAAkB;QAClB,iBAAiB;QACjB,YAAY;QACZ,gBAAgB;QAChB,iBAAiB;QACjB,MAAM;QACN,UAAU;QACV,UAAU;QACV,YAAY;QACZ,OAAO;QACP,iBAAiB;QACjB,cAAc;QACd,QAAQ;QACR,aAAa;QACb,kBAAkB;QAClB,uBAAuB;QACvB,wBAAwB;QACxB,QAAQ;QACR,SAAS;QACT,YAAY;QACZ,eAAe;QACf,eAAe;QACf,aAAa;QACb,YAAY;QACZ,UAAU;QACV,qBAAqB;QACrB,wBAAwB;QACxB,gBAAgB;QAChB,eAAe;KAClB,CAAC;AACN,CAAC","sourcesContent":["// GENERATED - AngularThree v1.0.0\nimport * as THREE from 'three';\nimport { Component } from '@angular/core';\nimport {\n    injectArgs,\n    NGT_INSTANCE_INPUTS,\n    NGT_INSTANCE_OUTPUTS,\n    NgtInstance,\n    provideInstanceRef,\n    proxify,\n    NgtVector3,\n    NgtEuler,\n    NgtQuaternion,\n    NgtMatrix4,\n    NgtLayers,\n    NgtObservableInput,\n} from 'angular-three';\n\n@Component({\n    selector: 'ngt-ambient-light',\n    standalone: true,\n    template: '<ng-content></ng-content>',\n    hostDirectives: [{ directive: NgtInstance, inputs: NGT_INSTANCE_INPUTS, outputs: NGT_INSTANCE_OUTPUTS }],\n    providers: [provideInstanceRef(NgtAmbientLight)],\n    inputs: [...getInputs()],\n})\nexport class NgtAmbientLight extends THREE.AmbientLight {\n    constructor() {\n        super(...(injectArgs<typeof THREE.AmbientLight>({ optional: true }) || []));\n        return proxify(this);\n    }\n\n    static ngAcceptInputType_color: NgtObservableInput<THREE.ColorRepresentation> | undefined;\n    static ngAcceptInputType_intensity: NgtObservableInput<number> | undefined;\n    static ngAcceptInputType_hex: NgtObservableInput<number | string> | undefined;\n    static ngAcceptInputType_shadow: NgtObservableInput<THREE.LightShadow>;\n    static ngAcceptInputType_shadowCameraFov: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraLeft: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraRight: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraTop: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraBottom: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraNear: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraFar: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowBias: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowMapWidth: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowMapHeight: NgtObservableInput<any>;\n    static ngAcceptInputType_name: NgtObservableInput<string>;\n    static ngAcceptInputType_position: NgtObservableInput<NgtVector3>;\n    static ngAcceptInputType_rotation: NgtObservableInput<NgtEuler>;\n    static ngAcceptInputType_quaternion: NgtObservableInput<NgtQuaternion>;\n    static ngAcceptInputType_scale: NgtObservableInput<NgtVector3>;\n    static ngAcceptInputType_modelViewMatrix: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_normalMatrix: NgtObservableInput<THREE.Matrix3>;\n    static ngAcceptInputType_matrix: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_matrixWorld: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_matrixAutoUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_matrixWorldAutoUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_matrixWorldNeedsUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_layers: NgtObservableInput<NgtLayers>;\n    static ngAcceptInputType_visible: NgtObservableInput<boolean>;\n    static ngAcceptInputType_castShadow: NgtObservableInput<boolean>;\n    static ngAcceptInputType_receiveShadow: NgtObservableInput<boolean>;\n    static ngAcceptInputType_frustumCulled: NgtObservableInput<boolean>;\n    static ngAcceptInputType_renderOrder: NgtObservableInput<number>;\n    static ngAcceptInputType_animations: NgtObservableInput<THREE.AnimationClip[]>;\n    static ngAcceptInputType_userData: NgtObservableInput<{ [key: string]: any }>;\n    static ngAcceptInputType_customDepthMaterial: NgtObservableInput<THREE.Material>;\n    static ngAcceptInputType_customDistanceMaterial: NgtObservableInput<THREE.Material>;\n    static ngAcceptInputType_onBeforeRender: NgtObservableInput<\n        (\n            renderer: THREE.WebGLRenderer,\n            scene: THREE.Scene,\n            camera: THREE.Camera,\n            geometry: THREE.BufferGeometry,\n            material: THREE.Material,\n            group: THREE.Group\n        ) => void\n    >;\n    static ngAcceptInputType_onAfterRender: NgtObservableInput<\n        (\n            renderer: THREE.WebGLRenderer,\n            scene: THREE.Scene,\n            camera: THREE.Camera,\n            geometry: THREE.BufferGeometry,\n            material: THREE.Material,\n            group: THREE.Group\n        ) => void\n    >;\n}\n\nfunction getInputs() {\n    return [\n        'color',\n        'intensity',\n        'hex',\n        'shadow',\n        'shadowCameraFov',\n        'shadowCameraLeft',\n        'shadowCameraRight',\n        'shadowCameraTop',\n        'shadowCameraBottom',\n        'shadowCameraNear',\n        'shadowCameraFar',\n        'shadowBias',\n        'shadowMapWidth',\n        'shadowMapHeight',\n        'name',\n        'position',\n        'rotation',\n        'quaternion',\n        'scale',\n        'modelViewMatrix',\n        'normalMatrix',\n        'matrix',\n        'matrixWorld',\n        'matrixAutoUpdate',\n        'matrixWorldAutoUpdate',\n        'matrixWorldNeedsUpdate',\n        'layers',\n        'visible',\n        'castShadow',\n        'receiveShadow',\n        'frustumCulled',\n        'renderOrder',\n        'animations',\n        'userData',\n        'customDepthMaterial',\n        'customDistanceMaterial',\n        'onBeforeRender',\n        'onAfterRender',\n    ];\n}\n"]}

package/esm2020/lights/lib/ambient-light-probe/ambient-light-probe.mjs

@@ -0,0 +1,69 @@
+// GENERATED - AngularThree v1.0.0
+import * as THREE from 'three';
+import { Component } from '@angular/core';
+import { injectArgs, NGT_INSTANCE_INPUTS, NGT_INSTANCE_OUTPUTS, NgtInstance, provideInstanceRef, proxify, } from 'angular-three';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-three";
+export class NgtAmbientLightProbe extends THREE.AmbientLightProbe {
+    constructor() {
+        super(...(injectArgs({ optional: true }) || []));
+        return proxify(this);
+    }
+}
+NgtAmbientLightProbe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtAmbientLightProbe, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtAmbientLightProbe.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.0", type: NgtAmbientLightProbe, isStandalone: true, selector: "ngt-ambient-light-probe", inputs: { color: "color", intensity: "intensity", sh: "sh", hex: "hex", shadow: "shadow", shadowCameraFov: "shadowCameraFov", shadowCameraLeft: "shadowCameraLeft", shadowCameraRight: "shadowCameraRight", shadowCameraTop: "shadowCameraTop", shadowCameraBottom: "shadowCameraBottom", shadowCameraNear: "shadowCameraNear", shadowCameraFar: "shadowCameraFar", shadowBias: "shadowBias", shadowMapWidth: "shadowMapWidth", shadowMapHeight: "shadowMapHeight", name: "name", position: "position", rotation: "rotation", quaternion: "quaternion", scale: "scale", modelViewMatrix: "modelViewMatrix", normalMatrix: "normalMatrix", matrix: "matrix", matrixWorld: "matrixWorld", matrixAutoUpdate: "matrixAutoUpdate", matrixWorldAutoUpdate: "matrixWorldAutoUpdate", matrixWorldNeedsUpdate: "matrixWorldNeedsUpdate", layers: "layers", visible: "visible", castShadow: "castShadow", receiveShadow: "receiveShadow", frustumCulled: "frustumCulled", renderOrder: "renderOrder", animations: "animations", userData: "userData", customDepthMaterial: "customDepthMaterial", customDistanceMaterial: "customDistanceMaterial", onBeforeRender: "onBeforeRender", onAfterRender: "onAfterRender" }, providers: [provideInstanceRef(NgtAmbientLightProbe)], usesInheritance: true, hostDirectives: [{ directive: i1.NgtInstance }], ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.0", ngImport: i0, type: NgtAmbientLightProbe, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-ambient-light-probe',
+                    standalone: true,
+                    template: '<ng-content></ng-content>',
+                    hostDirectives: [{ directive: NgtInstance, inputs: NGT_INSTANCE_INPUTS, outputs: NGT_INSTANCE_OUTPUTS }],
+                    providers: [provideInstanceRef(NgtAmbientLightProbe)],
+                    inputs: [...getInputs()],
+                }]
+        }], ctorParameters: function () { return []; } });
+function getInputs() {
+    return [
+        'color',
+        'intensity',
+        'sh',
+        'hex',
+        'shadow',
+        'shadowCameraFov',
+        'shadowCameraLeft',
+        'shadowCameraRight',
+        'shadowCameraTop',
+        'shadowCameraBottom',
+        'shadowCameraNear',
+        'shadowCameraFar',
+        'shadowBias',
+        'shadowMapWidth',
+        'shadowMapHeight',
+        'name',
+        'position',
+        'rotation',
+        'quaternion',
+        'scale',
+        'modelViewMatrix',
+        'normalMatrix',
+        'matrix',
+        'matrixWorld',
+        'matrixAutoUpdate',
+        'matrixWorldAutoUpdate',
+        'matrixWorldNeedsUpdate',
+        'layers',
+        'visible',
+        'castShadow',
+        'receiveShadow',
+        'frustumCulled',
+        'renderOrder',
+        'animations',
+        'userData',
+        'customDepthMaterial',
+        'customDistanceMaterial',
+        'onBeforeRender',
+        'onAfterRender',
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ambient-light-probe.js","sourceRoot":"","sources":["../../../../../../../packages/angular-three/lights/src/lib/ambient-light-probe/ambient-light-probe.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EACH,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,OAAO,GAOV,MAAM,eAAe,CAAC;;;AAUvB,MAAM,OAAO,oBAAqB,SAAQ,KAAK,CAAC,iBAAiB;IAC7D;QACI,KAAK,CAAC,GAAG,CAAC,UAAU,CAAiC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QACjF,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;;iHAJQ,oBAAoB;qGAApB,oBAAoB,otCAHlB,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,CAAC,kGAF3C,2BAA2B;2FAK5B,oBAAoB;kBARhC,SAAS;mBAAC;oBACP,QAAQ,EAAE,yBAAyB;oBACnC,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,2BAA2B;oBACrC,cAAc,EAAE,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;oBACxG,SAAS,EAAE,CAAC,kBAAkB,sBAAsB,CAAC;oBACrD,MAAM,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC;iBAC3B;;AAkED,SAAS,SAAS;IACd,OAAO;QACH,OAAO;QACP,WAAW;QACX,IAAI;QACJ,KAAK;QACL,QAAQ;QACR,iBAAiB;QACjB,kBAAkB;QAClB,mBAAmB;QACnB,iBAAiB;QACjB,oBAAoB;QACpB,kBAAkB;QAClB,iBAAiB;QACjB,YAAY;QACZ,gBAAgB;QAChB,iBAAiB;QACjB,MAAM;QACN,UAAU;QACV,UAAU;QACV,YAAY;QACZ,OAAO;QACP,iBAAiB;QACjB,cAAc;QACd,QAAQ;QACR,aAAa;QACb,kBAAkB;QAClB,uBAAuB;QACvB,wBAAwB;QACxB,QAAQ;QACR,SAAS;QACT,YAAY;QACZ,eAAe;QACf,eAAe;QACf,aAAa;QACb,YAAY;QACZ,UAAU;QACV,qBAAqB;QACrB,wBAAwB;QACxB,gBAAgB;QAChB,eAAe;KAClB,CAAC;AACN,CAAC","sourcesContent":["// GENERATED - AngularThree v1.0.0\nimport * as THREE from 'three';\nimport { Component } from '@angular/core';\nimport {\n    injectArgs,\n    NGT_INSTANCE_INPUTS,\n    NGT_INSTANCE_OUTPUTS,\n    NgtInstance,\n    provideInstanceRef,\n    proxify,\n    NgtVector3,\n    NgtEuler,\n    NgtQuaternion,\n    NgtMatrix4,\n    NgtLayers,\n    NgtObservableInput,\n} from 'angular-three';\n\n@Component({\n    selector: 'ngt-ambient-light-probe',\n    standalone: true,\n    template: '<ng-content></ng-content>',\n    hostDirectives: [{ directive: NgtInstance, inputs: NGT_INSTANCE_INPUTS, outputs: NGT_INSTANCE_OUTPUTS }],\n    providers: [provideInstanceRef(NgtAmbientLightProbe)],\n    inputs: [...getInputs()],\n})\nexport class NgtAmbientLightProbe extends THREE.AmbientLightProbe {\n    constructor() {\n        super(...(injectArgs<typeof THREE.AmbientLightProbe>({ optional: true }) || []));\n        return proxify(this);\n    }\n\n    static ngAcceptInputType_color: NgtObservableInput<THREE.ColorRepresentation> | undefined;\n    static ngAcceptInputType_intensity: NgtObservableInput<number> | undefined;\n    static ngAcceptInputType_sh: NgtObservableInput<THREE.SphericalHarmonics3>;\n    static ngAcceptInputType_hex: NgtObservableInput<number | string> | undefined;\n    static ngAcceptInputType_shadow: NgtObservableInput<THREE.LightShadow>;\n    static ngAcceptInputType_shadowCameraFov: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraLeft: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraRight: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraTop: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraBottom: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraNear: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowCameraFar: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowBias: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowMapWidth: NgtObservableInput<any>;\n    static ngAcceptInputType_shadowMapHeight: NgtObservableInput<any>;\n    static ngAcceptInputType_name: NgtObservableInput<string>;\n    static ngAcceptInputType_position: NgtObservableInput<NgtVector3>;\n    static ngAcceptInputType_rotation: NgtObservableInput<NgtEuler>;\n    static ngAcceptInputType_quaternion: NgtObservableInput<NgtQuaternion>;\n    static ngAcceptInputType_scale: NgtObservableInput<NgtVector3>;\n    static ngAcceptInputType_modelViewMatrix: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_normalMatrix: NgtObservableInput<THREE.Matrix3>;\n    static ngAcceptInputType_matrix: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_matrixWorld: NgtObservableInput<NgtMatrix4>;\n    static ngAcceptInputType_matrixAutoUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_matrixWorldAutoUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_matrixWorldNeedsUpdate: NgtObservableInput<boolean>;\n    static ngAcceptInputType_layers: NgtObservableInput<NgtLayers>;\n    static ngAcceptInputType_visible: NgtObservableInput<boolean>;\n    static ngAcceptInputType_castShadow: NgtObservableInput<boolean>;\n    static ngAcceptInputType_receiveShadow: NgtObservableInput<boolean>;\n    static ngAcceptInputType_frustumCulled: NgtObservableInput<boolean>;\n    static ngAcceptInputType_renderOrder: NgtObservableInput<number>;\n    static ngAcceptInputType_animations: NgtObservableInput<THREE.AnimationClip[]>;\n    static ngAcceptInputType_userData: NgtObservableInput<{ [key: string]: any }>;\n    static ngAcceptInputType_customDepthMaterial: NgtObservableInput<THREE.Material>;\n    static ngAcceptInputType_customDistanceMaterial: NgtObservableInput<THREE.Material>;\n    static ngAcceptInputType_onBeforeRender: NgtObservableInput<\n        (\n            renderer: THREE.WebGLRenderer,\n            scene: THREE.Scene,\n            camera: THREE.Camera,\n            geometry: THREE.BufferGeometry,\n            material: THREE.Material,\n            group: THREE.Group\n        ) => void\n    >;\n    static ngAcceptInputType_onAfterRender: NgtObservableInput<\n        (\n            renderer: THREE.WebGLRenderer,\n            scene: THREE.Scene,\n            camera: THREE.Camera,\n            geometry: THREE.BufferGeometry,\n            material: THREE.Material,\n            group: THREE.Group\n        ) => void\n    >;\n}\n\nfunction getInputs() {\n    return [\n        'color',\n        'intensity',\n        'sh',\n        'hex',\n        'shadow',\n        'shadowCameraFov',\n        'shadowCameraLeft',\n        'shadowCameraRight',\n        'shadowCameraTop',\n        'shadowCameraBottom',\n        'shadowCameraNear',\n        'shadowCameraFar',\n        'shadowBias',\n        'shadowMapWidth',\n        'shadowMapHeight',\n        'name',\n        'position',\n        'rotation',\n        'quaternion',\n        'scale',\n        'modelViewMatrix',\n        'normalMatrix',\n        'matrix',\n        'matrixWorld',\n        'matrixAutoUpdate',\n        'matrixWorldAutoUpdate',\n        'matrixWorldNeedsUpdate',\n        'layers',\n        'visible',\n        'castShadow',\n        'receiveShadow',\n        'frustumCulled',\n        'renderOrder',\n        'animations',\n        'userData',\n        'customDepthMaterial',\n        'customDistanceMaterial',\n        'onBeforeRender',\n        'onAfterRender',\n    ];\n}\n"]}