angular-three-soba 2.0.0 → 2.2.0

package/esm2022/gizmos/lib/transform-controls.mjs

@@ -0,0 +1,177 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, input, output, viewChild, } from '@angular/core';
+import { extend, getLocalState, injectStore, NgtArgs, omit, pick, resolveRef, } from 'angular-three';
+import { Group } from 'three';
+import { TransformControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export class NgtsTransformControls {
+    constructor() {
+        this.object = input(null);
+        this.options = input({});
+        this.parameters = omit(this.options, [
+            'enabled',
+            'axis',
+            'mode',
+            'translationSnap',
+            'rotationSnap',
+            'scaleSnap',
+            'space',
+            'size',
+            'showX',
+            'showY',
+            'showZ',
+            'domElement',
+            'makeDefault',
+            'camera',
+        ]);
+        this.controlsOptions = pick(this.options, [
+            'enabled',
+            'axis',
+            'mode',
+            'translationSnap',
+            'rotationSnap',
+            'scaleSnap',
+            'space',
+            'size',
+            'showX',
+            'showY',
+            'showZ',
+        ]);
+        this.camera = pick(this.options, 'camera');
+        this.domElement = pick(this.options, 'domElement');
+        this.makeDefault = pick(this.options, 'makeDefault');
+        this.change = output();
+        this.mouseDown = output();
+        this.mouseUp = output();
+        this.objectChange = output();
+        this.groupRef = viewChild.required('group');
+        this.store = injectStore();
+        this.glDomElement = this.store.select('gl', 'domElement');
+        this.defaultCamera = this.store.select('camera');
+        this.events = this.store.select('events');
+        this.defaultControls = this.store.select('controls');
+        this.invalidate = this.store.select('invalidate');
+        this.controls = computed(() => {
+            let camera = this.camera();
+            if (!camera) {
+                camera = this.defaultCamera();
+            }
+            let domElement = this.domElement();
+            if (!domElement) {
+                domElement = this.events().connected || this.glDomElement();
+            }
+            return new TransformControls(camera, domElement);
+        });
+        extend({ Group });
+        effect((onCleanup) => {
+            const cleanup = this.attachControlsEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect((onCleanup) => {
+            const cleanup = this.disableDefaultControlsEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect((onCleanup) => {
+            const cleanup = this.setupControlsEventsEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect((onCleanup) => {
+            const cleanup = this.updateDefaultControlsEffect();
+            onCleanup(() => cleanup?.());
+        });
+    }
+    attachControlsEffect() {
+        const group = this.groupRef().nativeElement;
+        if (!group)
+            return;
+        const localState = getLocalState(group);
+        if (!localState)
+            return;
+        const [object, controls] = [resolveRef(this.object()), this.controls(), localState.objects()];
+        if (object) {
+            controls.attach(object);
+        }
+        else {
+            controls.attach(group);
+        }
+        return () => controls.detach();
+    }
+    disableDefaultControlsEffect() {
+        const defaultControls = this.defaultControls();
+        if (!defaultControls)
+            return;
+        const controls = this.controls();
+        const callback = (event) => {
+            defaultControls.enabled = !event.value;
+        };
+        // @ts-expect-error - three-stdlib types are not up-to-date
+        controls.addEventListener('dragging-changed', callback);
+        return () => {
+            // @ts-expect-error - three-stdlib types are not up-to-date
+            controls.removeEventListener('dragging-changed', callback);
+        };
+    }
+    setupControlsEventsEffect() {
+        const [controls, invalidate] = [this.controls(), this.invalidate()];
+        const onChange = (event) => {
+            invalidate();
+            if (!this.change['destroyed']) {
+                this.change.emit(event);
+            }
+        };
+        const onMouseDown = this.mouseDown.emit.bind(this.mouseDown);
+        const onMouseUp = this.mouseUp.emit.bind(this.mouseUp);
+        const onObjectChange = this.objectChange.emit.bind(this.objectChange);
+        // @ts-expect-error - three-stdlib types are not up-to-date
+        controls.addEventListener('change', onChange);
+        // @ts-expect-error - three-stdlib types are not up-to-date
+        controls.addEventListener('mouseDown', onMouseDown);
+        // @ts-expect-error - three-stdlib types are not up-to-date
+        controls.addEventListener('mouseUp', onMouseUp);
+        // @ts-expect-error - three-stdlib types are not up-to-date
+        controls.addEventListener('objectChange', onObjectChange);
+        return () => {
+            // @ts-expect-error - three-stdlib types are not up-to-date
+            controls.removeEventListener('change', onChange);
+            // @ts-expect-error - three-stdlib types are not up-to-date
+            controls.removeEventListener('mouseDown', onMouseDown);
+            // @ts-expect-error - three-stdlib types are not up-to-date
+            controls.removeEventListener('mouseUp', onMouseUp);
+            // @ts-expect-error - three-stdlib types are not up-to-date
+            controls.removeEventListener('objectChange', onObjectChange);
+        };
+    }
+    updateDefaultControlsEffect() {
+        const [controls, makeDefault] = [this.controls(), this.makeDefault()];
+        if (!makeDefault)
+            return;
+        const oldControls = this.store.snapshot.controls;
+        this.store.update({ controls });
+        return () => this.store.update(() => ({ controls: oldControls }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsTransformControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsTransformControls, isStandalone: true, selector: "ngts-transform-controls", inputs: { object: { classPropertyName: "object", publicName: "object", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { change: "change", mouseDown: "mouseDown", mouseUp: "mouseUp", objectChange: "objectChange" }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-primitive *args="[controls()]" [parameters]="controlsOptions()" />
+
+		<ngt-group #group [parameters]="parameters()">
+			<ng-content />
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsTransformControls, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-transform-controls',
+                    standalone: true,
+                    template: `
+		<ngt-primitive *args="[controls()]" [parameters]="controlsOptions()" />
+
+		<ngt-group #group [parameters]="parameters()">
+			<ng-content />
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/gizmos/src/lib/transform-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\teffect,\n\tElementRef,\n\tinput,\n\toutput,\n\tSignal,\n\tviewChild,\n} from '@angular/core';\nimport {\n\textend,\n\tgetLocalState,\n\tinjectStore,\n\tNgtArgs,\n\tNgtGroup,\n\tNgtObject3DNode,\n\tomit,\n\tpick,\n\tresolveRef,\n} from 'angular-three';\nimport { Camera, Group, Object3D, Event as ThreeEvent } from 'three';\nimport { TransformControls } from 'three-stdlib';\n\ninterface ControlsProto {\n\tenabled: boolean;\n}\n\nexport type NgtsTransformControlsObject = NgtObject3DNode<TransformControls, typeof TransformControls>;\n\nexport type NgtsTransformControlsOptions = Partial<NgtsTransformControlsObject> &\n\tPartial<NgtGroup> & {\n\t\tenabled?: boolean;\n\t\taxis?: string | null;\n\t\tdomElement?: HTMLElement;\n\t\tmode?: 'translate' | 'rotate' | 'scale';\n\t\ttranslationSnap?: number | null;\n\t\trotationSnap?: number | null;\n\t\tscaleSnap?: number | null;\n\t\tspace?: 'world' | 'local';\n\t\tsize?: number;\n\t\tshowX?: boolean;\n\t\tshowY?: boolean;\n\t\tshowZ?: boolean;\n\t\tcamera?: Camera;\n\t\tmakeDefault?: boolean;\n\t};\n\n@Component({\n\tselector: 'ngts-transform-controls',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive *args=\"[controls()]\" [parameters]=\"controlsOptions()\" />\n\n\t\t<ngt-group #group [parameters]=\"parameters()\">\n\t\t\t<ng-content />\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class NgtsTransformControls {\n\tobject = input<Object3D | ElementRef<Object3D> | undefined | null>(null);\n\toptions = input({} as Partial<NgtsTransformControlsOptions>);\n\tparameters = omit(this.options, [\n\t\t'enabled',\n\t\t'axis',\n\t\t'mode',\n\t\t'translationSnap',\n\t\t'rotationSnap',\n\t\t'scaleSnap',\n\t\t'space',\n\t\t'size',\n\t\t'showX',\n\t\t'showY',\n\t\t'showZ',\n\t\t'domElement',\n\t\t'makeDefault',\n\t\t'camera',\n\t]);\n\n\tprotected controlsOptions = pick(this.options, [\n\t\t'enabled',\n\t\t'axis',\n\t\t'mode',\n\t\t'translationSnap',\n\t\t'rotationSnap',\n\t\t'scaleSnap',\n\t\t'space',\n\t\t'size',\n\t\t'showX',\n\t\t'showY',\n\t\t'showZ',\n\t]);\n\n\tprivate camera = pick(this.options, 'camera');\n\tprivate domElement = pick(this.options, 'domElement');\n\tprivate makeDefault = pick(this.options, 'makeDefault');\n\n\tchange = output<ThreeEvent>();\n\tmouseDown = output<ThreeEvent>();\n\tmouseUp = output<ThreeEvent>();\n\tobjectChange = output<ThreeEvent>();\n\n\tprivate groupRef = viewChild.required<ElementRef<Group>>('group');\n\n\tprivate store = injectStore();\n\tprivate glDomElement = this.store.select('gl', 'domElement');\n\tprivate defaultCamera = this.store.select('camera');\n\tprivate events = this.store.select('events');\n\tprivate defaultControls = this.store.select('controls') as unknown as Signal<ControlsProto>;\n\tprivate invalidate = this.store.select('invalidate');\n\n\tcontrols = computed(() => {\n\t\tlet camera = this.camera();\n\t\tif (!camera) {\n\t\t\tcamera = this.defaultCamera();\n\t\t}\n\n\t\tlet domElement = this.domElement();\n\t\tif (!domElement) {\n\t\t\tdomElement = this.events().connected || this.glDomElement();\n\t\t}\n\n\t\treturn new TransformControls(camera, domElement);\n\t});\n\n\tconstructor() {\n\t\textend({ Group });\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.attachControlsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.disableDefaultControlsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.setupControlsEventsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.updateDefaultControlsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\t}\n\n\tprivate attachControlsEffect() {\n\t\tconst group = this.groupRef().nativeElement;\n\t\tif (!group) return;\n\n\t\tconst localState = getLocalState(group);\n\t\tif (!localState) return;\n\n\t\tconst [object, controls] = [resolveRef(this.object()), this.controls(), localState.objects()];\n\t\tif (object) {\n\t\t\tcontrols.attach(object);\n\t\t} else {\n\t\t\tcontrols.attach(group);\n\t\t}\n\n\t\treturn () => controls.detach();\n\t}\n\n\tprivate disableDefaultControlsEffect() {\n\t\tconst defaultControls = this.defaultControls();\n\t\tif (!defaultControls) return;\n\n\t\tconst controls = this.controls();\n\t\tconst callback = (event: any) => {\n\t\t\tdefaultControls.enabled = !event.value;\n\t\t};\n\n\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\tcontrols.addEventListener('dragging-changed', callback);\n\t\treturn () => {\n\t\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\t\tcontrols.removeEventListener('dragging-changed', callback);\n\t\t};\n\t}\n\n\tprivate setupControlsEventsEffect() {\n\t\tconst [controls, invalidate] = [this.controls(), this.invalidate()];\n\t\tconst onChange = (event: ThreeEvent) => {\n\t\t\tinvalidate();\n\t\t\tif (!this.change['destroyed']) {\n\t\t\t\tthis.change.emit(event);\n\t\t\t}\n\t\t};\n\t\tconst onMouseDown = this.mouseDown.emit.bind(this.mouseDown);\n\t\tconst onMouseUp = this.mouseUp.emit.bind(this.mouseUp);\n\t\tconst onObjectChange = this.objectChange.emit.bind(this.objectChange);\n\n\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\tcontrols.addEventListener('change', onChange);\n\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\tcontrols.addEventListener('mouseDown', onMouseDown);\n\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\tcontrols.addEventListener('mouseUp', onMouseUp);\n\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\tcontrols.addEventListener('objectChange', onObjectChange);\n\n\t\treturn () => {\n\t\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\t\tcontrols.removeEventListener('change', onChange);\n\t\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\t\tcontrols.removeEventListener('mouseDown', onMouseDown);\n\t\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\t\tcontrols.removeEventListener('mouseUp', onMouseUp);\n\t\t\t// @ts-expect-error - three-stdlib types are not up-to-date\n\t\t\tcontrols.removeEventListener('objectChange', onObjectChange);\n\t\t};\n\t}\n\n\tprivate updateDefaultControlsEffect() {\n\t\tconst [controls, makeDefault] = [this.controls(), this.makeDefault()];\n\t\tif (!makeDefault) return;\n\n\t\tconst oldControls = this.store.snapshot.controls;\n\t\tthis.store.update({ controls });\n\t\treturn () => this.store.update(() => ({ controls: oldControls }));\n\t}\n}\n"]}

package/esm2022/staging/index.mjs

@@ -9,6 +9,7 @@ export * from './lib/contact-shadows';
 export * from './lib/environment';
 export * from './lib/float';
 export * from './lib/lightformer';
+export * from './lib/mask';
 export * from './lib/matcap-texture';
 export * from './lib/normal-texture';
 export * from './lib/randomized-lights';
@@ -16,4 +17,4 @@ export * from './lib/render-texture';
 export * from './lib/sky';
 export { NgtsSpotLight, NgtsSpotLightShadow } from './lib/spot-light';
 export * from './lib/stage';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc3RhZ2luZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxXQUFXLENBQUM7QUFDMUIsT0FBTyxFQUFFLGFBQWEsRUFBd0IsbUJBQW1CLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM1RixjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2FjY3VtdWxhdGl2ZS1zaGFkb3dzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2JhY2tkcm9wJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2JiLWFuY2hvcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ib3VuZHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2FtZXJhLXNoYWtlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdXN0aWNzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlbnRlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb250YWN0LXNoYWRvd3MnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZW52aXJvbm1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZmxvYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGlnaHRmb3JtZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWF0Y2FwLXRleHR1cmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbm9ybWFsLXRleHR1cmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmFuZG9taXplZC1saWdodHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmVuZGVyLXRleHR1cmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2t5JztcbmV4cG9ydCB7IE5ndHNTcG90TGlnaHQsIE5ndHNTcG90TGlnaHRPcHRpb25zLCBOZ3RzU3BvdExpZ2h0U2hhZG93IH0gZnJvbSAnLi9saWIvc3BvdC1saWdodCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zdGFnZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc3RhZ2luZy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxXQUFXLENBQUM7QUFDMUIsT0FBTyxFQUFFLGFBQWEsRUFBd0IsbUJBQW1CLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM1RixjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2FjY3VtdWxhdGl2ZS1zaGFkb3dzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2JhY2tkcm9wJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2JiLWFuY2hvcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ib3VuZHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY2FtZXJhLXNoYWtlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhdXN0aWNzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NlbnRlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb250YWN0LXNoYWRvd3MnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZW52aXJvbm1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZmxvYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGlnaHRmb3JtZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWFzayc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tYXRjYXAtdGV4dHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ub3JtYWwtdGV4dHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yYW5kb21pemVkLWxpZ2h0cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZW5kZXItdGV4dHVyZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9za3knO1xuZXhwb3J0IHsgTmd0c1Nwb3RMaWdodCwgTmd0c1Nwb3RMaWdodE9wdGlvbnMsIE5ndHNTcG90TGlnaHRTaGFkb3cgfSBmcm9tICcuL2xpYi9zcG90LWxpZ2h0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3N0YWdlJztcbiJdfQ==

package/esm2022/staging/lib/mask.mjs

@@ -0,0 +1,78 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, numberAttribute, viewChild, } from '@angular/core';
+import { extend, omit, pick } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { AlwaysStencilFunc, EqualStencilFunc, KeepStencilOp, Mesh, NotEqualStencilFunc, ReplaceStencilOp, } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    colorWrite: false,
+    depthWrite: false,
+};
+export class NgtsMask {
+    constructor() {
+        this.id = input(1, { transform: numberAttribute });
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['colorWrite', 'depthWrite']);
+        this.meshRef = viewChild.required('mesh');
+        this.colorWrite = pick(this.options, 'colorWrite');
+        this.depthWrite = pick(this.options, 'depthWrite');
+        this.spread = computed(() => {
+            const [id, colorWrite, depthWrite] = [this.id(), this.colorWrite(), this.depthWrite()];
+            return {
+                colorWrite,
+                depthWrite,
+                stencilWrite: true,
+                stencilRef: id,
+                stencilFunc: AlwaysStencilFunc,
+                stencilFail: ReplaceStencilOp,
+                stencilZFail: ReplaceStencilOp,
+                stencilZPass: ReplaceStencilOp,
+            };
+        });
+        extend({ Mesh });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [mesh, spread] = [this.meshRef().nativeElement, this.spread()];
+                Object.assign(mesh.material, spread);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsMask, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsMask, isStandalone: true, selector: "ngts-mask", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "meshRef", first: true, predicate: ["mesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-mesh #mesh [renderOrder]="-id()" [parameters]="parameters()">
+			<ng-content />
+		</ngt-mesh>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsMask, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-mask',
+                    standalone: true,
+                    template: `
+		<ngt-mesh #mesh [renderOrder]="-id()" [parameters]="parameters()">
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export function injectMask(id, inverse = () => false, { injector } = {}) {
+    return assertInjector(injectMask, injector, () => {
+        return computed(() => {
+            const [_id, _inverse] = [id(), inverse()];
+            return {
+                stencilWrite: true,
+                stencilRef: _id,
+                stencilFunc: _inverse ? NotEqualStencilFunc : EqualStencilFunc,
+                stencilFail: KeepStencilOp,
+                stencilZFail: KeepStencilOp,
+                stencilZPass: KeepStencilOp,
+            };
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9zdGFnaW5nL3NyYy9saWIvbWFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ04sZUFBZSxFQUNmLHVCQUF1QixFQUN2QixTQUFTLEVBQ1QsUUFBUSxFQUNSLHNCQUFzQixFQUd0QixLQUFLLEVBQ0wsZUFBZSxFQUNmLFNBQVMsR0FDVCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsTUFBTSxFQUFXLElBQUksRUFBRSxJQUFJLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDNUQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzVELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxPQUFPLEVBQ04saUJBQWlCLEVBRWpCLGdCQUFnQixFQUNoQixhQUFhLEVBRWIsSUFBSSxFQUNKLG1CQUFtQixFQUNuQixnQkFBZ0IsR0FDaEIsTUFBTSxPQUFPLENBQUM7O0FBT2YsTUFBTSxjQUFjLEdBQW9CO0lBQ3ZDLFVBQVUsRUFBRSxLQUFLO0lBQ2pCLFVBQVUsRUFBRSxLQUFLO0NBQ2pCLENBQUM7QUFhRixNQUFNLE9BQU8sUUFBUTtJQXdCcEI7UUF2QkEsT0FBRSxHQUFHLEtBQUssQ0FBQyxDQUFDLEVBQUUsRUFBRSxTQUFTLEVBQUUsZUFBZSxFQUFFLENBQUMsQ0FBQztRQUM5QyxZQUFPLEdBQUcsS0FBSyxDQUFDLGNBQWMsRUFBRSxFQUFFLFNBQVMsRUFBRSxXQUFXLENBQUMsY0FBYyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBRTVFLGVBQVUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDO1FBRTlELFlBQU8sR0FBRyxTQUFTLENBQUMsUUFBUSxDQUE2QyxNQUFNLENBQUMsQ0FBQztRQUV6RSxlQUFVLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsWUFBWSxDQUFDLENBQUM7UUFDOUMsZUFBVSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFlBQVksQ0FBQyxDQUFDO1FBQzlDLFdBQU0sR0FBRyxRQUFRLENBQUMsR0FBRyxFQUFFO1lBQzlCLE1BQU0sQ0FBQyxFQUFFLEVBQUUsVUFBVSxFQUFFLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxFQUFFLElBQUksQ0FBQyxVQUFVLEVBQUUsRUFBRSxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztZQUN2RixPQUFPO2dCQUNOLFVBQVU7Z0JBQ1YsVUFBVTtnQkFDVixZQUFZLEVBQUUsSUFBSTtnQkFDbEIsVUFBVSxFQUFFLEVBQUU7Z0JBQ2QsV0FBVyxFQUFFLGlCQUFpQjtnQkFDOUIsV0FBVyxFQUFFLGdCQUFnQjtnQkFDN0IsWUFBWSxFQUFFLGdCQUFnQjtnQkFDOUIsWUFBWSxFQUFFLGdCQUFnQjthQUM5QixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFHRixNQUFNLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLE1BQU0sVUFBVSxHQUFHLGdCQUFnQixFQUFFLENBQUM7UUFFdEMsZUFBZSxDQUFDLEdBQUcsRUFBRTtZQUNwQixVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUNmLE1BQU0sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsYUFBYSxFQUFFLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO2dCQUNyRSxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDdEMsQ0FBQyxDQUFDLENBQUM7UUFDSixDQUFDLENBQUMsQ0FBQztJQUNKLENBQUM7OEdBbkNXLFFBQVE7a0dBQVIsUUFBUSwrYUFSVjs7OztFQUlUOzsyRkFJVyxRQUFRO2tCQVhwQixTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxXQUFXO29CQUNyQixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFOzs7O0VBSVQ7b0JBQ0QsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ2pDLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUMvQzs7QUF1Q0QsTUFBTSxVQUFVLFVBQVUsQ0FDekIsRUFBZ0IsRUFDaEIsVUFBeUIsR0FBRyxFQUFFLENBQUMsS0FBSyxFQUNwQyxFQUFFLFFBQVEsS0FBOEIsRUFBRTtJQUUxQyxPQUFPLGNBQWMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxFQUFFLEdBQUcsRUFBRTtRQUNoRCxPQUFPLFFBQVEsQ0FBQyxHQUFHLEVBQUU7WUFDcEIsTUFBTSxDQUFDLEdBQUcsRUFBRSxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFDMUMsT0FBTztnQkFDTixZQUFZLEVBQUUsSUFBSTtnQkFDbEIsVUFBVSxFQUFFLEdBQUc7Z0JBQ2YsV0FBVyxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLGdCQUFnQjtnQkFDOUQsV0FBVyxFQUFFLGFBQWE7Z0JBQzFCLFlBQVksRUFBRSxhQUFhO2dCQUMzQixZQUFZLEVBQUUsYUFBYTthQUMzQixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDSixDQUFDLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuXHRhZnRlck5leHRSZW5kZXIsXG5cdENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuXHRDb21wb25lbnQsXG5cdGNvbXB1dGVkLFxuXHRDVVNUT01fRUxFTUVOVFNfU0NIRU1BLFxuXHRFbGVtZW50UmVmLFxuXHRJbmplY3Rvcixcblx0aW5wdXQsXG5cdG51bWJlckF0dHJpYnV0ZSxcblx0dmlld0NoaWxkLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IGV4dGVuZCwgTmd0TWVzaCwgb21pdCwgcGljayB9IGZyb20gJ2FuZ3VsYXItdGhyZWUnO1xuaW1wb3J0IHsgYXNzZXJ0SW5qZWN0b3IgfSBmcm9tICduZ3h0ZW5zaW9uL2Fzc2VydC1pbmplY3Rvcic7XG5pbXBvcnQgeyBpbmplY3RBdXRvRWZmZWN0IH0gZnJvbSAnbmd4dGVuc2lvbi9hdXRvLWVmZmVjdCc7XG5pbXBvcnQgeyBtZXJnZUlucHV0cyB9IGZyb20gJ25neHRlbnNpb24vaW5qZWN0LWlucHV0cyc7XG5pbXBvcnQge1xuXHRBbHdheXNTdGVuY2lsRnVuYyxcblx0QnVmZmVyR2VvbWV0cnksXG5cdEVxdWFsU3RlbmNpbEZ1bmMsXG5cdEtlZXBTdGVuY2lsT3AsXG5cdE1hdGVyaWFsLFxuXHRNZXNoLFxuXHROb3RFcXVhbFN0ZW5jaWxGdW5jLFxuXHRSZXBsYWNlU3RlbmNpbE9wLFxufSBmcm9tICd0aHJlZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmd0c01hc2tPcHRpb25zIGV4dGVuZHMgUGFydGlhbDxOZ3RNZXNoPiB7XG5cdGNvbG9yV3JpdGU6IGJvb2xlYW47XG5cdGRlcHRoV3JpdGU6IGJvb2xlYW47XG59XG5cbmNvbnN0IGRlZmF1bHRPcHRpb25zOiBOZ3RzTWFza09wdGlvbnMgPSB7XG5cdGNvbG9yV3JpdGU6IGZhbHNlLFxuXHRkZXB0aFdyaXRlOiBmYWxzZSxcbn07XG5cbkBDb21wb25lbnQoe1xuXHRzZWxlY3RvcjogJ25ndHMtbWFzaycsXG5cdHN0YW5kYWxvbmU6IHRydWUsXG5cdHRlbXBsYXRlOiBgXG5cdFx0PG5ndC1tZXNoICNtZXNoIFtyZW5kZXJPcmRlcl09XCItaWQoKVwiIFtwYXJhbWV0ZXJzXT1cInBhcmFtZXRlcnMoKVwiPlxuXHRcdFx0PG5nLWNvbnRlbnQgLz5cblx0XHQ8L25ndC1tZXNoPlxuXHRgLFxuXHRzY2hlbWFzOiBbQ1VTVE9NX0VMRU1FTlRTX1NDSEVNQV0sXG5cdGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBOZ3RzTWFzayB7XG5cdGlkID0gaW5wdXQoMSwgeyB0cmFuc2Zvcm06IG51bWJlckF0dHJpYnV0ZSB9KTtcblx0b3B0aW9ucyA9IGlucHV0KGRlZmF1bHRPcHRpb25zLCB7IHRyYW5zZm9ybTogbWVyZ2VJbnB1dHMoZGVmYXVsdE9wdGlvbnMpIH0pO1xuXG5cdHBhcmFtZXRlcnMgPSBvbWl0KHRoaXMub3B0aW9ucywgWydjb2xvcldyaXRlJywgJ2RlcHRoV3JpdGUnXSk7XG5cblx0bWVzaFJlZiA9IHZpZXdDaGlsZC5yZXF1aXJlZDxFbGVtZW50UmVmPE1lc2g8QnVmZmVyR2VvbWV0cnksIE1hdGVyaWFsPj4+KCdtZXNoJyk7XG5cblx0cHJpdmF0ZSBjb2xvcldyaXRlID0gcGljayh0aGlzLm9wdGlvbnMsICdjb2xvcldyaXRlJyk7XG5cdHByaXZhdGUgZGVwdGhXcml0ZSA9IHBpY2sodGhpcy5vcHRpb25zLCAnZGVwdGhXcml0ZScpO1xuXHRwcml2YXRlIHNwcmVhZCA9IGNvbXB1dGVkKCgpID0+IHtcblx0XHRjb25zdCBbaWQsIGNvbG9yV3JpdGUsIGRlcHRoV3JpdGVdID0gW3RoaXMuaWQoKSwgdGhpcy5jb2xvcldyaXRlKCksIHRoaXMuZGVwdGhXcml0ZSgpXTtcblx0XHRyZXR1cm4ge1xuXHRcdFx0Y29sb3JXcml0ZSxcblx0XHRcdGRlcHRoV3JpdGUsXG5cdFx0XHRzdGVuY2lsV3JpdGU6IHRydWUsXG5cdFx0XHRzdGVuY2lsUmVmOiBpZCxcblx0XHRcdHN0ZW5jaWxGdW5jOiBBbHdheXNTdGVuY2lsRnVuYyxcblx0XHRcdHN0ZW5jaWxGYWlsOiBSZXBsYWNlU3RlbmNpbE9wLFxuXHRcdFx0c3RlbmNpbFpGYWlsOiBSZXBsYWNlU3RlbmNpbE9wLFxuXHRcdFx0c3RlbmNpbFpQYXNzOiBSZXBsYWNlU3RlbmNpbE9wLFxuXHRcdH07XG5cdH0pO1xuXG5cdGNvbnN0cnVjdG9yKCkge1xuXHRcdGV4dGVuZCh7IE1lc2ggfSk7XG5cblx0XHRjb25zdCBhdXRvRWZmZWN0ID0gaW5qZWN0QXV0b0VmZmVjdCgpO1xuXG5cdFx0YWZ0ZXJOZXh0UmVuZGVyKCgpID0+IHtcblx0XHRcdGF1dG9FZmZlY3QoKCkgPT4ge1xuXHRcdFx0XHRjb25zdCBbbWVzaCwgc3ByZWFkXSA9IFt0aGlzLm1lc2hSZWYoKS5uYXRpdmVFbGVtZW50LCB0aGlzLnNwcmVhZCgpXTtcblx0XHRcdFx0T2JqZWN0LmFzc2lnbihtZXNoLm1hdGVyaWFsLCBzcHJlYWQpO1xuXHRcdFx0fSk7XG5cdFx0fSk7XG5cdH1cbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGluamVjdE1hc2soXG5cdGlkOiAoKSA9PiBudW1iZXIsXG5cdGludmVyc2U6ICgpID0+IGJvb2xlYW4gPSAoKSA9PiBmYWxzZSxcblx0eyBpbmplY3RvciB9OiB7IGluamVjdG9yPzogSW5qZWN0b3IgfSA9IHt9LFxuKSB7XG5cdHJldHVybiBhc3NlcnRJbmplY3RvcihpbmplY3RNYXNrLCBpbmplY3RvciwgKCkgPT4ge1xuXHRcdHJldHVybiBjb21wdXRlZCgoKSA9PiB7XG5cdFx0XHRjb25zdCBbX2lkLCBfaW52ZXJzZV0gPSBbaWQoKSwgaW52ZXJzZSgpXTtcblx0XHRcdHJldHVybiB7XG5cdFx0XHRcdHN0ZW5jaWxXcml0ZTogdHJ1ZSxcblx0XHRcdFx0c3RlbmNpbFJlZjogX2lkLFxuXHRcdFx0XHRzdGVuY2lsRnVuYzogX2ludmVyc2UgPyBOb3RFcXVhbFN0ZW5jaWxGdW5jIDogRXF1YWxTdGVuY2lsRnVuYyxcblx0XHRcdFx0c3RlbmNpbEZhaWw6IEtlZXBTdGVuY2lsT3AsXG5cdFx0XHRcdHN0ZW5jaWxaRmFpbDogS2VlcFN0ZW5jaWxPcCxcblx0XHRcdFx0c3RlbmNpbFpQYXNzOiBLZWVwU3RlbmNpbE9wLFxuXHRcdFx0fTtcblx0XHR9KTtcblx0fSk7XG59XG4iXX0=