angular-three-soba 2.0.0 → 2.2.0

package/esm2022/gizmos/lib/pivot-controls/axis-arrow.mjs

@@ -0,0 +1,263 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, input, signal, viewChild, } from '@angular/core';
+import { extend, injectStore, NgtArgs } from 'angular-three';
+import { NgtsLine } from 'angular-three-soba/abstractions';
+import { NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';
+import { ConeGeometry, CylinderGeometry, DoubleSide, Group, Matrix4, Mesh, MeshBasicMaterial, Quaternion, 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 offsetMatrix = new Matrix4();
+export class NgtsAxisArrow {
+    constructor() {
+        this.DoubleSide = DoubleSide;
+        this.direction = 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.offset0 = 0;
+        this.color = computed(() => this.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()]);
+        this.coneWidth = computed(() => this.pivotControls.fixed()
+            ? (this.pivotControls.lineWidth() / this.pivotControls.scale()) * 1.6
+            : this.pivotControls.scale() / 20);
+        this.coneLength = computed(() => (this.pivotControls.fixed() ? 0.2 : this.pivotControls.scale() / 5));
+        this.cylinderLength = computed(() => this.pivotControls.fixed() ? 1 - this.coneLength() : this.pivotControls.scale() - this.coneLength());
+        this.matrixL = computed(() => {
+            const quaternion = new Quaternion().setFromUnitVectors(upV, this.direction().clone().normalize());
+            return new Matrix4().makeRotationFromQuaternion(quaternion);
+        });
+        extend({ Group, Mesh, ConeGeometry, CylinderGeometry, MeshBasicMaterial });
+    }
+    onPointerDown(event) {
+        const [group, direction, axis, controls, annotation] = [
+            this.groupRef().nativeElement,
+            this.direction(),
+            this.axis(),
+            this.controls(),
+            this.annotationRef()?.nativeElement,
+        ];
+        if (annotation) {
+            annotation.innerText = `${this.pivotControls.translation[axis].toFixed(2)}`;
+            annotation.style.display = 'block';
+        }
+        event.stopPropagation();
+        const rotation = new Matrix4().extractRotation(group.matrixWorld);
+        const origin = new Vector3().setFromMatrixPosition(group.matrixWorld);
+        const clickPoint = event.point.clone();
+        const dir = direction.clone().applyMatrix4(rotation).normalize();
+        this.clickInfo = { clickPoint, dir };
+        this.offset0 = this.pivotControls.translation[axis];
+        this.pivotControls.onDragStart({ component: 'Arrow', axis, origin, directions: [dir] });
+        if (controls) {
+            controls.enabled = false;
+        }
+        // @ts-expect-error - setPointerCapture is not in the type definition
+        event.target.setPointerCapture(event.pointerId);
+    }
+    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 - setPointerCapture is not in the type definition
+        event.target.releasePointerCapture(event.pointerId);
+    }
+    onPointerMove(event) {
+        event.stopPropagation();
+        if (!this.hovered()) {
+            this.hovered.set(true);
+        }
+        if (this.clickInfo) {
+            const { clickPoint, dir } = this.clickInfo;
+            const [translationLimits, annotation, axis] = [
+                this.pivotControls.translationLimits(),
+                this.annotationRef()?.nativeElement,
+                this.axis(),
+            ];
+            const [min, max] = translationLimits?.[axis] || [undefined, undefined];
+            let offset = calculateOffset(clickPoint, dir, event.ray.origin, event.ray.direction);
+            if (min !== undefined) {
+                offset = Math.max(offset, min - this.offset0);
+            }
+            if (max !== undefined) {
+                offset = Math.min(offset, max - this.offset0);
+            }
+            this.pivotControls.translation[axis] = this.offset0 + offset;
+            if (annotation) {
+                annotation.innerText = `${this.pivotControls.translation[axis].toFixed(2)}`;
+            }
+            offsetMatrix.makeTranslation(dir.x * offset, dir.y * offset, dir.z * offset);
+            this.pivotControls.onDrag(offsetMatrix);
+        }
+    }
+    onPointerOut(event) {
+        event.stopPropagation();
+        this.hovered.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsAxisArrow, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsAxisArrow, isStandalone: true, selector: "ngts-axis-arrow", 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 }], ngImport: i0, template: `
+		<ngt-group #group>
+			<ngt-group
+				[matrix]="matrixL()"
+				[matrixAutoUpdate]="false"
+				(pointerdown)="onPointerDown($any($event))"
+				(pointerup)="onPointerUp($any($event))"
+				(pointermove)="onPointerMove($any($event))"
+				(pointerout)="onPointerOut($any($event))"
+			>
+				@if (pivotControls.annotations()) {
+					<ngts-html [options]="{ position: [0, -coneLength(), 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
+					[visible]="false"
+					[position]="[0, (cylinderLength() + coneLength()) / 2.0, 0]"
+					[userData]="pivotControls.userData()"
+				>
+					<ngt-cylinder-geometry
+						*args="[coneWidth() * 1.4, coneWidth() * 1.4, cylinderLength() + coneLength(), 8, 1]"
+					/>
+				</ngt-mesh>
+
+				<ngts-line
+					[points]="[0, 0, 0, 0, cylinderLength(), 0]"
+					[options]="{
+						raycast: null,
+						side: DoubleSide,
+						polygonOffset: true,
+						polygonOffsetFactor: -10,
+						renderOrder: 1,
+						fog: false,
+						transparent: true,
+						lineWidth: pivotControls.lineWidth(),
+						color: color(),
+						opacity: pivotControls.opacity(),
+						depthTest: pivotControls.depthTest(),
+					}"
+				/>
+
+				<ngt-mesh [raycast]="null" [position]="[0, cylinderLength() + coneLength() / 2.0, 0]" [renderOrder]="500">
+					<ngt-cone-geometry *args="[coneWidth(), coneLength(), 24, 1]" />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[opacity]="pivotControls.opacity()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+						[fog]="false"
+					/>
+				</ngt-mesh>
+			</ngt-group>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }, { kind: "component", type: NgtsHTML, selector: "ngts-html", inputs: ["options"] }, { kind: "component", type: NgtsHTMLContent, selector: "[ngtsHTMLContent]", inputs: ["ngtsHTMLContent"], outputs: ["occluded"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsAxisArrow, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-axis-arrow',
+                    standalone: true,
+                    template: `
+		<ngt-group #group>
+			<ngt-group
+				[matrix]="matrixL()"
+				[matrixAutoUpdate]="false"
+				(pointerdown)="onPointerDown($any($event))"
+				(pointerup)="onPointerUp($any($event))"
+				(pointermove)="onPointerMove($any($event))"
+				(pointerout)="onPointerOut($any($event))"
+			>
+				@if (pivotControls.annotations()) {
+					<ngts-html [options]="{ position: [0, -coneLength(), 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
+					[visible]="false"
+					[position]="[0, (cylinderLength() + coneLength()) / 2.0, 0]"
+					[userData]="pivotControls.userData()"
+				>
+					<ngt-cylinder-geometry
+						*args="[coneWidth() * 1.4, coneWidth() * 1.4, cylinderLength() + coneLength(), 8, 1]"
+					/>
+				</ngt-mesh>
+
+				<ngts-line
+					[points]="[0, 0, 0, 0, cylinderLength(), 0]"
+					[options]="{
+						raycast: null,
+						side: DoubleSide,
+						polygonOffset: true,
+						polygonOffsetFactor: -10,
+						renderOrder: 1,
+						fog: false,
+						transparent: true,
+						lineWidth: pivotControls.lineWidth(),
+						color: color(),
+						opacity: pivotControls.opacity(),
+						depthTest: pivotControls.depthTest(),
+					}"
+				/>
+
+				<ngt-mesh [raycast]="null" [position]="[0, cylinderLength() + coneLength() / 2.0, 0]" [renderOrder]="500">
+					<ngt-cone-geometry *args="[coneWidth(), coneLength(), 24, 1]" />
+					<ngt-mesh-basic-material
+						[transparent]="true"
+						[depthTest]="pivotControls.depthTest()"
+						[color]="color()"
+						[opacity]="pivotControls.opacity()"
+						[polygonOffset]="true"
+						[polygonOffsetFactor]="-10"
+						[fog]="false"
+					/>
+				</ngt-mesh>
+			</ngt-group>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs, NgtsLine, NgtsHTML, NgtsHTMLContent],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axis-arrow.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/pivot-controls/axis-arrow.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 { NgtsLine } from 'angular-three-soba/abstractions';\nimport { NgtsHTML, NgtsHTMLContent } from 'angular-three-soba/misc';\nimport {\n\tConeGeometry,\n\tCylinderGeometry,\n\tDoubleSide,\n\tGroup,\n\tMatrix4,\n\tMesh,\n\tMeshBasicMaterial,\n\tQuaternion,\n\tVector3,\n} 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 offsetMatrix = new Matrix4();\n\n@Component({\n\tselector: 'ngts-axis-arrow',\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(pointerup)=\"onPointerUp($any($event))\"\n\t\t\t\t(pointermove)=\"onPointerMove($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, -coneLength(), 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\n\t\t\t\t\t[visible]=\"false\"\n\t\t\t\t\t[position]=\"[0, (cylinderLength() + coneLength()) / 2.0, 0]\"\n\t\t\t\t\t[userData]=\"pivotControls.userData()\"\n\t\t\t\t>\n\t\t\t\t\t<ngt-cylinder-geometry\n\t\t\t\t\t\t*args=\"[coneWidth() * 1.4, coneWidth() * 1.4, cylinderLength() + coneLength(), 8, 1]\"\n\t\t\t\t\t/>\n\t\t\t\t</ngt-mesh>\n\n\t\t\t\t<ngts-line\n\t\t\t\t\t[points]=\"[0, 0, 0, 0, cylinderLength(), 0]\"\n\t\t\t\t\t[options]=\"{\n\t\t\t\t\t\traycast: null,\n\t\t\t\t\t\tside: DoubleSide,\n\t\t\t\t\t\tpolygonOffset: true,\n\t\t\t\t\t\tpolygonOffsetFactor: -10,\n\t\t\t\t\t\trenderOrder: 1,\n\t\t\t\t\t\tfog: false,\n\t\t\t\t\t\ttransparent: true,\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\tdepthTest: pivotControls.depthTest(),\n\t\t\t\t\t}\"\n\t\t\t\t/>\n\n\t\t\t\t<ngt-mesh [raycast]=\"null\" [position]=\"[0, cylinderLength() + coneLength() / 2.0, 0]\" [renderOrder]=\"500\">\n\t\t\t\t\t<ngt-cone-geometry *args=\"[coneWidth(), coneLength(), 24, 1]\" />\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\t[fog]=\"false\"\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: [NgtArgs, NgtsLine, NgtsHTML, NgtsHTMLContent],\n})\nexport class NgtsAxisArrow {\n\tprotected readonly DoubleSide = DoubleSide;\n\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\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; dir: Vector3 } | null = null;\n\tprivate offset0 = 0;\n\n\tcolor = computed(() =>\n\t\tthis.hovered() ? this.pivotControls.hoveredColor() : this.pivotControls.axisColors()[this.axis()],\n\t);\n\n\tconeWidth = computed(() =>\n\t\tthis.pivotControls.fixed()\n\t\t\t? (this.pivotControls.lineWidth() / this.pivotControls.scale()) * 1.6\n\t\t\t: this.pivotControls.scale() / 20,\n\t);\n\tconeLength = computed(() => (this.pivotControls.fixed() ? 0.2 : this.pivotControls.scale() / 5));\n\tcylinderLength = computed(() =>\n\t\tthis.pivotControls.fixed() ? 1 - this.coneLength() : this.pivotControls.scale() - this.coneLength(),\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\n\tconstructor() {\n\t\textend({ Group, Mesh, ConeGeometry, CylinderGeometry, MeshBasicMaterial });\n\t}\n\n\tonPointerDown(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [group, direction, axis, controls, annotation] = [\n\t\t\tthis.groupRef().nativeElement,\n\t\t\tthis.direction(),\n\t\t\tthis.axis(),\n\t\t\tthis.controls(),\n\t\t\tthis.annotationRef()?.nativeElement,\n\t\t];\n\n\t\tif (annotation) {\n\t\t\tannotation.innerText = `${this.pivotControls.translation[axis].toFixed(2)}`;\n\t\t\tannotation.style.display = 'block';\n\t\t}\n\n\t\tevent.stopPropagation();\n\n\t\tconst rotation = new Matrix4().extractRotation(group.matrixWorld);\n\t\tconst origin = new Vector3().setFromMatrixPosition(group.matrixWorld);\n\t\tconst clickPoint = event.point.clone();\n\t\tconst dir = direction.clone().applyMatrix4(rotation).normalize();\n\t\tthis.clickInfo = { clickPoint, dir };\n\t\tthis.offset0 = this.pivotControls.translation[axis];\n\t\tthis.pivotControls.onDragStart({ component: 'Arrow', axis, origin, directions: [dir] });\n\t\tif (controls) {\n\t\t\tcontrols.enabled = false;\n\t\t}\n\n\t\t// @ts-expect-error - setPointerCapture is not in the type definition\n\t\tevent.target.setPointerCapture(event.pointerId);\n\t}\n\n\tonPointerUp(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, controls] = [this.annotationRef()?.nativeElement, this.controls()];\n\n\t\tif (annotation) {\n\t\t\tannotation.style.display = 'none';\n\t\t}\n\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\n\t\t// @ts-expect-error - setPointerCapture is not in the type definition\n\t\tevent.target.releasePointerCapture(event.pointerId);\n\t}\n\n\tonPointerMove(event: NgtThreeEvent<PointerEvent>) {\n\t\tevent.stopPropagation();\n\n\t\tif (!this.hovered()) {\n\t\t\tthis.hovered.set(true);\n\t\t}\n\n\t\tif (this.clickInfo) {\n\t\t\tconst { clickPoint, dir } = this.clickInfo;\n\t\t\tconst [translationLimits, annotation, axis] = [\n\t\t\t\tthis.pivotControls.translationLimits(),\n\t\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\t\tthis.axis(),\n\t\t\t];\n\n\t\t\tconst [min, max] = translationLimits?.[axis] || [undefined, undefined];\n\n\t\t\tlet offset = calculateOffset(clickPoint, dir, event.ray.origin, event.ray.direction);\n\t\t\tif (min !== undefined) {\n\t\t\t\toffset = Math.max(offset, min - this.offset0);\n\t\t\t}\n\n\t\t\tif (max !== undefined) {\n\t\t\t\toffset = Math.min(offset, max - this.offset0);\n\t\t\t}\n\n\t\t\tthis.pivotControls.translation[axis] = this.offset0 + offset;\n\n\t\t\tif (annotation) {\n\t\t\t\tannotation.innerText = `${this.pivotControls.translation[axis].toFixed(2)}`;\n\t\t\t}\n\n\t\t\toffsetMatrix.makeTranslation(dir.x * offset, dir.y * offset, dir.z * offset);\n\t\t\tthis.pivotControls.onDrag(offsetMatrix);\n\t\t}\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/axis-rotator.mjs

@@ -0,0 +1,264 @@
+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, Plane, Ray, Vector3 } from 'three';
+import { NgtsPivotControls } from './pivot-controls';
+import * as i0 from "@angular/core";
+const clickDir = new Vector3();
+const intersectionDir = new Vector3();
+function toDegrees(radians) {
+    return (radians * 180) / Math.PI;
+}
+function toRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+function calculateAngle(clickPoint, intersectionPoint, origin, e1, e2) {
+    clickDir.copy(clickPoint).sub(origin);
+    intersectionDir.copy(intersectionPoint).sub(origin);
+    const dote1e1 = e1.dot(e1);
+    const dote2e2 = e2.dot(e2);
+    const uClick = clickDir.dot(e1) / dote1e1;
+    const vClick = clickDir.dot(e2) / dote2e2;
+    const uIntersection = intersectionDir.dot(e1) / dote1e1;
+    const vIntersection = intersectionDir.dot(e2) / dote2e2;
+    const angleClick = Math.atan2(vClick, uClick);
+    const angleIntersection = Math.atan2(vIntersection, uIntersection);
+    return angleIntersection - angleClick;
+}
+function fmod(num, denom) {
+    let k = Math.floor(num / denom);
+    k = k < 0 ? k + 1 : k;
+    return num - k * denom;
+}
+function minimizeAngle(angle) {
+    let result = fmod(angle, 2 * Math.PI);
+    if (Math.abs(result) < 1e-6) {
+        return 0.0;
+    }
+    if (result < 0.0) {
+        result += 2 * Math.PI;
+    }
+    return result;
+}
+const rotMatrix = new Matrix4();
+const posNew = new Vector3();
+const ray = new Ray();
+const intersection = new Vector3();
+export class NgtsAxisRotator {
+    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.angle = 0;
+        this.angle0 = 0;
+        this.clickInfo = null;
+        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.r = computed(() => (this.pivotControls.fixed() ? 0.65 : this.pivotControls.scale() * 0.65));
+        this.arc = computed(() => {
+            const segments = 32;
+            const points = [];
+            for (let j = 0; j <= segments; j++) {
+                const angle = (j * (Math.PI / 2)) / segments;
+                points.push(new Vector3(Math.cos(angle) * this.r(), Math.sin(angle) * this.r(), 0));
+            }
+            return points;
+        });
+        extend({ Group });
+    }
+    onPointerDown(event) {
+        const [annotation, group, axis, controls] = [
+            this.annotationRef()?.nativeElement,
+            this.groupRef().nativeElement,
+            this.axis(),
+            this.controls(),
+        ];
+        if (annotation) {
+            annotation.innerText = `${toDegrees(this.angle).toFixed(0)}º`;
+            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, origin, e1, e2, normal, plane };
+        this.pivotControls.onDragStart({ component: 'Rotator', axis, origin, directions: [e1, e2, normal] });
+        if (controls) {
+            controls.enabled = false;
+        }
+        // @ts-expect-error - setPointerCapture is not a function on PointerEvent
+        event.target.setPointerCapture(event.pointerId);
+    }
+    onPointerMove(event) {
+        event.stopPropagation();
+        if (!this.hovered())
+            this.hovered.set(true);
+        if (this.clickInfo) {
+            const { clickPoint, origin, e1, e2, normal, plane } = this.clickInfo;
+            const [rotationLimits, axis, annotation] = [
+                this.pivotControls.rotationLimits(),
+                this.axis(),
+                this.annotationRef()?.nativeElement,
+            ];
+            const [min, max] = rotationLimits?.[axis] || [undefined, undefined];
+            ray.copy(event.ray);
+            ray.intersectPlane(plane, intersection);
+            ray.direction.negate();
+            ray.intersectPlane(plane, intersection);
+            let deltaAngle = calculateAngle(clickPoint, intersection, origin, e1, e2);
+            let degrees = toDegrees(deltaAngle);
+            if (event.shiftKey) {
+                degrees = Math.round(degrees / 10) * 10;
+                deltaAngle = toRadians(degrees);
+            }
+            if (min !== undefined && max !== undefined && max - min < 2 * Math.PI) {
+                deltaAngle = minimizeAngle(deltaAngle);
+                deltaAngle = deltaAngle > Math.PI ? deltaAngle - 2 * Math.PI : deltaAngle;
+                deltaAngle = Math.round(deltaAngle / 10) * 10;
+                this.angle = this.angle0 + deltaAngle;
+            }
+            else {
+                this.angle = minimizeAngle(this.angle0 + deltaAngle);
+                this.angle = this.angle > Math.PI ? this.angle - 2 * Math.PI : this.angle;
+            }
+            if (annotation) {
+                degrees = toDegrees(this.angle);
+                annotation.innerText = `${degrees.toFixed(0)}º`;
+            }
+            rotMatrix.makeRotationAxis(normal, deltaAngle);
+            posNew.copy(origin).applyMatrix4(rotMatrix).sub(origin).negate();
+            rotMatrix.setPosition(posNew);
+            this.pivotControls.onDrag(rotMatrix);
+        }
+    }
+    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 a function on PointerEvent
+        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: NgtsAxisRotator, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtsAxisRotator, isStandalone: true, selector: "ngts-axis-rotator", 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"
+			(pointerdown)="onPointerDown($any($event))"
+			(pointermove)="onPointerMove($any($event))"
+			(pointerup)="onPointerUp($any($event))"
+			(pointerout)="onPointerOut($any($event))"
+		>
+			@if (pivotControls.annotations()) {
+				<ngts-html [options]="{ position: [r(), r(), 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>
+			}
+
+			<ngts-line
+				[points]="arc()"
+				[options]="{ lineWidth: pivotControls.lineWidth() * 4, visible: false, userData: pivotControls.userData() }"
+			/>
+
+			<ngts-line
+				[points]="arc()"
+				[options]="{
+					transparent: true,
+					raycast: null,
+					depthTest: pivotControls.depthTest(),
+					lineWidth: pivotControls.lineWidth(),
+					side: DoubleSide,
+					color: hovered() ? pivotControls.hoveredColor() : pivotControls.axisColors()[axis()],
+					opacity: pivotControls.opacity(),
+					polygonOffset: true,
+					polygonOffsetFactor: -10,
+					fog: false,
+				}"
+			/>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }, { kind: "component", type: NgtsHTML, selector: "ngts-html", inputs: ["options"] }, { kind: "component", type: NgtsHTMLContent, selector: "[ngtsHTMLContent]", inputs: ["ngtsHTMLContent"], outputs: ["occluded"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsAxisRotator, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-axis-rotator',
+                    standalone: true,
+                    template: `
+		<ngt-group
+			#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: [r(), r(), 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>
+			}
+
+			<ngts-line
+				[points]="arc()"
+				[options]="{ lineWidth: pivotControls.lineWidth() * 4, visible: false, userData: pivotControls.userData() }"
+			/>
+
+			<ngts-line
+				[points]="arc()"
+				[options]="{
+					transparent: true,
+					raycast: null,
+					depthTest: pivotControls.depthTest(),
+					lineWidth: pivotControls.lineWidth(),
+					side: DoubleSide,
+					color: hovered() ? pivotControls.hoveredColor() : pivotControls.axisColors()[axis()],
+					opacity: pivotControls.opacity(),
+					polygonOffset: true,
+					polygonOffsetFactor: -10,
+					fog: false,
+				}"
+			/>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsLine, NgtsHTML, NgtsHTMLContent],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axis-rotator.js","sourceRoot":"","sources":["../../../../../../../libs/soba/gizmos/src/lib/pivot-controls/axis-rotator.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, Plane, Ray, Vector3 } from 'three';\nimport { NgtsPivotControls } from './pivot-controls';\n\nconst clickDir = new Vector3();\nconst intersectionDir = new Vector3();\n\nfunction toDegrees(radians: number) {\n\treturn (radians * 180) / Math.PI;\n}\n\nfunction toRadians(degrees: number) {\n\treturn (degrees * Math.PI) / 180;\n}\n\nfunction calculateAngle(clickPoint: Vector3, intersectionPoint: Vector3, origin: Vector3, e1: Vector3, e2: Vector3) {\n\tclickDir.copy(clickPoint).sub(origin);\n\tintersectionDir.copy(intersectionPoint).sub(origin);\n\tconst dote1e1 = e1.dot(e1);\n\tconst dote2e2 = e2.dot(e2);\n\tconst uClick = clickDir.dot(e1) / dote1e1;\n\tconst vClick = clickDir.dot(e2) / dote2e2;\n\tconst uIntersection = intersectionDir.dot(e1) / dote1e1;\n\tconst vIntersection = intersectionDir.dot(e2) / dote2e2;\n\tconst angleClick = Math.atan2(vClick, uClick);\n\tconst angleIntersection = Math.atan2(vIntersection, uIntersection);\n\treturn angleIntersection - angleClick;\n}\n\nfunction fmod(num: number, denom: number) {\n\tlet k = Math.floor(num / denom);\n\tk = k < 0 ? k + 1 : k;\n\n\treturn num - k * denom;\n}\n\nfunction minimizeAngle(angle: number) {\n\tlet result = fmod(angle, 2 * Math.PI);\n\n\tif (Math.abs(result) < 1e-6) {\n\t\treturn 0.0;\n\t}\n\n\tif (result < 0.0) {\n\t\tresult += 2 * Math.PI;\n\t}\n\n\treturn result;\n}\n\nconst rotMatrix = new Matrix4();\nconst posNew = new Vector3();\nconst ray = new Ray();\nconst intersection = new Vector3();\n\n@Component({\n\tselector: 'ngts-axis-rotator',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group\n\t\t\t#group\n\t\t\t[matrix]=\"matrixL()\"\n\t\t\t[matrixAutoUpdate]=\"false\"\n\t\t\t(pointerdown)=\"onPointerDown($any($event))\"\n\t\t\t(pointermove)=\"onPointerMove($any($event))\"\n\t\t\t(pointerup)=\"onPointerUp($any($event))\"\n\t\t\t(pointerout)=\"onPointerOut($any($event))\"\n\t\t>\n\t\t\t@if (pivotControls.annotations()) {\n\t\t\t\t<ngts-html [options]=\"{ position: [r(), r(), 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\n\t\t\t<ngts-line\n\t\t\t\t[points]=\"arc()\"\n\t\t\t\t[options]=\"{ lineWidth: pivotControls.lineWidth() * 4, visible: false, userData: pivotControls.userData() }\"\n\t\t\t/>\n\n\t\t\t<ngts-line\n\t\t\t\t[points]=\"arc()\"\n\t\t\t\t[options]=\"{\n\t\t\t\t\ttransparent: true,\n\t\t\t\t\traycast: null,\n\t\t\t\t\tdepthTest: pivotControls.depthTest(),\n\t\t\t\t\tlineWidth: pivotControls.lineWidth(),\n\t\t\t\t\tside: DoubleSide,\n\t\t\t\t\tcolor: hovered() ? pivotControls.hoveredColor() : pivotControls.axisColors()[axis()],\n\t\t\t\t\topacity: pivotControls.opacity(),\n\t\t\t\t\tpolygonOffset: true,\n\t\t\t\t\tpolygonOffsetFactor: -10,\n\t\t\t\t\tfog: false,\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: [NgtsLine, NgtsHTML, NgtsHTMLContent],\n})\nexport class NgtsAxisRotator {\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\thovered = signal(false);\n\tprivate angle = 0;\n\tprivate angle0 = 0;\n\tprivate clickInfo: {\n\t\tclickPoint: Vector3;\n\t\torigin: Vector3;\n\t\te1: Vector3;\n\t\te2: Vector3;\n\t\tnormal: Vector3;\n\t\tplane: Plane;\n\t} | null = null;\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\tr = computed(() => (this.pivotControls.fixed() ? 0.65 : this.pivotControls.scale() * 0.65));\n\tarc = computed(() => {\n\t\tconst segments = 32;\n\t\tconst points: Vector3[] = [];\n\t\tfor (let j = 0; j <= segments; j++) {\n\t\t\tconst angle = (j * (Math.PI / 2)) / segments;\n\t\t\tpoints.push(new Vector3(Math.cos(angle) * this.r(), Math.sin(angle) * this.r(), 0));\n\t\t}\n\t\treturn points;\n\t});\n\n\tconstructor() {\n\t\textend({ Group });\n\t}\n\n\tonPointerDown(event: NgtThreeEvent<PointerEvent>) {\n\t\tconst [annotation, group, axis, controls] = [\n\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\tthis.groupRef().nativeElement,\n\t\t\tthis.axis(),\n\t\t\tthis.controls(),\n\t\t];\n\n\t\tif (annotation) {\n\t\t\tannotation.innerText = `${toDegrees(this.angle).toFixed(0)}º`;\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, origin, e1, e2, normal, plane };\n\t\tthis.pivotControls.onDragStart({ component: 'Rotator', axis, origin, directions: [e1, e2, normal] });\n\n\t\tif (controls) {\n\t\t\tcontrols.enabled = false;\n\t\t}\n\n\t\t// @ts-expect-error - setPointerCapture is not a function on PointerEvent\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\t\tif (this.clickInfo) {\n\t\t\tconst { clickPoint, origin, e1, e2, normal, plane } = this.clickInfo;\n\t\t\tconst [rotationLimits, axis, annotation] = [\n\t\t\t\tthis.pivotControls.rotationLimits(),\n\t\t\t\tthis.axis(),\n\t\t\t\tthis.annotationRef()?.nativeElement,\n\t\t\t];\n\n\t\t\tconst [min, max] = rotationLimits?.[axis] || [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\tlet deltaAngle = calculateAngle(clickPoint, intersection, origin, e1, e2);\n\t\t\tlet degrees = toDegrees(deltaAngle);\n\n\t\t\tif (event.shiftKey) {\n\t\t\t\tdegrees = Math.round(degrees / 10) * 10;\n\t\t\t\tdeltaAngle = toRadians(degrees);\n\t\t\t}\n\n\t\t\tif (min !== undefined && max !== undefined && max - min < 2 * Math.PI) {\n\t\t\t\tdeltaAngle = minimizeAngle(deltaAngle);\n\t\t\t\tdeltaAngle = deltaAngle > Math.PI ? deltaAngle - 2 * Math.PI : deltaAngle;\n\t\t\t\tdeltaAngle = Math.round(deltaAngle / 10) * 10;\n\t\t\t\tthis.angle = this.angle0 + deltaAngle;\n\t\t\t} else {\n\t\t\t\tthis.angle = minimizeAngle(this.angle0 + deltaAngle);\n\t\t\t\tthis.angle = this.angle > Math.PI ? this.angle - 2 * Math.PI : this.angle;\n\t\t\t}\n\n\t\t\tif (annotation) {\n\t\t\t\tdegrees = toDegrees(this.angle);\n\t\t\t\tannotation.innerText = `${degrees.toFixed(0)}º`;\n\t\t\t}\n\n\t\t\trotMatrix.makeRotationAxis(normal, deltaAngle);\n\t\t\tposNew.copy(origin).applyMatrix4(rotMatrix).sub(origin).negate();\n\t\t\trotMatrix.setPosition(posNew);\n\t\t\tthis.pivotControls.onDrag(rotMatrix);\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 a function on PointerEvent\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"]}