angular-three 1.9.16 → 1.10.0

package/esm2022/lib/portal.mjs

@@ -0,0 +1,240 @@
+import { NgIf } from '@angular/common';
+import { Component, ContentChild, Directive, EventEmitter, inject, Input, Output, SkipSelf, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import * as THREE from 'three';
+import { injectNgtRef } from './di/ref';
+import { NgtRxStore } from './stores/rx-store';
+import { NgtStore } from './stores/store';
+import { getLocalState, prepare } from './utils/instance';
+import { is } from './utils/is';
+import { updateCamera } from './utils/update';
+import * as i0 from "@angular/core";
+const privateKeys = [
+    'get',
+    'set',
+    'select',
+    'setSize',
+    'setDpr',
+    'setFrameloop',
+    'events',
+    'invalidate',
+    'advance',
+    'size',
+    'viewport',
+    'addInteraction',
+    'removeInteraction',
+];
+class NgtPortalBeforeRender {
+    constructor() {
+        this.portalStore = inject(NgtStore);
+        this.renderPriority = 1;
+        this.beforeRender = new EventEmitter();
+    }
+    ngOnInit() {
+        let oldClear;
+        this.subscription = this.portalStore.get('internal').subscribe(({ delta, frame }) => {
+            this.beforeRender.emit({ ...this.portalStore.get(), delta, frame });
+            const { gl, scene, camera } = this.portalStore.get();
+            oldClear = gl.autoClear;
+            if (this.renderPriority === 1) {
+                // clear scene and render with default
+                gl.autoClear = true;
+                gl.render(this.parentScene, this.parentCamera);
+            }
+            // disable cleaning
+            gl.autoClear = false;
+            gl.clearDepth();
+            gl.render(scene, camera);
+            // restore
+            gl.autoClear = oldClear;
+        }, this.renderPriority, this.portalStore);
+    }
+    ngOnDestroy() {
+        this.subscription?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortalBeforeRender, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtPortalBeforeRender, isStandalone: true, selector: "[ngtPortalBeforeRender]", inputs: { renderPriority: "renderPriority", parentScene: "parentScene", parentCamera: "parentCamera" }, outputs: { beforeRender: "beforeRender" }, ngImport: i0 }); }
+}
+export { NgtPortalBeforeRender };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortalBeforeRender, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ngtPortalBeforeRender]', standalone: true }]
+        }], propDecorators: { renderPriority: [{
+                type: Input
+            }], parentScene: [{
+                type: Input
+            }], parentCamera: [{
+                type: Input
+            }], beforeRender: [{
+                type: Output
+            }] } });
+class NgtPortalContent {
+    constructor(vcr, parentVcr) {
+        const commentNode = vcr.element.nativeElement;
+        if (commentNode['__ngt_renderer_add_comment__']) {
+            commentNode['__ngt_renderer_add_comment__'](parentVcr.element.nativeElement);
+            delete commentNode['__ngt_renderer_add_comment__'];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortalContent, deps: [{ token: i0.ViewContainerRef }, { token: i0.ViewContainerRef, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtPortalContent, isStandalone: true, selector: "ng-template[ngtPortalContent]", ngImport: i0 }); }
+}
+export { NgtPortalContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortalContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtPortalContent]', standalone: true }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ViewContainerRef, decorators: [{
+                    type: SkipSelf
+                }] }]; } });
+class NgtPortal extends NgtRxStore {
+    constructor() {
+        super(...arguments);
+        this.autoRender = true;
+        this.autoRenderPriority = 1;
+        this.beforeRender = new EventEmitter();
+        this.parentStore = inject(NgtStore, { skipSelf: true });
+        this.parentScene = this.parentStore.get('scene');
+        this.parentCamera = this.parentStore.get('camera');
+        this.portalStore = inject(NgtStore, { self: true });
+        this.raycaster = new THREE.Raycaster();
+        this.pointer = new THREE.Vector2();
+        this.portalContentRendered = false;
+    }
+    set container(container) {
+        this.set({ container });
+    }
+    set state(state) {
+        this.set({ state });
+    }
+    initialize() {
+        super.initialize();
+        this.set({ container: injectNgtRef(prepare(new THREE.Scene())) });
+    }
+    ngOnInit() {
+        const previousState = this.parentStore.get();
+        const inputsState = this.get();
+        if (!inputsState.state && this.autoRender) {
+            inputsState.state = { events: { priority: this.autoRenderPriority + 1 } };
+        }
+        const { events, size, ...restInputsState } = inputsState.state || {};
+        const containerState = inputsState.container;
+        const container = is.ref(containerState) ? containerState.nativeElement : containerState;
+        const localState = getLocalState(container);
+        if (!localState.store) {
+            localState.store = this.portalStore;
+        }
+        this.portalStore.set({
+            ...previousState,
+            scene: container,
+            raycaster: this.raycaster,
+            pointer: this.pointer,
+            previousStore: this.parentStore,
+            events: { ...previousState.events, ...(events || {}) },
+            size: { ...previousState.size, ...(size || {}) },
+            ...restInputsState,
+            get: this.portalStore.get.bind(this.portalStore),
+            set: this.portalStore.set.bind(this.portalStore),
+            select: this.portalStore.select.bind(this.portalStore),
+            setEvents: (events) => this.portalStore.set((state) => ({ ...state, events: { ...state.events, ...events } })),
+        });
+        this.hold(this.parentStore.select(), (previous) => this.portalStore.set((state) => this.inject(previous, state)));
+        requestAnimationFrame(() => {
+            this.portalStore.set((injectState) => this.inject(this.parentStore.get(), injectState));
+        });
+        this.portalContentView = this.portalContentAnchor.createEmbeddedView(this.portalContentTemplate);
+        this.portalContentView.detectChanges();
+        this.portalContentRendered = true;
+    }
+    onBeforeRender(portal) {
+        this.beforeRender.emit({
+            root: { ...this.parentStore.get(), delta: portal.delta, frame: portal.frame },
+            portal,
+        });
+    }
+    ngOnDestroy() {
+        if (this.portalContentView && !this.portalContentView.destroyed) {
+            this.portalContentView.destroy();
+        }
+        super.ngOnDestroy();
+    }
+    inject(rootState, injectState) {
+        const intersect = { ...rootState };
+        Object.keys(intersect).forEach((key) => {
+            if (privateKeys.includes(key) ||
+                rootState[key] !== injectState[key]) {
+                delete intersect[key];
+            }
+        });
+        const inputs = this.get();
+        const { size, events, ...restInputsState } = inputs.state || {};
+        let viewport = undefined;
+        if (injectState && size) {
+            const camera = injectState.camera;
+            viewport = rootState.viewport.getCurrentViewport(camera, new THREE.Vector3(), size);
+            if (camera !== rootState.camera)
+                updateCamera(camera, size);
+        }
+        return {
+            ...intersect,
+            scene: is.ref(inputs.container) ? inputs.container.nativeElement : inputs.container,
+            raycaster: this.raycaster,
+            pointer: this.pointer,
+            previousStore: this.parentStore,
+            events: { ...rootState.events, ...(injectState?.events || {}), ...events },
+            size: { ...rootState.size, ...size },
+            viewport: { ...rootState.viewport, ...(viewport || {}) },
+            ...restInputsState,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortal, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtPortal, isStandalone: true, selector: "ngt-portal", inputs: { container: "container", state: "state", autoRender: "autoRender", autoRenderPriority: "autoRenderPriority" }, outputs: { beforeRender: "beforeRender" }, providers: [NgtStore], queries: [{ propertyName: "portalContentTemplate", first: true, predicate: NgtPortalContent, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "portalContentAnchor", first: true, predicate: ["portalContentAnchor"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0, template: `
+        <ng-container #portalContentAnchor>
+            <ng-container
+                *ngIf="autoRender && portalContentRendered"
+                ngtPortalBeforeRender
+                [renderPriority]="autoRenderPriority"
+                [parentScene]="parentScene"
+                [parentCamera]="parentCamera"
+                (beforeRender)="onBeforeRender($event)"
+            />
+        </ng-container>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgtPortalBeforeRender, selector: "[ngtPortalBeforeRender]", inputs: ["renderPriority", "parentScene", "parentCamera"], outputs: ["beforeRender"] }] }); }
+}
+export { NgtPortal };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtPortal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-portal',
+                    standalone: true,
+                    template: `
+        <ng-container #portalContentAnchor>
+            <ng-container
+                *ngIf="autoRender && portalContentRendered"
+                ngtPortalBeforeRender
+                [renderPriority]="autoRenderPriority"
+                [parentScene]="parentScene"
+                [parentCamera]="parentCamera"
+                (beforeRender)="onBeforeRender($event)"
+            />
+        </ng-container>
+    `,
+                    imports: [NgIf, NgtPortalBeforeRender],
+                    providers: [NgtStore],
+                }]
+        }], propDecorators: { container: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], autoRender: [{
+                type: Input
+            }], autoRenderPriority: [{
+                type: Input
+            }], beforeRender: [{
+                type: Output
+            }], portalContentTemplate: [{
+                type: ContentChild,
+                args: [NgtPortalContent, { read: TemplateRef, static: true }]
+            }], portalContentAnchor: [{
+                type: ViewChild,
+                args: ['portalContentAnchor', { read: ViewContainerRef, static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portal.js","sourceRoot":"","sources":["../../../../../libs/angular-three/src/lib/portal.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport {\n    Component,\n    ContentChild,\n    Directive,\n    ElementRef,\n    EmbeddedViewRef,\n    EventEmitter,\n    inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    SkipSelf,\n    TemplateRef,\n    ViewChild,\n    ViewContainerRef,\n} from '@angular/core';\nimport * as THREE from 'three';\nimport { injectNgtRef } from './di/ref';\nimport { NgtRxStore } from './stores/rx-store';\nimport { NgtStore } from './stores/store';\nimport { NgtEventManager, NgtRenderState, NgtSize, NgtState } from './types';\nimport { getLocalState, prepare } from './utils/instance';\nimport { is } from './utils/is';\nimport { updateCamera } from './utils/update';\n\nconst privateKeys = [\n    'get',\n    'set',\n    'select',\n    'setSize',\n    'setDpr',\n    'setFrameloop',\n    'events',\n    'invalidate',\n    'advance',\n    'size',\n    'viewport',\n    'addInteraction',\n    'removeInteraction',\n] as const;\ntype PrivateKeys = (typeof privateKeys)[number];\n\nexport interface NgtPortalInputs {\n    container: ElementRef<THREE.Object3D> | THREE.Object3D;\n    camera: ElementRef<THREE.Camera> | THREE.Camera;\n    state: Partial<\n        Omit<NgtState, PrivateKeys> & {\n            events: Partial<Pick<NgtEventManager<any>, 'enabled' | 'priority' | 'compute' | 'connected'>>;\n            size: NgtSize;\n        }\n    >;\n}\n\n@Directive({ selector: '[ngtPortalBeforeRender]', standalone: true })\nexport class NgtPortalBeforeRender implements OnInit, OnDestroy {\n    private readonly portalStore = inject(NgtStore);\n\n    @Input() renderPriority = 1;\n    @Input() parentScene!: THREE.Scene;\n    @Input() parentCamera!: THREE.Camera;\n\n    @Output() beforeRender = new EventEmitter<NgtRenderState>();\n\n    private subscription?: () => void;\n\n    ngOnInit() {\n        let oldClear: boolean;\n        this.subscription = this.portalStore.get('internal').subscribe(\n            ({ delta, frame }) => {\n                this.beforeRender.emit({ ...this.portalStore.get(), delta, frame });\n                const { gl, scene, camera } = this.portalStore.get();\n                oldClear = gl.autoClear;\n                if (this.renderPriority === 1) {\n                    // clear scene and render with default\n                    gl.autoClear = true;\n                    gl.render(this.parentScene, this.parentCamera);\n                }\n                // disable cleaning\n                gl.autoClear = false;\n                gl.clearDepth();\n                gl.render(scene, camera);\n                // restore\n                gl.autoClear = oldClear;\n            },\n            this.renderPriority,\n            this.portalStore\n        );\n    }\n\n    ngOnDestroy() {\n        this.subscription?.();\n    }\n}\n\n@Directive({ selector: 'ng-template[ngtPortalContent]', standalone: true })\nexport class NgtPortalContent {\n    constructor(vcr: ViewContainerRef, @SkipSelf() parentVcr: ViewContainerRef) {\n        const commentNode = vcr.element.nativeElement;\n        if (commentNode['__ngt_renderer_add_comment__']) {\n            commentNode['__ngt_renderer_add_comment__'](parentVcr.element.nativeElement);\n            delete commentNode['__ngt_renderer_add_comment__'];\n        }\n    }\n}\n\n@Component({\n    selector: 'ngt-portal',\n    standalone: true,\n    template: `\n        <ng-container #portalContentAnchor>\n            <ng-container\n                *ngIf=\"autoRender && portalContentRendered\"\n                ngtPortalBeforeRender\n                [renderPriority]=\"autoRenderPriority\"\n                [parentScene]=\"parentScene\"\n                [parentCamera]=\"parentCamera\"\n                (beforeRender)=\"onBeforeRender($event)\"\n            />\n        </ng-container>\n    `,\n    imports: [NgIf, NgtPortalBeforeRender],\n    providers: [NgtStore],\n})\nexport class NgtPortal extends NgtRxStore<NgtPortalInputs> implements OnInit, OnDestroy {\n    @Input() set container(container: NgtPortalInputs['container']) {\n        this.set({ container });\n    }\n\n    @Input() set state(state: NgtPortalInputs['state']) {\n        this.set({ state });\n    }\n\n    @Input() autoRender = true;\n    @Input() autoRenderPriority = 1;\n\n    @Output() beforeRender = new EventEmitter<{ root: NgtRenderState; portal: NgtRenderState }>();\n\n    @ContentChild(NgtPortalContent, { read: TemplateRef, static: true })\n    readonly portalContentTemplate!: TemplateRef<unknown>;\n\n    @ViewChild('portalContentAnchor', { read: ViewContainerRef, static: true })\n    readonly portalContentAnchor!: ViewContainerRef;\n\n    private readonly parentStore = inject(NgtStore, { skipSelf: true });\n    readonly parentScene = this.parentStore.get('scene');\n    readonly parentCamera = this.parentStore.get('camera');\n\n    private readonly portalStore = inject(NgtStore, { self: true });\n\n    private readonly raycaster = new THREE.Raycaster();\n    private readonly pointer = new THREE.Vector2();\n\n    portalContentRendered = false;\n    private portalContentView?: EmbeddedViewRef<unknown>;\n\n    override initialize() {\n        super.initialize();\n        this.set({ container: injectNgtRef<THREE.Scene>(prepare(new THREE.Scene())) });\n    }\n\n    ngOnInit() {\n        const previousState = this.parentStore.get();\n        const inputsState = this.get();\n\n        if (!inputsState.state && this.autoRender) {\n            inputsState.state = { events: { priority: this.autoRenderPriority + 1 } };\n        }\n\n        const { events, size, ...restInputsState } = inputsState.state || {};\n\n        const containerState = inputsState.container;\n        const container = is.ref(containerState) ? containerState.nativeElement : containerState;\n\n        const localState = getLocalState(container);\n        if (!localState.store) {\n            localState.store = this.portalStore;\n        }\n\n        this.portalStore.set({\n            ...previousState,\n            scene: container as THREE.Scene,\n            raycaster: this.raycaster,\n            pointer: this.pointer,\n            previousStore: this.parentStore,\n            events: { ...previousState.events, ...(events || {}) },\n            size: { ...previousState.size, ...(size || {}) },\n            ...restInputsState,\n            get: this.portalStore.get.bind(this.portalStore),\n            set: this.portalStore.set.bind(this.portalStore),\n            select: this.portalStore.select.bind(this.portalStore),\n            setEvents: (events) =>\n                this.portalStore.set((state) => ({ ...state, events: { ...state.events, ...events } })),\n        });\n\n        this.hold(this.parentStore.select(), (previous) =>\n            this.portalStore.set((state) => this.inject(previous, state))\n        );\n\n        requestAnimationFrame(() => {\n            this.portalStore.set((injectState) => this.inject(this.parentStore.get(), injectState));\n        });\n        this.portalContentView = this.portalContentAnchor.createEmbeddedView(this.portalContentTemplate);\n        this.portalContentView.detectChanges();\n        this.portalContentRendered = true;\n    }\n\n    onBeforeRender(portal: NgtRenderState) {\n        this.beforeRender.emit({\n            root: { ...this.parentStore.get(), delta: portal.delta, frame: portal.frame },\n            portal,\n        });\n    }\n\n    override ngOnDestroy() {\n        if (this.portalContentView && !this.portalContentView.destroyed) {\n            this.portalContentView.destroy();\n        }\n        super.ngOnDestroy();\n    }\n\n    private inject(rootState: NgtState, injectState: NgtState) {\n        const intersect: Partial<NgtState> = { ...rootState };\n\n        Object.keys(intersect).forEach((key) => {\n            if (\n                privateKeys.includes(key as PrivateKeys) ||\n                rootState[key as keyof NgtState] !== injectState[key as keyof NgtState]\n            ) {\n                delete intersect[key as keyof NgtState];\n            }\n        });\n\n        const inputs = this.get();\n        const { size, events, ...restInputsState } = inputs.state || {};\n\n        let viewport = undefined;\n        if (injectState && size) {\n            const camera = injectState.camera;\n            viewport = rootState.viewport.getCurrentViewport(camera, new THREE.Vector3(), size);\n            if (camera !== rootState.camera) updateCamera(camera, size);\n        }\n\n        return {\n            ...intersect,\n            scene: is.ref(inputs.container) ? inputs.container.nativeElement : inputs.container,\n            raycaster: this.raycaster,\n            pointer: this.pointer,\n            previousStore: this.parentStore,\n            events: { ...rootState.events, ...(injectState?.events || {}), ...events },\n            size: { ...rootState.size, ...size },\n            viewport: { ...rootState.viewport, ...(viewport || {}) },\n            ...restInputsState,\n        } as NgtState;\n    }\n}\n"]}