angular-three-soba 1.13.0 → 2.0.0-beta.2

package/esm2022/abstractions/gizmo-helper/gizmo-helper.mjs

@@ -0,0 +1,210 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { Component, computed, ContentChild, CUSTOM_ELEMENTS_SCHEMA, Directive, effect, EventEmitter, inject, InjectionToken, Input, Output, TemplateRef, } from '@angular/core';
+import { extend, injectNgtRef, NgtPortal, NgtPortalContent, NgtSignalStore, NgtStore } from 'angular-three';
+import { NgtsOrthographicCamera } from 'angular-three-soba/cameras';
+import { Group, Matrix4, Object3D, Quaternion, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+const isOrbitControls = (controls) => 'minPolarAngle' in controls;
+export const NGTS_GIZMO_HELPER_API = new InjectionToken('NgtsGizmoHelper API');
+extend({ Group });
+class NgtsGizmoHelperContent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoHelperContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoHelperContent, isStandalone: true, selector: "ng-template[ngtsGizmoHelperContent]", ngImport: i0 }); }
+}
+export { NgtsGizmoHelperContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoHelperContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[ngtsGizmoHelperContent]', standalone: true }]
+        }] });
+class NgtsGizmoHelper extends NgtSignalStore {
+    set alignment(alignment) {
+        this.set({ alignment });
+    }
+    set margin(margin) {
+        this.set({ margin });
+    }
+    set renderPriority(renderPriority) {
+        this.set({ renderPriority });
+    }
+    set autoClear(autoClear) {
+        this.set({ autoClear });
+    }
+    #store;
+    #camera;
+    #size;
+    #alignment;
+    #margin;
+    #animating;
+    #radius;
+    #focusPoint;
+    #q1;
+    #q2;
+    #target;
+    #targetPosition;
+    #dummy;
+    #defaultUp;
+    #turnRate; // turn rate in angles per sec
+    #matrix;
+    constructor() {
+        super({ alignment: 'bottom-right', margin: [80, 80], renderPriority: 1 });
+        this.gizmoRef = injectNgtRef();
+        this.virtualCameraRef = injectNgtRef();
+        this.updated = new EventEmitter();
+        this.#store = inject(NgtStore);
+        this.#camera = this.#store.select('camera');
+        this.#size = this.#store.select('size');
+        this.#alignment = this.select('alignment');
+        this.#margin = this.select('margin');
+        this.#animating = false;
+        this.#radius = 0;
+        this.#focusPoint = new Vector3(0, 0, 0);
+        this.#q1 = new Quaternion();
+        this.#q2 = new Quaternion();
+        this.#target = new Vector3();
+        this.#targetPosition = new Vector3();
+        this.#dummy = new Object3D();
+        this.#defaultUp = new Vector3(0, 0, 0);
+        this.#turnRate = 2 * Math.PI; // turn rate in angles per sec
+        this.#matrix = new Matrix4();
+        this.priority = this.select('renderPriority');
+        this.position = computed(() => {
+            const size = this.#size();
+            const alignment = this.#alignment();
+            const margin = this.#margin();
+            const [marginX, marginY] = margin;
+            const x = alignment.endsWith('-center')
+                ? 0
+                : alignment.endsWith('-left')
+                    ? -size.width / 2 + marginX
+                    : size.width / 2 - marginX;
+            const y = alignment.startsWith('center-')
+                ? 0
+                : alignment.startsWith('top-')
+                    ? size.height / 2 - marginY
+                    : -size.height / 2 + marginY;
+            return [x, y, 0];
+        });
+        this.api = computed(() => (direction) => {
+            const { controls, camera, invalidate } = this.#store.get();
+            const defaultControls = controls;
+            this.#animating = true;
+            if (defaultControls)
+                this.#focusPoint = defaultControls.target;
+            this.#radius = camera.position.distanceTo(this.#target);
+            // rotate from current camera orientation
+            this.#q1.copy(camera.quaternion);
+            // to new current camera orientation
+            this.#targetPosition.copy(direction).multiplyScalar(this.#radius).add(this.#target);
+            this.#dummy.lookAt(this.#targetPosition);
+            this.#q2.copy(this.#dummy.quaternion);
+            invalidate();
+        });
+        this.#updateDefaultUp();
+    }
+    onBeforeRender(delta) {
+        if (this.virtualCameraRef.nativeElement && this.gizmoRef.nativeElement) {
+            const { controls, camera: mainCamera, invalidate } = this.#store.get();
+            const defaultControls = controls;
+            // Animate step
+            if (this.#animating) {
+                if (this.#q1.angleTo(this.#q2) < 0.01) {
+                    this.#animating = false;
+                    // Orbit controls uses UP vector as the orbit axes,
+                    // so we need to reset it after the animation is done
+                    // moving it around for the controls to work correctly
+                    if (isOrbitControls(defaultControls)) {
+                        mainCamera.up.copy(this.#defaultUp);
+                    }
+                }
+                else {
+                    const step = delta * this.#turnRate;
+                    // animate position by doing a slerp and then scaling the position on the unit sphere
+                    this.#q1.rotateTowards(this.#q2, step);
+                    // animate orientation
+                    mainCamera.position
+                        .set(0, 0, 1)
+                        .applyQuaternion(this.#q1)
+                        .multiplyScalar(this.#radius)
+                        .add(this.#focusPoint);
+                    mainCamera.up.set(0, 1, 0).applyQuaternion(this.#q1).normalize();
+                    mainCamera.quaternion.copy(this.#q1);
+                    if (this.updated.observed)
+                        this.updated.emit();
+                    else if (defaultControls) {
+                        defaultControls.update();
+                    }
+                    invalidate();
+                }
+            }
+            // Sync Gizmo with main camera orientation
+            this.#matrix.copy(mainCamera.matrix).invert();
+            this.gizmoRef.nativeElement.quaternion.setFromRotationMatrix(this.#matrix);
+        }
+    }
+    #updateDefaultUp() {
+        effect(() => {
+            const camera = this.#camera();
+            if (!camera)
+                return;
+            this.#defaultUp.copy(camera.up);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoHelper, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoHelper, isStandalone: true, selector: "ngts-gizmo-helper", inputs: { alignment: "alignment", margin: "margin", renderPriority: "renderPriority", autoClear: "autoClear" }, outputs: { updated: "updated" }, providers: [
+            { provide: NGTS_GIZMO_HELPER_API, useFactory: (gizmo) => gizmo.api, deps: [NgtsGizmoHelper] },
+        ], queries: [{ propertyName: "gizmoHelperContent", first: true, predicate: NgtsGizmoHelperContent, descendants: true, read: TemplateRef, static: true }], usesInheritance: true, ngImport: i0, template: `
+        <ngt-portal [renderPriority]="priority()">
+            <ng-template ngtPortalContent>
+                <ngts-orthographic-camera
+                    [cameraRef]="virtualCameraRef"
+                    [makeDefault]="true"
+                    [position]="[0, 0, 200]"
+                />
+                <ngt-group [ref]="gizmoRef" [position]="position()" (beforeRender)="onBeforeRender($event.state.delta)">
+                    <ng-container *ngTemplateOutlet="gizmoHelperContent" />
+                </ngt-group>
+            </ng-template>
+        </ngt-portal>
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"], outputs: ["beforeRender"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[ngtPortalContent]" }, { kind: "component", type: NgtsOrthographicCamera, selector: "ngts-orthographic-camera", inputs: ["left", "right", "top", "bottom"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+export { NgtsGizmoHelper };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoHelper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-helper',
+                    standalone: true,
+                    template: `
+        <ngt-portal [renderPriority]="priority()">
+            <ng-template ngtPortalContent>
+                <ngts-orthographic-camera
+                    [cameraRef]="virtualCameraRef"
+                    [makeDefault]="true"
+                    [position]="[0, 0, 200]"
+                />
+                <ngt-group [ref]="gizmoRef" [position]="position()" (beforeRender)="onBeforeRender($event.state.delta)">
+                    <ng-container *ngTemplateOutlet="gizmoHelperContent" />
+                </ngt-group>
+            </ng-template>
+        </ngt-portal>
+    `,
+                    imports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],
+                    providers: [
+                        { provide: NGTS_GIZMO_HELPER_API, useFactory: (gizmo) => gizmo.api, deps: [NgtsGizmoHelper] },
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { alignment: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], renderPriority: [{
+                type: Input
+            }], autoClear: [{
+                type: Input
+            }], updated: [{
+                type: Output
+            }], gizmoHelperContent: [{
+                type: ContentChild,
+                args: [NgtsGizmoHelperContent, { static: true, read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo-helper.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/gizmo-helper/gizmo-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n    Component,\n    computed,\n    ContentChild,\n    CUSTOM_ELEMENTS_SCHEMA,\n    Directive,\n    effect,\n    EventEmitter,\n    inject,\n    InjectionToken,\n    Input,\n    Output,\n    Signal,\n    TemplateRef,\n} from '@angular/core';\nimport { extend, injectNgtRef, NgtPortal, NgtPortalContent, NgtSignalStore, NgtStore } from 'angular-three';\nimport { NgtsOrthographicCamera } from 'angular-three-soba/cameras';\nimport { Group, Matrix4, Object3D, OrthographicCamera, Quaternion, Vector3 } from 'three';\nimport { OrbitControls } from 'three-stdlib';\n\ntype ControlsProto = { update(): void; target: THREE.Vector3 };\n\nconst isOrbitControls = (controls: ControlsProto): controls is OrbitControls =>\n    'minPolarAngle' in (controls as OrbitControls);\n\nexport type NgtsGizmoHelperApi = (direction: Vector3) => void;\nexport const NGTS_GIZMO_HELPER_API = new InjectionToken<Signal<NgtsGizmoHelperApi>>('NgtsGizmoHelper API');\n\nextend({ Group });\n\nexport interface NgtsGizmoHelperState {\n    alignment:\n        | 'top-left'\n        | 'top-right'\n        | 'bottom-right'\n        | 'bottom-left'\n        | 'bottom-center'\n        | 'center-right'\n        | 'center-left'\n        | 'center-center'\n        | 'top-center';\n    margin: [number, number];\n    renderPriority: number;\n    autoClear: boolean;\n}\n\n@Directive({ selector: 'ng-template[ngtsGizmoHelperContent]', standalone: true })\nexport class NgtsGizmoHelperContent {}\n\n@Component({\n    selector: 'ngts-gizmo-helper',\n    standalone: true,\n    template: `\n        <ngt-portal [renderPriority]=\"priority()\">\n            <ng-template ngtPortalContent>\n                <ngts-orthographic-camera\n                    [cameraRef]=\"virtualCameraRef\"\n                    [makeDefault]=\"true\"\n                    [position]=\"[0, 0, 200]\"\n                />\n                <ngt-group [ref]=\"gizmoRef\" [position]=\"position()\" (beforeRender)=\"onBeforeRender($event.state.delta)\">\n                    <ng-container *ngTemplateOutlet=\"gizmoHelperContent\" />\n                </ngt-group>\n            </ng-template>\n        </ngt-portal>\n    `,\n    imports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],\n    providers: [\n        { provide: NGTS_GIZMO_HELPER_API, useFactory: (gizmo: NgtsGizmoHelper) => gizmo.api, deps: [NgtsGizmoHelper] },\n    ],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsGizmoHelper extends NgtSignalStore<NgtsGizmoHelperState> {\n    readonly gizmoRef = injectNgtRef<Group>();\n    readonly virtualCameraRef = injectNgtRef<OrthographicCamera>();\n\n    @Input() set alignment(\n        alignment:\n            | 'top-left'\n            | 'top-right'\n            | 'bottom-right'\n            | 'bottom-left'\n            | 'bottom-center'\n            | 'center-right'\n            | 'center-left'\n            | 'center-center'\n            | 'top-center'\n    ) {\n        this.set({ alignment });\n    }\n\n    @Input() set margin(margin: [number, number]) {\n        this.set({ margin });\n    }\n\n    @Input() set renderPriority(renderPriority: number) {\n        this.set({ renderPriority });\n    }\n\n    @Input() set autoClear(autoClear: boolean) {\n        this.set({ autoClear });\n    }\n\n    @Output() updated = new EventEmitter<void>();\n\n    @ContentChild(NgtsGizmoHelperContent, { static: true, read: TemplateRef })\n    gizmoHelperContent!: TemplateRef<unknown>;\n\n    readonly #store = inject(NgtStore);\n    readonly #camera = this.#store.select('camera');\n    readonly #size = this.#store.select('size');\n\n    readonly #alignment = this.select('alignment');\n    readonly #margin = this.select('margin');\n\n    #animating = false;\n    #radius = 0;\n    #focusPoint = new Vector3(0, 0, 0);\n    #q1 = new Quaternion();\n    #q2 = new Quaternion();\n    #target = new Vector3();\n    #targetPosition = new Vector3();\n    #dummy = new Object3D();\n\n    #defaultUp = new Vector3(0, 0, 0);\n    #turnRate = 2 * Math.PI; // turn rate in angles per sec\n    #matrix = new Matrix4();\n\n    readonly priority = this.select('renderPriority');\n\n    readonly position = computed(() => {\n        const size = this.#size();\n        const alignment = this.#alignment();\n        const margin = this.#margin();\n\n        const [marginX, marginY] = margin;\n        const x = alignment.endsWith('-center')\n            ? 0\n            : alignment.endsWith('-left')\n            ? -size.width / 2 + marginX\n            : size.width / 2 - marginX;\n        const y = alignment.startsWith('center-')\n            ? 0\n            : alignment.startsWith('top-')\n            ? size.height / 2 - marginY\n            : -size.height / 2 + marginY;\n\n        return [x, y, 0];\n    });\n\n    readonly api = computed(() => (direction: THREE.Vector3) => {\n        const { controls, camera, invalidate } = this.#store.get();\n        const defaultControls = controls as unknown as ControlsProto;\n\n        this.#animating = true;\n        if (defaultControls) this.#focusPoint = defaultControls.target;\n        this.#radius = camera.position.distanceTo(this.#target);\n        // rotate from current camera orientation\n        this.#q1.copy(camera.quaternion);\n        // to new current camera orientation\n        this.#targetPosition.copy(direction).multiplyScalar(this.#radius).add(this.#target);\n        this.#dummy.lookAt(this.#targetPosition);\n        this.#q2.copy(this.#dummy.quaternion);\n        invalidate();\n    });\n\n    constructor() {\n        super({ alignment: 'bottom-right', margin: [80, 80], renderPriority: 1 });\n        this.#updateDefaultUp();\n    }\n\n    onBeforeRender(delta: number) {\n        if (this.virtualCameraRef.nativeElement && this.gizmoRef.nativeElement) {\n            const { controls, camera: mainCamera, invalidate } = this.#store.get();\n            const defaultControls = controls as unknown as ControlsProto;\n            // Animate step\n            if (this.#animating) {\n                if (this.#q1.angleTo(this.#q2) < 0.01) {\n                    this.#animating = false;\n                    // Orbit controls uses UP vector as the orbit axes,\n                    // so we need to reset it after the animation is done\n                    // moving it around for the controls to work correctly\n                    if (isOrbitControls(defaultControls)) {\n                        mainCamera.up.copy(this.#defaultUp);\n                    }\n                } else {\n                    const step = delta * this.#turnRate;\n                    // animate position by doing a slerp and then scaling the position on the unit sphere\n                    this.#q1.rotateTowards(this.#q2, step);\n                    // animate orientation\n                    mainCamera.position\n                        .set(0, 0, 1)\n                        .applyQuaternion(this.#q1)\n                        .multiplyScalar(this.#radius)\n                        .add(this.#focusPoint);\n                    mainCamera.up.set(0, 1, 0).applyQuaternion(this.#q1).normalize();\n                    mainCamera.quaternion.copy(this.#q1);\n                    if (this.updated.observed) this.updated.emit();\n                    else if (defaultControls) {\n                        defaultControls.update();\n                    }\n                    invalidate();\n                }\n            }\n\n            // Sync Gizmo with main camera orientation\n            this.#matrix.copy(mainCamera.matrix).invert();\n            this.gizmoRef.nativeElement.quaternion.setFromRotationMatrix(this.#matrix);\n        }\n    }\n\n    #updateDefaultUp() {\n        effect(() => {\n            const camera = this.#camera();\n            if (!camera) return;\n            this.#defaultUp.copy(camera.up);\n        });\n    }\n}\n"]}

package/esm2022/abstractions/gizmo-helper/gizmo-viewcube/constants.mjs

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+export const colors = { bg: '#f0f0f0', hover: '#999', text: 'black', stroke: 'black' };
+export const defaultFaces = ['Right', 'Left', 'Top', 'Bottom', 'Front', 'Back'];
+const makePositionVector = (xyz) => new THREE.Vector3(...xyz).multiplyScalar(0.38);
+export const corners = [
+    [1, 1, 1],
+    [1, 1, -1],
+    [1, -1, 1],
+    [1, -1, -1],
+    [-1, 1, 1],
+    [-1, 1, -1],
+    [-1, -1, 1],
+    [-1, -1, -1],
+].map(makePositionVector);
+export const cornerDimensions = [0.25, 0.25, 0.25];
+export const edges = [
+    [1, 1, 0],
+    [1, 0, 1],
+    [1, 0, -1],
+    [1, -1, 0],
+    [0, 1, 1],
+    [0, 1, -1],
+    [0, -1, 1],
+    [0, -1, -1],
+    [-1, 1, 0],
+    [-1, 0, 1],
+    [-1, 0, -1],
+    [-1, -1, 0],
+].map(makePositionVector);
+export const edgeDimensions = edges.map((edge) => edge.toArray().map((axis) => (axis == 0 ? 0.5 : 0.25)));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-edge.mjs

@@ -0,0 +1,95 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, Input, signal } from '@angular/core';
+import { extend, NgtArgs, NgtSignalStore } from 'angular-three';
+import { BoxGeometry, Mesh, MeshBasicMaterial, Vector3 } from 'three';
+import { NGTS_GIZMO_HELPER_API } from '../gizmo-helper';
+import { colors } from './constants';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+extend({ Mesh, BoxGeometry, MeshBasicMaterial });
+class NgtsGizmoViewcubeEdgeCube extends NgtSignalStore {
+    #gizmoHelperApi;
+    set dimensions(dimensions) {
+        this.set({ dimensions });
+    }
+    set position(position) {
+        this.set({ position });
+    }
+    constructor() {
+        super();
+        this.#gizmoHelperApi = inject(NGTS_GIZMO_HELPER_API);
+        this.viewcubeInputs = inject(NgtsGizmoViewcubeInputs);
+        this.hover = signal(false);
+        this.edgePosition = this.select('position');
+        this.edgeDimensions = this.select('dimensions');
+        this.viewcubeInputs.patch({ hoverColor: colors.hover });
+    }
+    onPointerMove(event) {
+        event.stopPropagation();
+        this.hover.set(true);
+    }
+    onPointerOut(event) {
+        event.stopPropagation();
+        this.hover.set(false);
+    }
+    onClick(event) {
+        if (this.viewcubeInputs.get('clickEmitter')?.observed) {
+            this.viewcubeInputs.get('clickEmitter').emit(event);
+        }
+        else {
+            event.stopPropagation();
+            this.#gizmoHelperApi()(this.get('position'));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeEdgeCube, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoViewcubeEdgeCube, isStandalone: true, selector: "ngts-gizmo-viewcube-edge-cube", inputs: { dimensions: "dimensions", position: "position" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh
+            [scale]="1.01"
+            [position]="edgePosition()"
+            (pointermove)="onPointerMove($event)"
+            (pointerout)="onPointerOut($event)"
+            (click)="onClick($event)"
+        >
+            <ngt-box-geometry *args="edgeDimensions()" />
+            <ngt-mesh-basic-material
+                [color]="hover() ? viewcubeInputs.viewcubeHoverColor() : 'white'"
+                [transparent]="true"
+                [opacity]="0.6"
+                [visible]="hover()"
+            />
+        </ngt-mesh>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsGizmoViewcubeEdgeCube };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeEdgeCube, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-viewcube-edge-cube',
+                    standalone: true,
+                    template: `
+        <ngt-mesh
+            [scale]="1.01"
+            [position]="edgePosition()"
+            (pointermove)="onPointerMove($event)"
+            (pointerout)="onPointerOut($event)"
+            (click)="onClick($event)"
+        >
+            <ngt-box-geometry *args="edgeDimensions()" />
+            <ngt-mesh-basic-material
+                [color]="hover() ? viewcubeInputs.viewcubeHoverColor() : 'white'"
+                [transparent]="true"
+                [opacity]="0.6"
+                [visible]="hover()"
+            />
+        </ngt-mesh>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { dimensions: [{
+                type: Input,
+                args: [{ required: true }]
+            }], position: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-face.mjs

@@ -0,0 +1,155 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input, signal } from '@angular/core';
+import { extend, NgtRepeat, NgtSignalStore, NgtStore } from 'angular-three';
+import { BoxGeometry, CanvasTexture, Mesh, MeshLambertMaterial } from 'three';
+import { NGTS_GIZMO_HELPER_API } from '../gizmo-helper';
+import { colors, defaultFaces } from './constants';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+extend({ MeshLambertMaterial, Mesh, BoxGeometry });
+class NgtsGizmoViewcubeFaceMaterial extends NgtSignalStore {
+    #document;
+    #store;
+    set index(index) {
+        this.set({ index });
+    }
+    set hover(hover) {
+        this.set({ hover });
+    }
+    constructor() {
+        super();
+        this.#document = inject(DOCUMENT);
+        this.#store = inject(NgtStore);
+        this.gl = this.#store.select('gl');
+        this.viewcubeInputs = inject(NgtsGizmoViewcubeInputs);
+        this.faceIndex = this.select('index');
+        this.faceHover = this.select('hover');
+        this.texture = computed(() => {
+            const index = this.faceIndex();
+            const color = this.viewcubeInputs.viewcubeColor();
+            const font = this.viewcubeInputs.viewcubeFont();
+            const faces = this.viewcubeInputs.viewcubeFaces();
+            const textColor = this.viewcubeInputs.viewcubeTextColor();
+            const strokeColor = this.viewcubeInputs.viewcubeStrokeColor();
+            const canvas = this.#document.createElement('canvas');
+            canvas.width = 128;
+            canvas.height = 128;
+            const context = canvas.getContext('2d');
+            context.fillStyle = color;
+            context.fillRect(0, 0, canvas.width, canvas.height);
+            context.strokeStyle = strokeColor;
+            context.strokeRect(0, 0, canvas.width, canvas.height);
+            context.font = font;
+            context.textAlign = 'center';
+            context.fillStyle = textColor;
+            context.fillText(faces[index].toUpperCase(), 64, 76);
+            return new CanvasTexture(canvas);
+        });
+        this.viewcubeInputs.patch({
+            color: colors.bg,
+            font: '20px Inter var, Arial, sans-serif',
+            faces: defaultFaces,
+            hoverColor: colors.hover,
+            textColor: colors.text,
+            strokeColor: colors.stroke,
+            opacity: 1,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeFaceMaterial, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoViewcubeFaceMaterial, isStandalone: true, selector: "ngts-gizmo-viewcube-face-material", inputs: { index: "index", hover: "hover" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-mesh-lambert-material
+            [attach]="['material', faceIndex()]"
+            [map]="texture()"
+            [color]="faceHover() ? viewcubeInputs.viewcubeHoverColor() : viewcubeInputs.viewcubeColor()"
+            [opacity]="viewcubeInputs.viewcubeOpacity()"
+            [transparent]="true"
+        >
+            <ngt-value [rawValue]="gl().outputEncoding" attach="map.encoding" />
+            <ngt-value [rawValue]="gl().capabilities.getMaxAnisotropy() || 1" attach="map.anisotrophy" />
+        </ngt-mesh-lambert-material>
+    `, isInline: true }); }
+}
+export { NgtsGizmoViewcubeFaceMaterial };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeFaceMaterial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-viewcube-face-material',
+                    standalone: true,
+                    template: `
+        <ngt-mesh-lambert-material
+            [attach]="['material', faceIndex()]"
+            [map]="texture()"
+            [color]="faceHover() ? viewcubeInputs.viewcubeHoverColor() : viewcubeInputs.viewcubeColor()"
+            [opacity]="viewcubeInputs.viewcubeOpacity()"
+            [transparent]="true"
+        >
+            <ngt-value [rawValue]="gl().outputEncoding" attach="map.encoding" />
+            <ngt-value [rawValue]="gl().capabilities.getMaxAnisotropy() || 1" attach="map.anisotrophy" />
+        </ngt-mesh-lambert-material>
+    `,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { index: [{
+                type: Input,
+                args: [{ required: true }]
+            }], hover: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+class NgtsGizmoViewcubeFaceCube {
+    constructor() {
+        this.#gizmoHelperApi = inject(NGTS_GIZMO_HELPER_API);
+        this.viewcubeInputs = inject(NgtsGizmoViewcubeInputs);
+        this.hover = signal(-1);
+    }
+    #gizmoHelperApi;
+    onPointerMove(event) {
+        event.stopPropagation();
+        this.hover.set(Math.floor(event.faceIndex / 2));
+    }
+    onPointerOut(event) {
+        event.stopPropagation();
+        this.hover.set(-1);
+    }
+    onClick(event) {
+        if (this.viewcubeInputs.get('clickEmitter')?.observed) {
+            this.viewcubeInputs.get('clickEmitter').emit(event);
+        }
+        else {
+            event.stopPropagation();
+            this.#gizmoHelperApi()(event.face.normal);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeFaceCube, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoViewcubeFaceCube, isStandalone: true, selector: "ngts-gizmo-viewcube-face-cube", ngImport: i0, template: `
+        <ngt-mesh
+            (pointermove)="onPointerMove($any($event))"
+            (pointerout)="onPointerOut($any($event))"
+            (click)="onClick($any($event))"
+        >
+            <ngt-box-geometry />
+            <ngts-gizmo-viewcube-face-material *ngFor="let i; repeat: 6" [hover]="hover() === i" [index]="i" />
+        </ngt-mesh>
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsGizmoViewcubeFaceMaterial, selector: "ngts-gizmo-viewcube-face-material", inputs: ["index", "hover"] }, { kind: "directive", type: NgtRepeat, selector: "[ngFor][ngForRepeat]", inputs: ["ngForRepeat"] }] }); }
+}
+export { NgtsGizmoViewcubeFaceCube };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeFaceCube, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-viewcube-face-cube',
+                    standalone: true,
+                    template: `
+        <ngt-mesh
+            (pointermove)="onPointerMove($any($event))"
+            (pointerout)="onPointerOut($any($event))"
+            (click)="onClick($any($event))"
+        >
+            <ngt-box-geometry />
+            <ngts-gizmo-viewcube-face-material *ngFor="let i; repeat: 6" [hover]="hover() === i" [index]="i" />
+        </ngt-mesh>
+    `,
+                    imports: [NgtsGizmoViewcubeFaceMaterial, NgtRepeat],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo-viewcube-face.js","sourceRoot":"","sources":["../../../../../../../libs/soba/abstractions/src/gizmo-helper/gizmo-viewcube/gizmo-viewcube-face.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, Input, signal } from '@angular/core';\nimport { extend, NgtRepeat, NgtSignalStore, NgtStore, NgtThreeEvent } from 'angular-three';\nimport { BoxGeometry, CanvasTexture, Mesh, MeshLambertMaterial } from 'three';\nimport { NGTS_GIZMO_HELPER_API } from '../gizmo-helper';\nimport { colors, defaultFaces } from './constants';\nimport { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';\n\nextend({ MeshLambertMaterial, Mesh, BoxGeometry });\n\n@Component({\n    selector: 'ngts-gizmo-viewcube-face-material',\n    standalone: true,\n    template: `\n        <ngt-mesh-lambert-material\n            [attach]=\"['material', faceIndex()]\"\n            [map]=\"texture()\"\n            [color]=\"faceHover() ? viewcubeInputs.viewcubeHoverColor() : viewcubeInputs.viewcubeColor()\"\n            [opacity]=\"viewcubeInputs.viewcubeOpacity()\"\n            [transparent]=\"true\"\n        >\n            <ngt-value [rawValue]=\"gl().outputEncoding\" attach=\"map.encoding\" />\n            <ngt-value [rawValue]=\"gl().capabilities.getMaxAnisotropy() || 1\" attach=\"map.anisotrophy\" />\n        </ngt-mesh-lambert-material>\n    `,\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsGizmoViewcubeFaceMaterial extends NgtSignalStore<{\n    index: number;\n    hover: boolean;\n}> {\n    readonly #document = inject(DOCUMENT);\n    readonly #store = inject(NgtStore);\n    protected readonly gl = this.#store.select('gl');\n    protected readonly viewcubeInputs = inject(NgtsGizmoViewcubeInputs);\n\n    @Input({ required: true }) set index(index: number) {\n        this.set({ index });\n    }\n\n    @Input({ required: true }) set hover(hover: boolean) {\n        this.set({ hover });\n    }\n\n    readonly faceIndex = this.select('index');\n    readonly faceHover = this.select('hover');\n\n    readonly texture = computed(() => {\n        const index = this.faceIndex();\n        const color = this.viewcubeInputs.viewcubeColor();\n        const font = this.viewcubeInputs.viewcubeFont();\n        const faces = this.viewcubeInputs.viewcubeFaces();\n        const textColor = this.viewcubeInputs.viewcubeTextColor();\n        const strokeColor = this.viewcubeInputs.viewcubeStrokeColor();\n\n        const canvas = this.#document.createElement('canvas');\n        canvas.width = 128;\n        canvas.height = 128;\n        const context = canvas.getContext('2d')!;\n        context.fillStyle = color!;\n        context.fillRect(0, 0, canvas.width, canvas.height);\n        context.strokeStyle = strokeColor;\n        context.strokeRect(0, 0, canvas.width, canvas.height);\n        context.font = font!;\n        context.textAlign = 'center';\n        context.fillStyle = textColor;\n        context.fillText(faces[index].toUpperCase(), 64, 76);\n\n        return new CanvasTexture(canvas);\n    });\n\n    constructor() {\n        super();\n        this.viewcubeInputs.patch({\n            color: colors.bg,\n            font: '20px Inter var, Arial, sans-serif',\n            faces: defaultFaces,\n            hoverColor: colors.hover,\n            textColor: colors.text,\n            strokeColor: colors.stroke,\n            opacity: 1,\n        });\n    }\n}\n\n@Component({\n    selector: 'ngts-gizmo-viewcube-face-cube',\n    standalone: true,\n    template: `\n        <ngt-mesh\n            (pointermove)=\"onPointerMove($any($event))\"\n            (pointerout)=\"onPointerOut($any($event))\"\n            (click)=\"onClick($any($event))\"\n        >\n            <ngt-box-geometry />\n            <ngts-gizmo-viewcube-face-material *ngFor=\"let i; repeat: 6\" [hover]=\"hover() === i\" [index]=\"i\" />\n        </ngt-mesh>\n    `,\n    imports: [NgtsGizmoViewcubeFaceMaterial, NgtRepeat],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsGizmoViewcubeFaceCube {\n    readonly #gizmoHelperApi = inject(NGTS_GIZMO_HELPER_API);\n\n    protected readonly viewcubeInputs = inject(NgtsGizmoViewcubeInputs);\n\n    hover = signal(-1);\n\n    onPointerMove(event: NgtThreeEvent<PointerEvent>) {\n        event.stopPropagation();\n        this.hover.set(Math.floor(event.faceIndex! / 2));\n    }\n\n    onPointerOut(event: NgtThreeEvent<PointerEvent>) {\n        event.stopPropagation();\n        this.hover.set(-1);\n    }\n\n    onClick(event: NgtThreeEvent<MouseEvent>) {\n        if (this.viewcubeInputs.get('clickEmitter')?.observed) {\n            this.viewcubeInputs.get('clickEmitter').emit(event);\n        } else {\n            event.stopPropagation();\n            this.#gizmoHelperApi()(event.face!.normal);\n        }\n    }\n}\n"]}

package/esm2022/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-inputs.mjs

@@ -0,0 +1,62 @@
+import { Directive, Input } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import * as i0 from "@angular/core";
+class NgtsGizmoViewcubeInputs extends NgtSignalStore {
+    constructor() {
+        super(...arguments);
+        this.viewcubeHoverColor = this.select('hoverColor');
+        this.viewcubeOpacity = this.select('opacity');
+        this.viewcubeTextColor = this.select('textColor');
+        this.viewcubeStrokeColor = this.select('strokeColor');
+        this.viewcubeFaces = this.select('faces');
+        this.viewcubeFont = this.select('font');
+        this.viewcubeColor = this.select('color');
+    }
+    set opacity(opacity) {
+        this.set({ opacity });
+    }
+    set hoverColor(hoverColor) {
+        this.set({ hoverColor });
+    }
+    set textColor(textColor) {
+        this.set({ textColor });
+    }
+    set strokeColor(strokeColor) {
+        this.set({ strokeColor });
+    }
+    set faces(faces) {
+        this.set({ faces });
+    }
+    set font(font) {
+        this.set({ font });
+    }
+    set color(color) {
+        this.set({ color });
+    }
+    set clickEmitter(clickEmitter) {
+        this.set({ clickEmitter });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeInputs, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgtsGizmoViewcubeInputs, inputs: { opacity: "opacity", hoverColor: "hoverColor", textColor: "textColor", strokeColor: "strokeColor", faces: "faces", font: "font", color: "color", clickEmitter: "clickEmitter" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { NgtsGizmoViewcubeInputs };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsGizmoViewcubeInputs, decorators: [{
+            type: Directive
+        }], propDecorators: { opacity: [{
+                type: Input
+            }], hoverColor: [{
+                type: Input
+            }], textColor: [{
+                type: Input
+            }], strokeColor: [{
+                type: Input
+            }], faces: [{
+                type: Input
+            }], font: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], clickEmitter: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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