angular-three-soba 2.1.0 → 2.2.0

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"]}