angular-three-soba 2.0.0 → 2.2.0

package/esm2022/gizmos/lib/pivot-controls/plane-slider.mjs

@@ -0,0 +1,266 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, input, signal, viewChild, } from '@angular/core';
+import { extend, injectStore } from 'angular-three';
+import { NgtsLine } from 'angular-three-soba/abstractions';
+import { NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';
+import { DoubleSide, Group, Matrix4, Mesh, MeshBasicMaterial, Plane, PlaneGeometry, Ray, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+function decomposeIntoBasis(e1, e2, offset) {
+    const i1 = Math.abs(e1.x) >= Math.abs(e1.y) && Math.abs(e1.x) >= Math.abs(e1.z)
+        ? 0
+        : Math.abs(e1.y) >= Math.abs(e1.x) && Math.abs(e1.y) >= Math.abs(e1.z)
+            ? 1
+            : 2;
+    const e2DegrowthOrder = [0, 1, 2].sort((a, b) => Math.abs(e2.getComponent(b)) - Math.abs(e2.getComponent(a)));
+    const i2 = i1 === e2DegrowthOrder[0] ? e2DegrowthOrder[1] : e2DegrowthOrder[0];
+    const a1 = e1.getComponent(i1);
+    const a2 = e1.getComponent(i2);
+    const b1 = e2.getComponent(i1);
+    const b2 = e2.getComponent(i2);
+    const c1 = offset.getComponent(i1);
+    const c2 = offset.getComponent(i2);
+    const y = (c2 - c1 * (a2 / a1)) / (b2 - b1 * (a2 / a1));
+    const x = (c1 - y * b1) / a1;
+    return [x, y];
+}
+const ray = new Ray();
+const intersection = new Vector3();
+const offsetMatrix = new Matrix4();
+export class NgtsPlaneSlider {
+    constructor() {
+        this.DoubleSide = DoubleSide;
+        this.dir1 = input.required();
+        this.dir2 = input.required();
+        this.axis = input.required();
+        this.groupRef = viewChild.required('group');
+        this.annotationRef = viewChild('annotation', { read: ElementRef });
+        this.pivotControls = inject(NgtsPivotControls);
+        this.store = injectStore();
+        this.controls = this.store.select('controls');
+        this.hovered = signal(false);
+        this.clickInfo = null;
+        this.offsetX0 = 0;
+        this.offsetY0 = 0;
+        this.matrixL = computed(() => {
+            const dir1N = this.dir1().clone().normalize();
+            const dir2N = this.dir2().clone().normalize();
+            return new Matrix4().makeBasis(dir1N, dir2N, dir1N.clone().cross(dir2N));
+        });
+        this.pos1 = computed(() => (this.pivotControls.fixed() ? 1 / 7 : this.pivotControls.scale() / 7));
+        this.length = computed(() => (this.pivotControls.fixed() ? 0.225 : this.pivotControls.scale() * 0.225));
+        this.color = computed(() => this.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()]);
+        this.points = computed(() => {
+            const length = this.length();
+            return [
+                new Vector3(0, 0, 0),
+                new Vector3(0, length, 0),
+                new Vector3(length, length, 0),
+                new Vector3(length, 0, 0),
+                new Vector3(0, 0, 0),
+            ];
+        });
+        extend({ Group, Mesh, PlaneGeometry, MeshBasicMaterial });
+    }
+    onPointerDown(event) {
+        const [annotation, axis, group, controls] = [
+            this.annotationRef()?.nativeElement,
+            this.axis(),
+            this.groupRef().nativeElement,
+            this.controls(),
+        ];
+        if (annotation) {
+            annotation.innerText = `${this.pivotControls.translation[(axis + 1) % 3].toFixed(2)}, ${this.pivotControls.translation[(axis + 2) % 3].toFixed(2)}`;
+            annotation.style.display = 'block';
+        }
+        event.stopPropagation();
+        const clickPoint = event.point.clone();
+        const origin = new Vector3().setFromMatrixPosition(group.matrixWorld);
+        const e1 = new Vector3().setFromMatrixColumn(group.matrixWorld, 0).normalize();
+        const e2 = new Vector3().setFromMatrixColumn(group.matrixWorld, 1).normalize();
+        const normal = new Vector3().setFromMatrixColumn(group.matrixWorld, 2).normalize();
+        const plane = new Plane().setFromNormalAndCoplanarPoint(normal, origin);
+        this.clickInfo = { clickPoint, e1, e2, plane };
+        this.offsetX0 = this.pivotControls.translation[(axis + 1) % 3];
+        this.offsetY0 = this.pivotControls.translation[(axis + 2) % 3];
+        this.pivotControls.onDragStart({ component: 'Slider', axis, origin, directions: [e1, e2, normal] });
+        if (controls) {
+            controls.enabled = false;
+        }
+        // @ts-expect-error - setPointerCapture is not defined on ThreeEvent
+        event.target.setPointerCapture(event.pointerId);
+    }
+    onPointerMove(event) {
+        event.stopPropagation();
+        if (!this.hovered())
+            this.hovered.set(true);
+        if (this.clickInfo) {
+            const { clickPoint, e1, e2, plane } = this.clickInfo;
+            const [translationLimits, axis, annotation] = [
+                this.pivotControls.translationLimits(),
+                this.axis(),
+                this.annotationRef()?.nativeElement,
+            ];
+            const [minX, maxX] = translationLimits?.[(axis + 1) % 3] || [undefined, undefined];
+            const [minY, maxY] = translationLimits?.[(axis + 2) % 3] || [undefined, undefined];
+            ray.copy(event.ray);
+            ray.intersectPlane(plane, intersection);
+            ray.direction.negate();
+            ray.intersectPlane(plane, intersection);
+            intersection.sub(clickPoint);
+            let [offsetX, offsetY] = decomposeIntoBasis(e1, e2, intersection);
+            /* let offsetY = (intersection.y - (intersection.x * e1.y) / e1.x) / (e2.y - (e2.x * e1.y) / e1.x)
+      let offsetX = (intersection.x - offsetY * e2.x) / e1.x */
+            if (minX !== undefined) {
+                offsetX = Math.max(offsetX, minX - this.offsetX0);
+            }
+            if (maxX !== undefined) {
+                offsetX = Math.min(offsetX, maxX - this.offsetX0);
+            }
+            if (minY !== undefined) {
+                offsetY = Math.max(offsetY, minY - this.offsetY0);
+            }
+            if (maxY !== undefined) {
+                offsetY = Math.min(offsetY, maxY - this.offsetY0);
+            }
+            this.pivotControls.translation[(axis + 1) % 3] = this.offsetX0 + offsetX;
+            this.pivotControls.translation[(axis + 2) % 3] = this.offsetY0 + offsetY;
+            if (annotation) {
+                annotation.innerText = `${this.pivotControls.translation[(axis + 1) % 3].toFixed(2)}, ${this.pivotControls.translation[(axis + 2) % 3].toFixed(2)}`;
+            }
+            offsetMatrix.makeTranslation(offsetX * e1.x + offsetY * e2.x, offsetX * e1.y + offsetY * e2.y, offsetX * e1.z + offsetY * e2.z);
+            this.pivotControls.onDrag(offsetMatrix);
+        }
+    }
+    onPointerUp(event) {
+        const [annotation, controls] = [this.annotationRef()?.nativeElement, this.controls()];
+        if (annotation) {
+            annotation.style.display = 'none';
+        }
+        event.stopPropagation();
+        this.clickInfo = null;
+        this.pivotControls.onDragEnd();
+        if (controls) {
+            controls.enabled = true;
+        }
+        // @ts-expect-error - releasePointerCapture is not defined on ThreeEvent
+        event.target.releasePointerCapture(event.pointerId);
+    }
+    onPointerOut(event) {
+        event.stopPropagation();
+        this.hovered.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPlaneSlider, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsPlaneSlider, isStandalone: true, selector: "ngts-plane-slider", inputs: { dir1: { classPropertyName: "dir1", publicName: "dir1", isSignal: true, isRequired: true, transformFunction: null }, dir2: { classPropertyName: "dir2", publicName: "dir2", isSignal: true, isRequired: true, transformFunction: null }, axis: { classPropertyName: "axis", publicName: "axis", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "annotationRef", first: true, predicate: ["annotation"], descendants: true, read: ElementRef, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [matrix]="matrixL()" [matrixAutoUpdate]="false">
+			@if (pivotControls.annotations()) {
+				<ngts-html [options]="{ position: [0, 0, 0] }">
+					<div
+						#annotation
+						ngtsHTMLContent
+						style="display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap"
+						[class]="pivotControls.annotationsClass()"
+					></div>
+				</ngts-html>
+			}
+			<ngt-group [position]="[pos1() * 1.7, pos1() * 1.7, 0]">
+				<ngt-mesh
+					[visible]="true"
+					[scale]="length()"
+					[userData]="pivotControls.userData()"
+					(pointerdown)="onPointerDown($any($event))"
+					(pointermove)="onPointerMove($any($event))"
+					(pointerup)="onPointerUp($any($event))"
+					(pointerout)="onPointerOut($any($event))"
+				>
+					<ngt-plane-geometry />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+						[side]="DoubleSide"
+						[fog]="false"
+					/>
+				</ngt-mesh>
+				<ngts-line
+					[points]="points()"
+					[options]="{
+						position: [-length() / 2, -length() / 2, 0],
+						transparent: true,
+						depthTest: pivotControls.depthTest(),
+						lineWidth: pivotControls.lineWidth(),
+						color: color(),
+						opacity: pivotControls.opacity(),
+						polygonOffset: true,
+						polygonOffsetFactor: -10,
+						userData: pivotControls.userData(),
+						fog: false,
+					}"
+				/>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsHTML, selector: "ngts-html", inputs: ["options"] }, { kind: "component", type: NgtsHTMLContent, selector: "[ngtsHTMLContent]", inputs: ["ngtsHTMLContent"], outputs: ["occluded"] }, { kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsPlaneSlider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-plane-slider',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [matrix]="matrixL()" [matrixAutoUpdate]="false">
+			@if (pivotControls.annotations()) {
+				<ngts-html [options]="{ position: [0, 0, 0] }">
+					<div
+						#annotation
+						ngtsHTMLContent
+						style="display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap"
+						[class]="pivotControls.annotationsClass()"
+					></div>
+				</ngts-html>
+			}
+			<ngt-group [position]="[pos1() * 1.7, pos1() * 1.7, 0]">
+				<ngt-mesh
+					[visible]="true"
+					[scale]="length()"
+					[userData]="pivotControls.userData()"
+					(pointerdown)="onPointerDown($any($event))"
+					(pointermove)="onPointerMove($any($event))"
+					(pointerup)="onPointerUp($any($event))"
+					(pointerout)="onPointerOut($any($event))"
+				>
+					<ngt-plane-geometry />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+						[side]="DoubleSide"
+						[fog]="false"
+					/>
+				</ngt-mesh>
+				<ngts-line
+					[points]="points()"
+					[options]="{
+						position: [-length() / 2, -length() / 2, 0],
+						transparent: true,
+						depthTest: pivotControls.depthTest(),
+						lineWidth: pivotControls.lineWidth(),
+						color: color(),
+						opacity: pivotControls.opacity(),
+						polygonOffset: true,
+						polygonOffsetFactor: -10,
+						userData: pivotControls.userData(),
+						fog: false,
+					}"
+				/>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsHTML, NgtsHTMLContent, NgtsLine],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plane-slider.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/pivot-controls/plane-slider.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinject,\n\tinput,\n\tsignal,\n\tSignal,\n\tviewChild,\n} from '@angular/core';\nimport { extend, injectStore, NgtThreeEvent } from 'angular-three';\nimport { NgtsLine } from 'angular-three-soba/abstractions';\nimport { NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';\nimport { DoubleSide, Group, Matrix4, Mesh, MeshBasicMaterial, Plane, PlaneGeometry, Ray, Vector3 } from 'three';\nimport { NgtsPivotControls } from './pivot-controls';\n\nfunction decomposeIntoBasis(e1: Vector3, e2: Vector3, offset: Vector3) {\n\tconst i1 =\n\t\tMath.abs(e1.x) >= Math.abs(e1.y) && Math.abs(e1.x) >= Math.abs(e1.z)\n\t\t\t? 0\n\t\t\t: Math.abs(e1.y) >= Math.abs(e1.x) && Math.abs(e1.y) >= Math.abs(e1.z)\n\t\t\t\t? 1\n\t\t\t\t: 2;\n\tconst e2DegrowthOrder = [0, 1, 2].sort((a, b) => Math.abs(e2.getComponent(b)) - Math.abs(e2.getComponent(a)));\n\tconst i2 = i1 === e2DegrowthOrder[0] ? e2DegrowthOrder[1] : e2DegrowthOrder[0];\n\tconst a1 = e1.getComponent(i1);\n\tconst a2 = e1.getComponent(i2);\n\tconst b1 = e2.getComponent(i1);\n\tconst b2 = e2.getComponent(i2);\n\tconst c1 = offset.getComponent(i1);\n\tconst c2 = offset.getComponent(i2);\n\n\tconst y = (c2 - c1 * (a2 / a1)) / (b2 - b1 * (a2 / a1));\n\tconst x = (c1 - y * b1) / a1;\n\n\treturn [x, y];\n}\n\nconst ray = new Ray();\nconst intersection = new Vector3();\nconst offsetMatrix = new Matrix4();\n\n@Component({\n\tselector: 'ngts-plane-slider',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group [matrix]=\"matrixL()\" [matrixAutoUpdate]=\"false\">\n\t\t\t@if (pivotControls.annotations()) {\n\t\t\t\t<ngts-html [options]=\"{ position: [0, 0, 0] }\">\n\t\t\t\t\t<div\n\t\t\t\t\t\t#annotation\n\t\t\t\t\t\tngtsHTMLContent\n\t\t\t\t\t\tstyle=\"display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap\"\n\t\t\t\t\t\t[class]=\"pivotControls.annotationsClass()\"\n\t\t\t\t\t></div>\n\t\t\t\t</ngts-html>\n\t\t\t}\n\t\t\t<ngt-group [position]=\"[pos1() * 1.7, pos1() * 1.7, 0]\">\n\t\t\t\t<ngt-mesh\n\t\t\t\t\t[visible]=\"true\"\n\t\t\t\t\t[scale]=\"length()\"\n\t\t\t\t\t[userData]=\"pivotControls.userData()\"\n\t\t\t\t\t(pointerdown)=\"onPointerDown($any($event))\"\n\t\t\t\t\t(pointermove)=\"onPointerMove($any($event))\"\n\t\t\t\t\t(pointerup)=\"onPointerUp($any($event))\"\n\t\t\t\t\t(pointerout)=\"onPointerOut($any($event))\"\n\t\t\t\t>\n\t\t\t\t\t<ngt-plane-geometry />\n\t\t\t\t\t<ngt-mesh-basic-material\n\t\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t\t[depthTest]=\"pivotControls.depthTest()\"\n\t\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t\t[polygonOffset]=\"true\"\n\t\t\t\t\t\t[polygonOffsetFactor]=\"-10\"\n\t\t\t\t\t\t[side]=\"DoubleSide\"\n\t\t\t\t\t\t[fog]=\"false\"\n\t\t\t\t\t/>\n\t\t\t\t</ngt-mesh>\n\t\t\t\t<ngts-line\n\t\t\t\t\t[points]=\"points()\"\n\t\t\t\t\t[options]=\"{\n\t\t\t\t\t\tposition: [-length() / 2, -length() / 2, 0],\n\t\t\t\t\t\ttransparent: true,\n\t\t\t\t\t\tdepthTest: pivotControls.depthTest(),\n\t\t\t\t\t\tlineWidth: pivotControls.lineWidth(),\n\t\t\t\t\t\tcolor: color(),\n\t\t\t\t\t\topacity: pivotControls.opacity(),\n\t\t\t\t\t\tpolygonOffset: true,\n\t\t\t\t\t\tpolygonOffsetFactor: -10,\n\t\t\t\t\t\tuserData: pivotControls.userData(),\n\t\t\t\t\t\tfog: false,\n\t\t\t\t\t}\"\n\t\t\t\t/>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtsHTML, NgtsHTMLContent, NgtsLine],\n})\nexport class NgtsPlaneSlider {\n\tprotected readonly DoubleSide = DoubleSide;\n\n\tdir1 = input.required<Vector3>();\n\tdir2 = input.required<Vector3>();\n\taxis = input.required<0 | 1 | 2>();\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tannotationRef = viewChild<unknown, ElementRef<HTMLDivElement>>('annotation', { read: ElementRef });\n\n\tpivotControls = inject(NgtsPivotControls);\n\tprivate store = injectStore();\n\tprivate controls = this.store.select('controls') as unknown as Signal<{ enabled: boolean }>;\n\n\tprivate hovered = signal(false);\n\tprivate clickInfo: { clickPoint: Vector3; e1: Vector3; e2: Vector3; plane: Plane } | null = null;\n\tprivate offsetX0 = 0;\n\tprivate offsetY0 = 0;\n\n\tmatrixL = computed(() => {\n\t\tconst dir1N = this.dir1().clone().normalize();\n\t\tconst dir2N = this.dir2().clone().normalize();\n\t\treturn new Matrix4().makeBasis(dir1N, dir2N, dir1N.clone().cross(dir2N));\n\t});\n\n\tpos1 = computed(() => (this.pivotControls.fixed() ? 1 / 7 : this.pivotControls.scale() / 7));\n\tlength = computed(() => (this.pivotControls.fixed() ? 0.225 : this.pivotControls.scale() * 0.225));\n\tcolor = computed(() =>\n\t\tthis.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()],\n\t);\n\tpoints = computed(() => {\n\t\tconst length = this.length();\n\t\treturn [\n\t\t\tnew Vector3(0, 0, 0),\n\t\t\tnew Vector3(0, length, 0),\n\t\t\tnew Vector3(length, length, 0),\n\t\t\tnew Vector3(length, 0, 0),\n\t\t\tnew Vector3(0, 0, 0),\n\t\t];\n\t});\n\n\tconstructor() {\n\t\textend({ Group, Mesh, PlaneGeometry, MeshBasicMaterial });\n\t}\n\n\tonPointerDown(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, axis, group, controls] = [\n\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\tthis.axis(),\n\t\t\tthis.groupRef().nativeElement,\n\t\t\tthis.controls(),\n\t\t];\n\n\t\tif (annotation) {\n\t\t\tannotation.innerText = `${this.pivotControls.translation[(axis + 1) % 3].toFixed(2)}, ${this.pivotControls.translation[(axis + 2) % 3].toFixed(2)}`;\n\t\t\tannotation.style.display = 'block';\n\t\t}\n\n\t\tevent.stopPropagation();\n\t\tconst clickPoint = event.point.clone();\n\t\tconst origin = new Vector3().setFromMatrixPosition(group.matrixWorld);\n\t\tconst e1 = new Vector3().setFromMatrixColumn(group.matrixWorld, 0).normalize();\n\t\tconst e2 = new Vector3().setFromMatrixColumn(group.matrixWorld, 1).normalize();\n\t\tconst normal = new Vector3().setFromMatrixColumn(group.matrixWorld, 2).normalize();\n\t\tconst plane = new Plane().setFromNormalAndCoplanarPoint(normal, origin);\n\t\tthis.clickInfo = { clickPoint, e1, e2, plane };\n\t\tthis.offsetX0 = this.pivotControls.translation[(axis + 1) % 3];\n\t\tthis.offsetY0 = this.pivotControls.translation[(axis + 2) % 3];\n\t\tthis.pivotControls.onDragStart({ component: 'Slider', axis, origin, directions: [e1, e2, normal] });\n\t\tif (controls) {\n\t\t\tcontrols.enabled = false;\n\t\t}\n\n\t\t// @ts-expect-error - setPointerCapture is not defined on ThreeEvent\n\t\tevent.target.setPointerCapture(event.pointerId);\n\t}\n\n\tonPointerMove(event: NgtThreeEvent<PointerEvent>) {\n\t\tevent.stopPropagation();\n\t\tif (!this.hovered()) this.hovered.set(true);\n\n\t\tif (this.clickInfo) {\n\t\t\tconst { clickPoint, e1, e2, plane } = this.clickInfo;\n\t\t\tconst [translationLimits, axis, annotation] = [\n\t\t\t\tthis.pivotControls.translationLimits(),\n\t\t\t\tthis.axis(),\n\t\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\t];\n\n\t\t\tconst [minX, maxX] = translationLimits?.[(axis + 1) % 3] || [undefined, undefined];\n\t\t\tconst [minY, maxY] = translationLimits?.[(axis + 2) % 3] || [undefined, undefined];\n\n\t\t\tray.copy(event.ray);\n\t\t\tray.intersectPlane(plane, intersection);\n\t\t\tray.direction.negate();\n\t\t\tray.intersectPlane(plane, intersection);\n\t\t\tintersection.sub(clickPoint);\n\t\t\tlet [offsetX, offsetY] = decomposeIntoBasis(e1, e2, intersection);\n\t\t\t/* let offsetY = (intersection.y - (intersection.x * e1.y) / e1.x) / (e2.y - (e2.x * e1.y) / e1.x)\n      let offsetX = (intersection.x - offsetY * e2.x) / e1.x */\n\t\t\tif (minX !== undefined) {\n\t\t\t\toffsetX = Math.max(offsetX, minX - this.offsetX0);\n\t\t\t}\n\t\t\tif (maxX !== undefined) {\n\t\t\t\toffsetX = Math.min(offsetX, maxX - this.offsetX0);\n\t\t\t}\n\t\t\tif (minY !== undefined) {\n\t\t\t\toffsetY = Math.max(offsetY, minY - this.offsetY0);\n\t\t\t}\n\t\t\tif (maxY !== undefined) {\n\t\t\t\toffsetY = Math.min(offsetY, maxY - this.offsetY0);\n\t\t\t}\n\t\t\tthis.pivotControls.translation[(axis + 1) % 3] = this.offsetX0 + offsetX;\n\t\t\tthis.pivotControls.translation[(axis + 2) % 3] = this.offsetY0 + offsetY;\n\n\t\t\tif (annotation) {\n\t\t\t\tannotation.innerText = `${this.pivotControls.translation[(axis + 1) % 3].toFixed(2)}, ${this.pivotControls.translation[(axis + 2) % 3].toFixed(2)}`;\n\t\t\t}\n\n\t\t\toffsetMatrix.makeTranslation(\n\t\t\t\toffsetX * e1.x + offsetY * e2.x,\n\t\t\t\toffsetX * e1.y + offsetY * e2.y,\n\t\t\t\toffsetX * e1.z + offsetY * e2.z,\n\t\t\t);\n\t\t\tthis.pivotControls.onDrag(offsetMatrix);\n\t\t}\n\t}\n\n\tonPointerUp(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, controls] = [this.annotationRef()?.nativeElement, this.controls()];\n\t\tif (annotation) {\n\t\t\tannotation.style.display = 'none';\n\t\t}\n\t\tevent.stopPropagation();\n\t\tthis.clickInfo = null;\n\t\tthis.pivotControls.onDragEnd();\n\t\tif (controls) {\n\t\t\tcontrols.enabled = true;\n\t\t}\n\t\t// @ts-expect-error - releasePointerCapture is not defined on ThreeEvent\n\t\tevent.target.releasePointerCapture(event.pointerId);\n\t}\n\n\tonPointerOut(event: NgtThreeEvent<PointerEvent>) {\n\t\tevent.stopPropagation();\n\t\tthis.hovered.set(false);\n\t}\n}\n"]}

package/esm2022/gizmos/lib/pivot-controls/scaling-sphere.mjs

@@ -0,0 +1,232 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, input, signal, viewChild, } from '@angular/core';
+import { extend, injectStore, NgtArgs } from 'angular-three';
+import { calculateScaleFactor, NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';
+import { Group, Matrix4, Mesh, MeshBasicMaterial, Quaternion, SphereGeometry, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+const vec1 = new Vector3();
+const vec2 = new Vector3();
+export function calculateOffset(clickPoint, normal, rayStart, rayDir) {
+    const e1 = normal.dot(normal);
+    const e2 = normal.dot(clickPoint) - normal.dot(rayStart);
+    const e3 = normal.dot(rayDir);
+    if (e3 === 0) {
+        return -e2 / e1;
+    }
+    vec1
+        .copy(rayDir)
+        .multiplyScalar(e1 / e3)
+        .sub(normal);
+    vec2
+        .copy(rayDir)
+        .multiplyScalar(e2 / e3)
+        .add(rayStart)
+        .sub(clickPoint);
+    return -vec1.dot(vec2) / vec1.dot(vec1);
+}
+const upV = new Vector3(0, 1, 0);
+const scaleV = new Vector3();
+const scaleMatrix = new Matrix4();
+export class NgtsScalingSphere {
+    constructor() {
+        this.direction = input.required();
+        this.axis = input.required();
+        this.groupRef = viewChild.required('group');
+        this.annotationRef = viewChild('annotation', { read: ElementRef });
+        this.meshRef = viewChild.required('mesh');
+        this.pivotControls = inject(NgtsPivotControls);
+        this.store = injectStore();
+        this.controls = this.store.select('controls');
+        this.size = this.store.select('size');
+        this.hovered = signal(false);
+        this.scale0 = 1;
+        this.scaleCurrent = 1;
+        this.clickInfo = null;
+        this.position = computed(() => (this.pivotControls.fixed() ? 1.2 : 1.2 * this.pivotControls.scale()));
+        this.radius = computed(() => this.pivotControls.fixed()
+            ? (this.pivotControls.lineWidth() / this.pivotControls.scale()) * 1.8
+            : this.pivotControls.scale() / 22.5);
+        this.matrixL = computed(() => {
+            const quaternion = new Quaternion().setFromUnitVectors(upV, this.direction().clone().normalize());
+            return new Matrix4().makeRotationFromQuaternion(quaternion);
+        });
+        this.color = computed(() => this.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()]);
+        extend({ Group, Mesh, SphereGeometry, MeshBasicMaterial });
+    }
+    onPointerDown(event) {
+        const [annotation, controls, fixed, scale, direction, axis, size, group] = [
+            this.annotationRef()?.nativeElement,
+            this.controls(),
+            this.pivotControls.fixed(),
+            this.pivotControls.scale(),
+            this.direction(),
+            this.axis(),
+            this.size(),
+            this.groupRef().nativeElement,
+        ];
+        if (annotation) {
+            annotation.innerText = `${scale.toFixed(2)}`;
+            annotation.style.display = 'block';
+        }
+        event.stopPropagation();
+        const rotation = new Matrix4().extractRotation(group.matrixWorld);
+        const clickPoint = event.point.clone();
+        const origin = new Vector3().setFromMatrixPosition(group.matrixWorld);
+        const dir = direction.clone().applyMatrix4(rotation).normalize();
+        const mPLG = group.matrixWorld.clone();
+        const mPLGInv = mPLG.clone().invert();
+        const offsetMultiplier = fixed
+            ? 1 / calculateScaleFactor(group.getWorldPosition(vec1), scale, event.camera, size)
+            : 1;
+        this.clickInfo = { clickPoint, dir, mPLG, mPLGInv, offsetMultiplier };
+        this.pivotControls.onDragStart({ component: 'Sphere', axis, origin, directions: [dir] });
+        if (controls) {
+            controls.enabled = false;
+        }
+        // @ts-expect-error - setPointerCapture is not in the type definition
+        event.target.setPointerCapture(event.pointerId);
+    }
+    onPointerMove(event) {
+        event.stopPropagation();
+        if (!this.hovered())
+            this.hovered.set(true);
+        if (this.clickInfo) {
+            const { clickPoint, dir, mPLG, mPLGInv, offsetMultiplier } = this.clickInfo;
+            const [scaleLimits, axis, position, annotation, fixed, scale, mesh] = [
+                this.pivotControls.scaleLimits(),
+                this.axis(),
+                this.position(),
+                this.annotationRef()?.nativeElement,
+                this.pivotControls.fixed(),
+                this.pivotControls.scale(),
+                this.meshRef().nativeElement,
+            ];
+            const [min, max] = scaleLimits?.[axis] || [1e-5, undefined]; // always limit the minimal value, since setting it very low might break the transform
+            const offsetW = calculateOffset(clickPoint, dir, event.ray.origin, event.ray.direction);
+            const offsetL = offsetW * offsetMultiplier;
+            const offsetH = fixed ? offsetL : offsetL / scale;
+            let upscale = Math.pow(2, offsetH * 0.2);
+            if (event.shiftKey) {
+                upscale = Math.round(upscale * 10) / 10;
+            }
+            upscale = Math.max(upscale, min / this.scale0);
+            if (max !== undefined) {
+                upscale = Math.min(upscale, max / this.scale0);
+            }
+            this.scaleCurrent = this.scale0 * upscale;
+            mesh.position.set(0, position + offsetL, 0);
+            if (annotation) {
+                annotation.innerText = `${this.scaleCurrent.toFixed(2)}`;
+            }
+            scaleV.set(1, 1, 1);
+            scaleV.setComponent(axis, upscale);
+            scaleMatrix.makeScale(scaleV.x, scaleV.y, scaleV.z).premultiply(mPLG).multiply(mPLGInv);
+            this.pivotControls.onDrag(scaleMatrix);
+        }
+    }
+    onPointerUp(event) {
+        const [annotation, controls, position, mesh] = [
+            this.annotationRef()?.nativeElement,
+            this.controls(),
+            this.position(),
+            this.meshRef().nativeElement,
+        ];
+        if (annotation) {
+            annotation.style.display = 'none';
+        }
+        event.stopPropagation();
+        this.scale0 = this.scaleCurrent;
+        this.clickInfo = null;
+        mesh.position.set(0, position, 0);
+        this.pivotControls.onDragEnd();
+        if (controls) {
+            controls.enabled = true;
+        }
+        // @ts-expect-error - releasePointerCapture is not in the type definition
+        event.target.releasePointerCapture(event.pointerId);
+    }
+    onPointerOut(event) {
+        event.stopPropagation();
+        this.hovered.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsScalingSphere, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsScalingSphere, isStandalone: true, selector: "ngts-scaling-sphere", inputs: { direction: { classPropertyName: "direction", publicName: "direction", isSignal: true, isRequired: true, transformFunction: null }, axis: { classPropertyName: "axis", publicName: "axis", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "annotationRef", first: true, predicate: ["annotation"], descendants: true, read: ElementRef, isSignal: true }, { propertyName: "meshRef", first: true, predicate: ["mesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group>
+			<ngt-group
+				[matrix]="matrixL()"
+				[matrixAutoUpdate]="false"
+				(pointerdown)="onPointerDown($any($event))"
+				(pointermove)="onPointerMove($any($event))"
+				(pointerup)="onPointerUp($any($event))"
+				(pointerout)="onPointerOut($any($event))"
+			>
+				@if (pivotControls.annotations()) {
+					<ngts-html [options]="{ position: [0, position() / 2, 0] }">
+						<div
+							#annotation
+							ngtsHTMLContent
+							style="display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap;"
+							[class]="pivotControls.annotationsClass()"
+						></div>
+					</ngts-html>
+				}
+				<ngt-mesh #mesh [position]="[0, position(), 0]" [renderOrder]="500" [userData]="pivotControls.userData()">
+					<ngt-sphere-geometry *args="[radius(), 12, 12]" />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[opacity]="pivotControls.opacity()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+					/>
+				</ngt-mesh>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsHTML, selector: "ngts-html", inputs: ["options"] }, { kind: "component", type: NgtsHTMLContent, selector: "[ngtsHTMLContent]", inputs: ["ngtsHTMLContent"], outputs: ["occluded"] }, { 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: NgtsScalingSphere, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-scaling-sphere',
+                    standalone: true,
+                    template: `
+		<ngt-group #group>
+			<ngt-group
+				[matrix]="matrixL()"
+				[matrixAutoUpdate]="false"
+				(pointerdown)="onPointerDown($any($event))"
+				(pointermove)="onPointerMove($any($event))"
+				(pointerup)="onPointerUp($any($event))"
+				(pointerout)="onPointerOut($any($event))"
+			>
+				@if (pivotControls.annotations()) {
+					<ngts-html [options]="{ position: [0, position() / 2, 0] }">
+						<div
+							#annotation
+							ngtsHTMLContent
+							style="display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap;"
+							[class]="pivotControls.annotationsClass()"
+						></div>
+					</ngts-html>
+				}
+				<ngt-mesh #mesh [position]="[0, position(), 0]" [renderOrder]="500" [userData]="pivotControls.userData()">
+					<ngt-sphere-geometry *args="[radius(), 12, 12]" />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[opacity]="pivotControls.opacity()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+					/>
+				</ngt-mesh>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsHTML, NgtsHTMLContent, NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scaling-sphere.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/pivot-controls/scaling-sphere.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinject,\n\tinput,\n\tsignal,\n\tSignal,\n\tviewChild,\n} from '@angular/core';\nimport { extend, injectStore, NgtArgs, NgtThreeEvent } from 'angular-three';\nimport { calculateScaleFactor, NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';\nimport { Group, Matrix4, Mesh, MeshBasicMaterial, Quaternion, SphereGeometry, Vector3 } from 'three';\nimport { NgtsPivotControls } from './pivot-controls';\n\nconst vec1 = new Vector3();\nconst vec2 = new Vector3();\n\nexport function calculateOffset(clickPoint: Vector3, normal: Vector3, rayStart: Vector3, rayDir: Vector3) {\n\tconst e1 = normal.dot(normal);\n\tconst e2 = normal.dot(clickPoint) - normal.dot(rayStart);\n\tconst e3 = normal.dot(rayDir);\n\n\tif (e3 === 0) {\n\t\treturn -e2 / e1;\n\t}\n\n\tvec1\n\t\t.copy(rayDir)\n\t\t.multiplyScalar(e1 / e3)\n\t\t.sub(normal);\n\tvec2\n\t\t.copy(rayDir)\n\t\t.multiplyScalar(e2 / e3)\n\t\t.add(rayStart)\n\t\t.sub(clickPoint);\n\n\treturn -vec1.dot(vec2) / vec1.dot(vec1);\n}\n\nconst upV = new Vector3(0, 1, 0);\nconst scaleV = new Vector3();\nconst scaleMatrix = new Matrix4();\n\n@Component({\n\tselector: 'ngts-scaling-sphere',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group #group>\n\t\t\t<ngt-group\n\t\t\t\t[matrix]=\"matrixL()\"\n\t\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t\t(pointerdown)=\"onPointerDown($any($event))\"\n\t\t\t\t(pointermove)=\"onPointerMove($any($event))\"\n\t\t\t\t(pointerup)=\"onPointerUp($any($event))\"\n\t\t\t\t(pointerout)=\"onPointerOut($any($event))\"\n\t\t\t>\n\t\t\t\t@if (pivotControls.annotations()) {\n\t\t\t\t\t<ngts-html [options]=\"{ position: [0, position() / 2, 0] }\">\n\t\t\t\t\t\t<div\n\t\t\t\t\t\t\t#annotation\n\t\t\t\t\t\t\tngtsHTMLContent\n\t\t\t\t\t\t\tstyle=\"display: none; background: #151520; color: white; padding: 6px 8px; border-radius: 7px; white-space: nowrap;\"\n\t\t\t\t\t\t\t[class]=\"pivotControls.annotationsClass()\"\n\t\t\t\t\t\t></div>\n\t\t\t\t\t</ngts-html>\n\t\t\t\t}\n\t\t\t\t<ngt-mesh #mesh [position]=\"[0, position(), 0]\" [renderOrder]=\"500\" [userData]=\"pivotControls.userData()\">\n\t\t\t\t\t<ngt-sphere-geometry *args=\"[radius(), 12, 12]\" />\n\t\t\t\t\t<ngt-mesh-basic-material\n\t\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t\t\t[depthTest]=\"pivotControls.depthTest()\"\n\t\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t\t[opacity]=\"pivotControls.opacity()\"\n\t\t\t\t\t\t[polygonOffset]=\"true\"\n\t\t\t\t\t\t[polygonOffsetFactor]=\"-10\"\n\t\t\t\t\t/>\n\t\t\t\t</ngt-mesh>\n\t\t\t</ngt-group>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtsHTML, NgtsHTMLContent, NgtArgs],\n})\nexport class NgtsScalingSphere {\n\tdirection = input.required<Vector3>();\n\taxis = input.required<0 | 1 | 2>();\n\n\tgroupRef = viewChild.required<ElementRef<Group>>('group');\n\tannotationRef = viewChild<unknown, ElementRef<HTMLDivElement>>('annotation', { read: ElementRef });\n\tmeshRef = viewChild.required<ElementRef<Mesh>>('mesh');\n\n\tpivotControls = inject(NgtsPivotControls);\n\tprivate store = injectStore();\n\tprivate controls = this.store.select('controls') as unknown as Signal<{ enabled: boolean }>;\n\tprivate size = this.store.select('size');\n\n\tprivate hovered = signal(false);\n\tprivate scale0 = 1;\n\tprivate scaleCurrent = 1;\n\tprivate clickInfo: {\n\t\tclickPoint: Vector3;\n\t\tdir: Vector3;\n\t\tmPLG: Matrix4;\n\t\tmPLGInv: Matrix4;\n\t\toffsetMultiplier: number;\n\t} | null = null;\n\n\tposition = computed(() => (this.pivotControls.fixed() ? 1.2 : 1.2 * this.pivotControls.scale()));\n\tradius = computed(() =>\n\t\tthis.pivotControls.fixed()\n\t\t\t? (this.pivotControls.lineWidth() / this.pivotControls.scale()) * 1.8\n\t\t\t: this.pivotControls.scale() / 22.5,\n\t);\n\tmatrixL = computed(() => {\n\t\tconst quaternion = new Quaternion().setFromUnitVectors(upV, this.direction().clone().normalize());\n\t\treturn new Matrix4().makeRotationFromQuaternion(quaternion);\n\t});\n\tcolor = computed(() =>\n\t\tthis.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()],\n\t);\n\n\tconstructor() {\n\t\textend({ Group, Mesh, SphereGeometry, MeshBasicMaterial });\n\t}\n\n\tonPointerDown(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, controls, fixed, scale, direction, axis, size, group] = [\n\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\tthis.controls(),\n\t\t\tthis.pivotControls.fixed(),\n\t\t\tthis.pivotControls.scale(),\n\t\t\tthis.direction(),\n\t\t\tthis.axis(),\n\t\t\tthis.size(),\n\t\t\tthis.groupRef().nativeElement,\n\t\t];\n\n\t\tif (annotation) {\n\t\t\tannotation.innerText = `${scale.toFixed(2)}`;\n\t\t\tannotation.style.display = 'block';\n\t\t}\n\n\t\tevent.stopPropagation();\n\t\tconst rotation = new Matrix4().extractRotation(group.matrixWorld);\n\t\tconst clickPoint = event.point.clone();\n\t\tconst origin = new Vector3().setFromMatrixPosition(group.matrixWorld);\n\t\tconst dir = direction.clone().applyMatrix4(rotation).normalize();\n\t\tconst mPLG = group.matrixWorld.clone();\n\t\tconst mPLGInv = mPLG.clone().invert();\n\t\tconst offsetMultiplier = fixed\n\t\t\t? 1 / calculateScaleFactor(group.getWorldPosition(vec1), scale, event.camera, size)\n\t\t\t: 1;\n\t\tthis.clickInfo = { clickPoint, dir, mPLG, mPLGInv, offsetMultiplier };\n\t\tthis.pivotControls.onDragStart({ component: 'Sphere', axis, origin, directions: [dir] });\n\n\t\tif (controls) {\n\t\t\tcontrols.enabled = false;\n\t\t}\n\t\t// @ts-expect-error - setPointerCapture is not in the type definition\n\t\tevent.target.setPointerCapture(event.pointerId);\n\t}\n\n\tonPointerMove(event: NgtThreeEvent<PointerEvent>) {\n\t\tevent.stopPropagation();\n\t\tif (!this.hovered()) this.hovered.set(true);\n\n\t\tif (this.clickInfo) {\n\t\t\tconst { clickPoint, dir, mPLG, mPLGInv, offsetMultiplier } = this.clickInfo;\n\t\t\tconst [scaleLimits, axis, position, annotation, fixed, scale, mesh] = [\n\t\t\t\tthis.pivotControls.scaleLimits(),\n\t\t\t\tthis.axis(),\n\t\t\t\tthis.position(),\n\t\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\t\tthis.pivotControls.fixed(),\n\t\t\t\tthis.pivotControls.scale(),\n\t\t\t\tthis.meshRef().nativeElement,\n\t\t\t];\n\n\t\t\tconst [min, max] = scaleLimits?.[axis] || [1e-5, undefined]; // always limit the minimal value, since setting it very low might break the transform\n\t\t\tconst offsetW = calculateOffset(clickPoint, dir, event.ray.origin, event.ray.direction);\n\t\t\tconst offsetL = offsetW * offsetMultiplier;\n\t\t\tconst offsetH = fixed ? offsetL : offsetL / scale;\n\t\t\tlet upscale = Math.pow(2, offsetH * 0.2);\n\n\t\t\tif (event.shiftKey) {\n\t\t\t\tupscale = Math.round(upscale * 10) / 10;\n\t\t\t}\n\n\t\t\tupscale = Math.max(upscale, min / this.scale0);\n\n\t\t\tif (max !== undefined) {\n\t\t\t\tupscale = Math.min(upscale, max / this.scale0);\n\t\t\t}\n\n\t\t\tthis.scaleCurrent = this.scale0 * upscale;\n\t\t\tmesh.position.set(0, position + offsetL, 0);\n\n\t\t\tif (annotation) {\n\t\t\t\tannotation.innerText = `${this.scaleCurrent.toFixed(2)}`;\n\t\t\t}\n\n\t\t\tscaleV.set(1, 1, 1);\n\t\t\tscaleV.setComponent(axis, upscale);\n\t\t\tscaleMatrix.makeScale(scaleV.x, scaleV.y, scaleV.z).premultiply(mPLG).multiply(mPLGInv);\n\t\t\tthis.pivotControls.onDrag(scaleMatrix);\n\t\t}\n\t}\n\n\tonPointerUp(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, controls, position, mesh] = [\n\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\tthis.controls(),\n\t\t\tthis.position(),\n\t\t\tthis.meshRef().nativeElement,\n\t\t];\n\n\t\tif (annotation) {\n\t\t\tannotation.style.display = 'none';\n\t\t}\n\n\t\tevent.stopPropagation();\n\t\tthis.scale0 = this.scaleCurrent;\n\t\tthis.clickInfo = null;\n\t\tmesh.position.set(0, position, 0);\n\t\tthis.pivotControls.onDragEnd();\n\t\tif (controls) {\n\t\t\tcontrols.enabled = true;\n\t\t}\n\t\t// @ts-expect-error - releasePointerCapture is not in the type definition\n\t\tevent.target.releasePointerCapture(event.pointerId);\n\t}\n\n\tonPointerOut(event: NgtThreeEvent<PointerEvent>) {\n\t\tevent.stopPropagation();\n\t\tthis.hovered.set(false);\n\t}\n}\n"]}