angular-three-soba 2.0.0 → 2.2.0

package/esm2022/gizmos/lib/gizmo-helper/gizmo-helper.mjs

@@ -0,0 +1,187 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, contentChild, CUSTOM_ELEMENTS_SCHEMA, Directive, effect, input, output, TemplateRef, viewChild, } from '@angular/core';
+import { extend, hasListener, injectBeforeRender, injectStore, NgtPortal, NgtPortalContent, pick } from 'angular-three';
+import { NgtsOrthographicCamera } from 'angular-three-soba/cameras';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, Matrix4, Object3D, Quaternion, Scene, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+const turnRate = 2 * Math.PI; // turn rate in angles per second
+const dummy = new Object3D();
+const matrix = new Matrix4();
+const [q1, q2] = [new Quaternion(), new Quaternion()];
+const target = new Vector3();
+const targetPosition = new Vector3();
+export class NgtsGizmoHelperContent {
+    static ngTemplateContextGuard(_, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoHelperContent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.0", type: NgtsGizmoHelperContent, isStandalone: true, selector: "ng-template[gizmoHelperContent]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoHelperContent, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[gizmoHelperContent]', standalone: true }]
+        }] });
+const defaultOptions = {
+    alignment: 'bottom-right',
+    margin: [80, 80],
+    renderPriority: 1,
+};
+export class NgtsGizmoHelper {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.update = output();
+        this.renderPriority = pick(this.options, 'renderPriority');
+        this.margin = pick(this.options, 'margin');
+        this.alignment = pick(this.options, 'alignment');
+        this.scene = new Scene();
+        this.content = contentChild.required(NgtsGizmoHelperContent, { read: TemplateRef });
+        this.gizmoRef = viewChild('gizmo');
+        this.virtualCameraRef = viewChild(NgtsOrthographicCamera);
+        this.store = injectStore();
+        this.size = this.store.select('size');
+        this.mainCamera = this.store.select('camera');
+        this.defaultControls = this.store.select('controls');
+        this.invalidate = this.store.select('invalidate');
+        this.x = computed(() => {
+            const alignment = this.alignment();
+            if (alignment.endsWith('-center'))
+                return 0;
+            const [{ width }, [marginX]] = [this.size(), this.margin()];
+            return alignment.endsWith('-left') ? -width / 2 + marginX : width / 2 - marginX;
+        });
+        this.y = computed(() => {
+            const alignment = this.alignment();
+            if (alignment.startsWith('center-'))
+                return 0;
+            const [{ height }, [marginY]] = [this.size(), this.margin()];
+            return alignment.startsWith('top-') ? height / 2 - marginY : -height / 2 + marginY;
+        });
+        this.animating = false;
+        this.radius = 0;
+        this.focusPoint = new Vector3(0, 0, 0);
+        this.defaultUp = new Vector3(0, 0, 0);
+        extend({ Group });
+        effect(() => {
+            this.updateDefaultUpEffect();
+        });
+        injectBeforeRender(({ delta }) => {
+            const [virtualCamera, gizmo] = [
+                this.virtualCameraRef()?.cameraRef()?.nativeElement,
+                this.gizmoRef()?.nativeElement,
+            ];
+            if (!virtualCamera || !gizmo)
+                return;
+            const [defaultControls, mainCamera, invalidate] = [this.defaultControls(), this.mainCamera(), this.invalidate()];
+            // Animate step
+            if (this.animating) {
+                if (q1.angleTo(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 (this.isOrbitControls(defaultControls)) {
+                        mainCamera.up.copy(this.defaultUp);
+                    }
+                }
+                else {
+                    const step = delta * turnRate;
+                    // animate position by doing a slerp and then scaling the position on the unit sphere
+                    q1.rotateTowards(q2, step);
+                    // animate orientation
+                    mainCamera.position.set(0, 0, 1).applyQuaternion(q1).multiplyScalar(this.radius).add(this.focusPoint);
+                    mainCamera.up.set(0, 1, 0).applyQuaternion(q1).normalize();
+                    mainCamera.quaternion.copy(q1);
+                    if (this.isCameraControls(defaultControls)) {
+                        void defaultControls.setPosition(mainCamera.position.x, mainCamera.position.y, mainCamera.position.z);
+                    }
+                    if (hasListener(this.update))
+                        this.update.emit();
+                    else if (defaultControls)
+                        defaultControls.update(delta);
+                    invalidate();
+                }
+            }
+            // Sync Gizmo with main camera orientation
+            matrix.copy(mainCamera.matrix).invert();
+            gizmo.quaternion.setFromRotationMatrix(matrix);
+        });
+    }
+    tweenCamera(direction) {
+        const [defaultControls, invalidate, mainCamera] = [this.defaultControls(), this.invalidate(), this.mainCamera()];
+        this.animating = true;
+        if (defaultControls) {
+            this.focusPoint = this.isCameraControls(defaultControls)
+                ? defaultControls.getTarget(this.focusPoint)
+                : defaultControls.target;
+        }
+        this.radius = mainCamera.position.distanceTo(target);
+        // Rotate from current camera orientation
+        q1.copy(mainCamera.quaternion);
+        // To new current camera orientation
+        targetPosition.copy(direction).multiplyScalar(this.radius).add(target);
+        dummy.lookAt(targetPosition);
+        q2.copy(dummy.quaternion);
+        invalidate();
+    }
+    updateDefaultUpEffect() {
+        const mainCamera = this.mainCamera();
+        this.defaultUp.copy(mainCamera.up);
+    }
+    isOrbitControls(controls) {
+        return 'minPolarAngle' in controls;
+    }
+    isCameraControls(controls) {
+        return 'getTarget' in controls;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoHelper, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsGizmoHelper, isStandalone: true, selector: "ngts-gizmo-helper", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { update: "update" }, queries: [{ propertyName: "content", first: true, predicate: NgtsGizmoHelperContent, descendants: true, read: TemplateRef, isSignal: true }], viewQueries: [{ propertyName: "gizmoRef", first: true, predicate: ["gizmo"], descendants: true, isSignal: true }, { propertyName: "virtualCameraRef", first: true, predicate: NgtsOrthographicCamera, descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-portal
+			[container]="scene"
+			[autoRender]="true"
+			[autoRenderPriority]="renderPriority()"
+			[state]="{ events: { priority: renderPriority() + 1 } }"
+		>
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ngts-orthographic-camera [options]="{ makeDefault: true, position: [0, 0, 200] }" />
+				<ngt-group #gizmo [position]="[x(), y(), 0]">
+					<ng-container
+						[ngTemplateOutlet]="content()"
+						[ngTemplateOutletContext]="{ container, injector }"
+						[ngTemplateOutletInjector]="injector"
+					/>
+				</ngt-group>
+			</ng-template>
+		</ngt-portal>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[portalContent]" }, { kind: "component", type: NgtsOrthographicCamera, selector: "ngts-orthographic-camera", inputs: ["options"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoHelper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-helper',
+                    standalone: true,
+                    template: `
+		<ngt-portal
+			[container]="scene"
+			[autoRender]="true"
+			[autoRenderPriority]="renderPriority()"
+			[state]="{ events: { priority: renderPriority() + 1 } }"
+		>
+			<ng-template portalContent let-injector="injector" let-container="container">
+				<ngts-orthographic-camera [options]="{ makeDefault: true, position: [0, 0, 200] }" />
+				<ngt-group #gizmo [position]="[x(), y(), 0]">
+					<ng-container
+						[ngTemplateOutlet]="content()"
+						[ngTemplateOutletContext]="{ container, injector }"
+						[ngTemplateOutletInjector]="injector"
+					/>
+				</ngt-group>
+			</ng-template>
+		</ngt-portal>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo-helper.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/gizmo-helper/gizmo-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tcontentChild,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tDirective,\n\teffect,\n\tElementRef,\n\tinput,\n\toutput,\n\tSignal,\n\tTemplateRef,\n\tviewChild,\n} from '@angular/core';\nimport { extend, hasListener, injectBeforeRender, injectStore, NgtPortal, NgtPortalContent, pick } from 'angular-three';\nimport { NgtsOrthographicCamera } from 'angular-three-soba/cameras';\nimport CameraControls from 'camera-controls';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Group, Matrix4, Object3D, Quaternion, Scene, Vector3 } from 'three';\nimport { OrbitControls } from 'three-stdlib';\n\nconst turnRate = 2 * Math.PI; // turn rate in angles per second\nconst dummy = new Object3D();\nconst matrix = new Matrix4();\nconst [q1, q2] = [new Quaternion(), new Quaternion()];\nconst target = new Vector3();\nconst targetPosition = new Vector3();\n\n@Directive({ selector: 'ng-template[gizmoHelperContent]', standalone: true })\nexport class NgtsGizmoHelperContent {\n\tstatic ngTemplateContextGuard(_: NgtsGizmoHelperContent, ctx: unknown): ctx is { container: Object3D } {\n\t\treturn true;\n\t}\n}\n\ntype ControlsProto = { update(delta?: number): void; target: Vector3 };\n\nexport interface NgtsGizmoHelperOptions {\n\talignment:\n\t\t| 'top-left'\n\t\t| 'top-right'\n\t\t| 'bottom-right'\n\t\t| 'bottom-left'\n\t\t| 'bottom-center'\n\t\t| 'center-right'\n\t\t| 'center-left'\n\t\t| 'center-center'\n\t\t| 'top-center';\n\tmargin: [number, number];\n\trenderPriority: number;\n\tautoClear?: boolean;\n}\n\nconst defaultOptions: NgtsGizmoHelperOptions = {\n\talignment: 'bottom-right',\n\tmargin: [80, 80],\n\trenderPriority: 1,\n};\n\n@Component({\n\tselector: 'ngts-gizmo-helper',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal\n\t\t\t[container]=\"scene\"\n\t\t\t[autoRender]=\"true\"\n\t\t\t[autoRenderPriority]=\"renderPriority()\"\n\t\t\t[state]=\"{ events: { priority: renderPriority() + 1 } }\"\n\t\t>\n\t\t\t<ng-template portalContent let-injector=\"injector\" let-container=\"container\">\n\t\t\t\t<ngts-orthographic-camera [options]=\"{ makeDefault: true, position: [0, 0, 200] }\" />\n\t\t\t\t<ngt-group #gizmo [position]=\"[x(), y(), 0]\">\n\t\t\t\t\t<ng-container\n\t\t\t\t\t\t[ngTemplateOutlet]=\"content()\"\n\t\t\t\t\t\t[ngTemplateOutletContext]=\"{ container, injector }\"\n\t\t\t\t\t\t[ngTemplateOutletInjector]=\"injector\"\n\t\t\t\t\t/>\n\t\t\t\t</ngt-group>\n\t\t\t</ng-template>\n\t\t</ngt-portal>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],\n})\nexport class NgtsGizmoHelper {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tupdate = output<void>();\n\n\tprotected renderPriority = pick(this.options, 'renderPriority');\n\tprotected margin = pick(this.options, 'margin');\n\tprotected alignment = pick(this.options, 'alignment');\n\n\tprotected scene = new Scene();\n\n\tprotected content = contentChild.required(NgtsGizmoHelperContent, { read: TemplateRef });\n\n\tprivate gizmoRef = viewChild<ElementRef<Group>>('gizmo');\n\tprivate virtualCameraRef = viewChild(NgtsOrthographicCamera);\n\n\tprivate store = injectStore();\n\tprivate size = this.store.select('size');\n\tprivate mainCamera = this.store.select('camera');\n\tprivate defaultControls = this.store.select('controls') as unknown as Signal<ControlsProto>;\n\tprivate invalidate = this.store.select('invalidate');\n\n\tprotected x = computed(() => {\n\t\tconst alignment = this.alignment();\n\t\tif (alignment.endsWith('-center')) return 0;\n\n\t\tconst [{ width }, [marginX]] = [this.size(), this.margin()];\n\t\treturn alignment.endsWith('-left') ? -width / 2 + marginX : width / 2 - marginX;\n\t});\n\tprotected y = computed(() => {\n\t\tconst alignment = this.alignment();\n\t\tif (alignment.startsWith('center-')) return 0;\n\n\t\tconst [{ height }, [marginY]] = [this.size(), this.margin()];\n\t\treturn alignment.startsWith('top-') ? height / 2 - marginY : -height / 2 + marginY;\n\t});\n\n\tprivate animating = false;\n\tprivate radius = 0;\n\tprivate focusPoint = new Vector3(0, 0, 0);\n\tprivate defaultUp = new Vector3(0, 0, 0);\n\n\tconstructor() {\n\t\textend({ Group });\n\t\teffect(() => {\n\t\t\tthis.updateDefaultUpEffect();\n\t\t});\n\n\t\tinjectBeforeRender(({ delta }) => {\n\t\t\tconst [virtualCamera, gizmo] = [\n\t\t\t\tthis.virtualCameraRef()?.cameraRef()?.nativeElement,\n\t\t\t\tthis.gizmoRef()?.nativeElement,\n\t\t\t];\n\n\t\t\tif (!virtualCamera || !gizmo) return;\n\n\t\t\tconst [defaultControls, mainCamera, invalidate] = [this.defaultControls(), this.mainCamera(), this.invalidate()];\n\n\t\t\t// Animate step\n\t\t\tif (this.animating) {\n\t\t\t\tif (q1.angleTo(q2) < 0.01) {\n\t\t\t\t\tthis.animating = false;\n\t\t\t\t\t// Orbit controls uses UP vector as the orbit axes,\n\t\t\t\t\t// so we need to reset it after the animation is done\n\t\t\t\t\t// moving it around for the controls to work correctly\n\t\t\t\t\tif (this.isOrbitControls(defaultControls)) {\n\t\t\t\t\t\tmainCamera.up.copy(this.defaultUp);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tconst step = delta * turnRate;\n\t\t\t\t\t// animate position by doing a slerp and then scaling the position on the unit sphere\n\t\t\t\t\tq1.rotateTowards(q2, step);\n\t\t\t\t\t// animate orientation\n\t\t\t\t\tmainCamera.position.set(0, 0, 1).applyQuaternion(q1).multiplyScalar(this.radius).add(this.focusPoint);\n\t\t\t\t\tmainCamera.up.set(0, 1, 0).applyQuaternion(q1).normalize();\n\t\t\t\t\tmainCamera.quaternion.copy(q1);\n\n\t\t\t\t\tif (this.isCameraControls(defaultControls)) {\n\t\t\t\t\t\tvoid defaultControls.setPosition(mainCamera.position.x, mainCamera.position.y, mainCamera.position.z);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (hasListener(this.update)) this.update.emit();\n\t\t\t\t\telse if (defaultControls) defaultControls.update(delta);\n\n\t\t\t\t\tinvalidate();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Sync Gizmo with main camera orientation\n\t\t\tmatrix.copy(mainCamera.matrix).invert();\n\t\t\tgizmo.quaternion.setFromRotationMatrix(matrix);\n\t\t});\n\t}\n\n\ttweenCamera(direction: Vector3) {\n\t\tconst [defaultControls, invalidate, mainCamera] = [this.defaultControls(), this.invalidate(), this.mainCamera()];\n\n\t\tthis.animating = true;\n\t\tif (defaultControls) {\n\t\t\tthis.focusPoint = this.isCameraControls(defaultControls)\n\t\t\t\t? defaultControls.getTarget(this.focusPoint)\n\t\t\t\t: defaultControls.target;\n\t\t}\n\t\tthis.radius = mainCamera.position.distanceTo(target);\n\n\t\t// Rotate from current camera orientation\n\t\tq1.copy(mainCamera.quaternion);\n\n\t\t// To new current camera orientation\n\t\ttargetPosition.copy(direction).multiplyScalar(this.radius).add(target);\n\t\tdummy.lookAt(targetPosition);\n\t\tq2.copy(dummy.quaternion);\n\n\t\tinvalidate();\n\t}\n\n\tprivate updateDefaultUpEffect() {\n\t\tconst mainCamera = this.mainCamera();\n\t\tthis.defaultUp.copy(mainCamera.up);\n\t}\n\n\tprivate isOrbitControls(controls: ControlsProto): controls is OrbitControls {\n\t\treturn 'minPolarAngle' in (controls as OrbitControls);\n\t}\n\n\tprivate isCameraControls(controls: CameraControls | ControlsProto): controls is CameraControls {\n\t\treturn 'getTarget' in (controls as CameraControls);\n\t}\n}\n"]}

package/esm2022/gizmos/lib/gizmo-helper/gizmo-viewcube.mjs

@@ -0,0 +1,304 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, input, output, signal, } from '@angular/core';
+import { extend, getEmitter, hasListener, injectStore, NgtArgs, pick, } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { BoxGeometry, CanvasTexture, Group, Mesh, MeshBasicMaterial, Vector3 } from 'three';
+import { NgtsGizmoHelper } from './gizmo-helper';
+import * as i0 from "@angular/core";
+const colors = { bg: '#f0f0f0', hover: '#999', text: 'black', stroke: 'black' };
+const defaultFaces = ['Right', 'Left', 'Top', 'Bottom', 'Front', 'Back'];
+const defaultFaceMaterialOptions = {
+    font: '20px Inter var, Arial, sans-serif',
+    faces: defaultFaces,
+    color: colors.bg,
+    hoverColor: colors.hover,
+    textColor: colors.text,
+    strokeColor: colors.stroke,
+    opacity: 1,
+};
+export class FaceMaterial {
+    constructor() {
+        this.hover = input.required();
+        this.index = input.required();
+        this.options = input(defaultFaceMaterialOptions, { transform: mergeInputs(defaultFaceMaterialOptions) });
+        this.faces = pick(this.options, 'faces');
+        this.font = pick(this.options, 'font');
+        this.color = pick(this.options, 'color');
+        this.textColor = pick(this.options, 'textColor');
+        this.strokeColor = pick(this.options, 'strokeColor');
+        this.hoverColor = pick(this.options, 'hoverColor');
+        this.document = inject(DOCUMENT);
+        this.store = injectStore();
+        this.gl = this.store.select('gl');
+        this.opacity = pick(this.options, 'opacity');
+        this.materialColor = computed(() => (this.hover() ? this.hoverColor() : 'white'));
+        this.texture = computed(() => {
+            const [index, faces, font, color, textColor, strokeColor, gl] = [
+                this.index(),
+                this.faces(),
+                this.font(),
+                this.color(),
+                this.textColor(),
+                this.strokeColor(),
+                this.gl(),
+            ];
+            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);
+            const texture = new CanvasTexture(canvas);
+            texture.anisotropy = gl.capabilities.getMaxAnisotropy() || 1;
+            return texture;
+        });
+        extend({ MeshBasicMaterial });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FaceMaterial, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: FaceMaterial, isStandalone: true, selector: "viewcube-face-material", inputs: { hover: { classPropertyName: "hover", publicName: "hover", isSignal: true, isRequired: true, transformFunction: null }, index: { classPropertyName: "index", publicName: "index", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-mesh-basic-material
+			[attach]="['material', index()]"
+			[map]="texture()"
+			[color]="materialColor()"
+			[transparent]="true"
+			[opacity]="opacity()"
+		/>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FaceMaterial, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'viewcube-face-material',
+                    standalone: true,
+                    template: `
+		<ngt-mesh-basic-material
+			[attach]="['material', index()]"
+			[map]="texture()"
+			[color]="materialColor()"
+			[transparent]="true"
+			[opacity]="opacity()"
+		/>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class FaceCube {
+    constructor() {
+        this.options = input({});
+        this.onClick = input();
+        this.gizmoHelper = inject(NgtsGizmoHelper);
+        this.hover = signal(-1);
+        this.count = Array.from({ length: 6 });
+        this.Math = Math;
+        extend({ Mesh, BoxGeometry });
+    }
+    internalOnClick(event) {
+        const onClick = this.onClick();
+        if (onClick)
+            onClick(event);
+        else {
+            event.stopPropagation();
+            this.gizmoHelper.tweenCamera(event.face.normal);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FaceCube, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: FaceCube, isStandalone: true, selector: "viewcube-face-cube", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, onClick: { classPropertyName: "onClick", publicName: "onClick", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-mesh
+			(pointerout)="$event.stopPropagation(); hover.set(-1)"
+			(pointermove)="$event.stopPropagation(); hover.set(Math.floor($any($event).faceIndex / 2))"
+			(click)="internalOnClick($any($event))"
+		>
+			<ngt-box-geometry />
+			@for (face of count; track $index) {
+				<viewcube-face-material [index]="$index" [hover]="hover() === $index" [options]="options()" />
+			}
+		</ngt-mesh>
+	`, isInline: true, dependencies: [{ kind: "component", type: FaceMaterial, selector: "viewcube-face-material", inputs: ["hover", "index", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: FaceCube, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'viewcube-face-cube',
+                    standalone: true,
+                    template: `
+		<ngt-mesh
+			(pointerout)="$event.stopPropagation(); hover.set(-1)"
+			(pointermove)="$event.stopPropagation(); hover.set(Math.floor($any($event).faceIndex / 2))"
+			(click)="internalOnClick($any($event))"
+		>
+			<ngt-box-geometry />
+			@for (face of count; track $index) {
+				<viewcube-face-material [index]="$index" [hover]="hover() === $index" [options]="options()" />
+			}
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [FaceMaterial],
+                }]
+        }], ctorParameters: () => [] });
+export class EdgeCube {
+    constructor() {
+        this.dimensions = input.required();
+        this.position = input.required();
+        this.hoverColor = input(colors.hover, {
+            transform: (value) => {
+                if (value === undefined)
+                    return colors.hover;
+                return value;
+            },
+        });
+        this.onClick = input();
+        this.gizmoHelper = inject(NgtsGizmoHelper);
+        this.hover = signal(false);
+        this.color = computed(() => (this.hover() ? this.hoverColor() : 'white'));
+        extend({ Mesh, BoxGeometry, MeshBasicMaterial });
+    }
+    internalOnClick(event) {
+        const onClick = this.onClick();
+        if (onClick)
+            onClick(event);
+        else {
+            event.stopPropagation();
+            this.gizmoHelper.tweenCamera(this.position());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: EdgeCube, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.0", type: EdgeCube, isStandalone: true, selector: "viewcube-edge-cube", inputs: { dimensions: { classPropertyName: "dimensions", publicName: "dimensions", isSignal: true, isRequired: true, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: true, transformFunction: null }, hoverColor: { classPropertyName: "hoverColor", publicName: "hoverColor", isSignal: true, isRequired: false, transformFunction: null }, onClick: { classPropertyName: "onClick", publicName: "onClick", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngt-mesh
+			[scale]="1.01"
+			[position]="position()"
+			(pointerout)="$event.stopPropagation(); hover.set(false)"
+			(pointerover)="$event.stopPropagation(); hover.set(true)"
+			(click)="internalOnClick($any($event))"
+		>
+			<ngt-mesh-basic-material [transparent]="true" [opacity]="0.6" [color]="color()" [visible]="hover()" />
+			<ngt-box-geometry *args="dimensions()" />
+		</ngt-mesh>
+	`, 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: EdgeCube, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'viewcube-edge-cube',
+                    standalone: true,
+                    template: `
+		<ngt-mesh
+			[scale]="1.01"
+			[position]="position()"
+			(pointerout)="$event.stopPropagation(); hover.set(false)"
+			(pointerover)="$event.stopPropagation(); hover.set(true)"
+			(click)="internalOnClick($any($event))"
+		>
+			<ngt-mesh-basic-material [transparent]="true" [opacity]="0.6" [color]="color()" [visible]="hover()" />
+			<ngt-box-geometry *args="dimensions()" />
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsGizmoViewcube {
+    constructor() {
+        this.options = input({});
+        this.click = output();
+        this.hoverColor = pick(this.options, 'hoverColor');
+        this.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(this.makePositionVector);
+        this.cornerDimensions = [0.25, 0.25, 0.25];
+        this.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(this.makePositionVector);
+        this.edgeDimensions = this.edges.map((edge) => edge.toArray().map((axis) => (axis == 0 ? 0.5 : 0.25)));
+        extend({ Group });
+    }
+    get onClick() {
+        if (hasListener(this.click))
+            return getEmitter(this.click);
+        return undefined;
+    }
+    makePositionVector(xyz) {
+        return new Vector3(...xyz).multiplyScalar(0.38);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoViewcube, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsGizmoViewcube, isStandalone: true, selector: "ngts-gizmo-viewcube", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { click: "click" }, ngImport: i0, template: `
+		<ngt-group [scale]="60">
+			<viewcube-face-cube [options]="options()" [onClick]="onClick" />
+			@for (edge of edges; track $index) {
+				<viewcube-edge-cube
+					[position]="edge"
+					[dimensions]="edgeDimensions[$index]"
+					[onClick]="onClick"
+					[hoverColor]="hoverColor()"
+				/>
+			}
+			@for (corner of corners; track $index) {
+				<viewcube-edge-cube
+					[position]="corner"
+					[dimensions]="cornerDimensions"
+					[onClick]="onClick"
+					[hoverColor]="hoverColor()"
+				/>
+			}
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: FaceCube, selector: "viewcube-face-cube", inputs: ["options", "onClick"] }, { kind: "component", type: EdgeCube, selector: "viewcube-edge-cube", inputs: ["dimensions", "position", "hoverColor", "onClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsGizmoViewcube, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-viewcube',
+                    standalone: true,
+                    template: `
+		<ngt-group [scale]="60">
+			<viewcube-face-cube [options]="options()" [onClick]="onClick" />
+			@for (edge of edges; track $index) {
+				<viewcube-edge-cube
+					[position]="edge"
+					[dimensions]="edgeDimensions[$index]"
+					[onClick]="onClick"
+					[hoverColor]="hoverColor()"
+				/>
+			}
+			@for (corner of corners; track $index) {
+				<viewcube-edge-cube
+					[position]="corner"
+					[dimensions]="cornerDimensions"
+					[onClick]="onClick"
+					[hoverColor]="hoverColor()"
+				/>
+			}
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [FaceCube, EdgeCube],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo-viewcube.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/gizmo-helper/gizmo-viewcube.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tinject,\n\tinput,\n\toutput,\n\tsignal,\n} from '@angular/core';\nimport {\n\textend,\n\tgetEmitter,\n\thasListener,\n\tinjectStore,\n\tNgtArgs,\n\tNgtEventHandlers,\n\tNgtThreeEvent,\n\tpick,\n} from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { BoxGeometry, CanvasTexture, Group, Mesh, MeshBasicMaterial, Vector3 } from 'three';\nimport { NgtsGizmoHelper } from './gizmo-helper';\n\ntype XYZ = [number, number, number];\n\nconst colors = { bg: '#f0f0f0', hover: '#999', text: 'black', stroke: 'black' };\nconst defaultFaces = ['Right', 'Left', 'Top', 'Bottom', 'Front', 'Back'];\n\ninterface CommonOptions {\n\tfont: string;\n\topacity: number;\n\tcolor: string;\n\thoverColor: string;\n\ttextColor: string;\n\tstrokeColor: string;\n\tfaces: string[];\n}\n\nconst defaultFaceMaterialOptions: CommonOptions = {\n\tfont: '20px Inter var, Arial, sans-serif',\n\tfaces: defaultFaces,\n\tcolor: colors.bg,\n\thoverColor: colors.hover,\n\ttextColor: colors.text,\n\tstrokeColor: colors.stroke,\n\topacity: 1,\n};\n\n@Component({\n\tselector: 'viewcube-face-material',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh-basic-material\n\t\t\t[attach]=\"['material', index()]\"\n\t\t\t[map]=\"texture()\"\n\t\t\t[color]=\"materialColor()\"\n\t\t\t[transparent]=\"true\"\n\t\t\t[opacity]=\"opacity()\"\n\t\t/>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FaceMaterial {\n\thover = input.required<boolean>();\n\tindex = input.required<number>();\n\toptions = input(defaultFaceMaterialOptions, { transform: mergeInputs(defaultFaceMaterialOptions) });\n\n\tprivate faces = pick(this.options, 'faces');\n\tprivate font = pick(this.options, 'font');\n\tprivate color = pick(this.options, 'color');\n\tprivate textColor = pick(this.options, 'textColor');\n\tprivate strokeColor = pick(this.options, 'strokeColor');\n\tprivate hoverColor = pick(this.options, 'hoverColor');\n\n\tprivate document = inject(DOCUMENT);\n\tprivate store = injectStore();\n\tprivate gl = this.store.select('gl');\n\n\tprotected opacity = pick(this.options, 'opacity');\n\tprotected materialColor = computed(() => (this.hover() ? this.hoverColor() : 'white'));\n\tprotected texture = computed(() => {\n\t\tconst [index, faces, font, color, textColor, strokeColor, gl] = [\n\t\t\tthis.index(),\n\t\t\tthis.faces(),\n\t\t\tthis.font(),\n\t\t\tthis.color(),\n\t\t\tthis.textColor(),\n\t\t\tthis.strokeColor(),\n\t\t\tthis.gl(),\n\t\t];\n\n\t\tconst canvas = this.document.createElement('canvas');\n\t\tcanvas.width = 128;\n\t\tcanvas.height = 128;\n\n\t\tconst context = canvas.getContext('2d')!;\n\t\tcontext.fillStyle = color;\n\t\tcontext.fillRect(0, 0, canvas.width, canvas.height);\n\t\tcontext.strokeStyle = strokeColor;\n\t\tcontext.strokeRect(0, 0, canvas.width, canvas.height);\n\t\tcontext.font = font;\n\t\tcontext.textAlign = 'center';\n\t\tcontext.fillStyle = textColor;\n\t\tcontext.fillText(faces[index].toUpperCase(), 64, 76);\n\n\t\tconst texture = new CanvasTexture(canvas);\n\t\ttexture.anisotropy = gl.capabilities.getMaxAnisotropy() || 1;\n\n\t\treturn texture;\n\t});\n\n\tconstructor() {\n\t\textend({ MeshBasicMaterial });\n\t}\n}\n\n@Component({\n\tselector: 'viewcube-face-cube',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh\n\t\t\t(pointerout)=\"$event.stopPropagation(); hover.set(-1)\"\n\t\t\t(pointermove)=\"$event.stopPropagation(); hover.set(Math.floor($any($event).faceIndex / 2))\"\n\t\t\t(click)=\"internalOnClick($any($event))\"\n\t\t>\n\t\t\t<ngt-box-geometry />\n\t\t\t@for (face of count; track $index) {\n\t\t\t\t<viewcube-face-material [index]=\"$index\" [hover]=\"hover() === $index\" [options]=\"options()\" />\n\t\t\t}\n\t\t</ngt-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [FaceMaterial],\n})\nexport class FaceCube {\n\toptions = input({} as Partial<CommonOptions>);\n\tonClick = input<NgtEventHandlers['click']>();\n\n\tprivate gizmoHelper = inject(NgtsGizmoHelper);\n\n\tprotected hover = signal(-1);\n\tprotected count = Array.from({ length: 6 });\n\n\tconstructor() {\n\t\textend({ Mesh, BoxGeometry });\n\t}\n\n\tinternalOnClick(event: NgtThreeEvent<MouseEvent>) {\n\t\tconst onClick = this.onClick();\n\t\tif (onClick) onClick(event);\n\t\telse {\n\t\t\tevent.stopPropagation();\n\t\t\tthis.gizmoHelper.tweenCamera(event.face!.normal);\n\t\t}\n\t}\n\n\tprotected readonly Math = Math;\n}\n\n@Component({\n\tselector: 'viewcube-edge-cube',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh\n\t\t\t[scale]=\"1.01\"\n\t\t\t[position]=\"position()\"\n\t\t\t(pointerout)=\"$event.stopPropagation(); hover.set(false)\"\n\t\t\t(pointerover)=\"$event.stopPropagation(); hover.set(true)\"\n\t\t\t(click)=\"internalOnClick($any($event))\"\n\t\t>\n\t\t\t<ngt-mesh-basic-material [transparent]=\"true\" [opacity]=\"0.6\" [color]=\"color()\" [visible]=\"hover()\" />\n\t\t\t<ngt-box-geometry *args=\"dimensions()\" />\n\t\t</ngt-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class EdgeCube {\n\tdimensions = input.required<XYZ>();\n\tposition = input.required<Vector3>();\n\thoverColor = input(colors.hover, {\n\t\ttransform: (value: string | undefined) => {\n\t\t\tif (value === undefined) return colors.hover;\n\t\t\treturn value;\n\t\t},\n\t});\n\tonClick = input<NgtEventHandlers['click']>();\n\n\tprivate gizmoHelper = inject(NgtsGizmoHelper);\n\n\tprotected hover = signal(false);\n\tprotected color = computed(() => (this.hover() ? this.hoverColor() : 'white'));\n\n\tconstructor() {\n\t\textend({ Mesh, BoxGeometry, MeshBasicMaterial });\n\t}\n\n\tinternalOnClick(event: NgtThreeEvent<MouseEvent>) {\n\t\tconst onClick = this.onClick();\n\t\tif (onClick) onClick(event);\n\t\telse {\n\t\t\tevent.stopPropagation();\n\t\t\tthis.gizmoHelper.tweenCamera(this.position());\n\t\t}\n\t}\n}\n\nexport type NgtsGizmoViewcubeOptions = Partial<CommonOptions>;\n\n@Component({\n\tselector: 'ngts-gizmo-viewcube',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group [scale]=\"60\">\n\t\t\t<viewcube-face-cube [options]=\"options()\" [onClick]=\"onClick\" />\n\t\t\t@for (edge of edges; track $index) {\n\t\t\t\t<viewcube-edge-cube\n\t\t\t\t\t[position]=\"edge\"\n\t\t\t\t\t[dimensions]=\"edgeDimensions[$index]\"\n\t\t\t\t\t[onClick]=\"onClick\"\n\t\t\t\t\t[hoverColor]=\"hoverColor()\"\n\t\t\t\t/>\n\t\t\t}\n\t\t\t@for (corner of corners; track $index) {\n\t\t\t\t<viewcube-edge-cube\n\t\t\t\t\t[position]=\"corner\"\n\t\t\t\t\t[dimensions]=\"cornerDimensions\"\n\t\t\t\t\t[onClick]=\"onClick\"\n\t\t\t\t\t[hoverColor]=\"hoverColor()\"\n\t\t\t\t/>\n\t\t\t}\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [FaceCube, EdgeCube],\n})\nexport class NgtsGizmoViewcube {\n\toptions = input({} as NgtsGizmoViewcubeOptions);\n\tclick = output<NgtThreeEvent<MouseEvent>>();\n\n\tprotected hoverColor = pick(this.options, 'hoverColor');\n\n\tprotected corners: Vector3[] = [\n\t\t[1, 1, 1],\n\t\t[1, 1, -1],\n\t\t[1, -1, 1],\n\t\t[1, -1, -1],\n\t\t[-1, 1, 1],\n\t\t[-1, 1, -1],\n\t\t[-1, -1, 1],\n\t\t[-1, -1, -1],\n\t].map(this.makePositionVector);\n\tprotected cornerDimensions: XYZ = [0.25, 0.25, 0.25];\n\tprotected edges: Vector3[] = [\n\t\t[1, 1, 0],\n\t\t[1, 0, 1],\n\t\t[1, 0, -1],\n\t\t[1, -1, 0],\n\t\t[0, 1, 1],\n\t\t[0, 1, -1],\n\t\t[0, -1, 1],\n\t\t[0, -1, -1],\n\t\t[-1, 1, 0],\n\t\t[-1, 0, 1],\n\t\t[-1, 0, -1],\n\t\t[-1, -1, 0],\n\t].map(this.makePositionVector);\n\tprotected edgeDimensions = this.edges.map(\n\t\t(edge) => edge.toArray().map((axis: number): number => (axis == 0 ? 0.5 : 0.25)) as XYZ,\n\t);\n\n\tconstructor() {\n\t\textend({ Group });\n\t}\n\n\tprotected get onClick() {\n\t\tif (hasListener(this.click)) return getEmitter(this.click);\n\t\treturn undefined;\n\t}\n\n\tprivate makePositionVector(xyz: number[]) {\n\t\treturn new Vector3(...xyz).multiplyScalar(0.38);\n\t}\n}\n"]}