Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

App: Ansichtswürfel in 3D und frei setzbarer Drehpunkt

Kai-Jungsthoefel3f543225bae0
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 12b5910..8f93e7b 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -85,11 +85,8 @@
</div>
<div id="cube" class="cube">
- <svg width="100" height="96" viewBox="0 0 100 96" aria-label="Ansichtswürfel">
- <g class="face" data-view="top" role="button" tabindex="0" aria-label="Ansicht von oben"><polygon points="50,6 90,24 50,42 10,24"/><text x="50" y="27">OBEN</text></g>
- <g class="face" data-view="front" role="button" tabindex="0" aria-label="Ansicht von vorne"><polygon points="10,24 50,42 50,88 10,70"/><text x="30" y="59">VORNE</text></g>
- <g class="face" data-view="right" role="button" tabindex="0" aria-label="Ansicht von rechts"><polygon points="50,42 90,24 90,70 50,88"/><text x="70" y="59">RECHTS</text></g>
- </svg>
+ <!-- Ansichtswürfel (viewcube.ts): 3D, dreht sich mit der Kamera. Per Tastatur gehen die Ansichten über „Darstellung“. -->
+ <div id="cube-view" class="cube-view" role="img" aria-label="Ansichtswürfel" title="Seite, Kante oder Ecke anklicken: Ansicht von dort. Ziehen dreht die Ansicht."></div>
<div class="vbtns">
<button data-view="fit" aria-label="Alles einpassen" title="Alles einpassen"><i data-icon="fit"></i></button>
<button data-view="iso" aria-label="Standardansicht" title="Standardansicht (isometrisch)"><i data-icon="home"></i></button>
@@ -228,6 +225,13 @@
<button class="mi keep" role="menuitemcheckbox" data-display="edges" aria-checked="true"><span class="chk"><i data-icon="check" data-size="15" data-stroke="2.2"></i></span><span>Kanten</span></button>
<button class="mi keep" role="menuitemcheckbox" data-display="wire" aria-checked="false"><span class="chk"><i data-icon="check" data-size="15" data-stroke="2.2"></i></span><span>Drahtgitter</span></button>
<button class="mi keep" role="menuitemcheckbox" data-display="ghost" aria-checked="false"><span class="chk"><i data-icon="check" data-size="15" data-stroke="2.2"></i></span><span>Transparent</span></button>
+ <div class="msep"></div>
+ <div class="mh">ANSICHT</div>
+ <div class="chips views">
+ <button class="chip" data-view="front">Vorne</button><button class="chip" data-view="back">Hinten</button><button class="chip" data-view="left">Links</button>
+ <button class="chip" data-view="right">Rechts</button><button class="chip" data-view="top">Oben</button><button class="chip" data-view="bottom">Unten</button>
+ </div>
+ <div class="mnote">Doppelklick ins Modell setzt den Drehpunkt. Das Mausrad zoomt zur Mausposition, die rechte Maustaste verschiebt. „Einpassen“ neben dem Würfel setzt zurück.</div>
</div>
<div id="menu-export" class="menu wide" role="menu" hidden>
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index 06c3b71..8243c85 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -15,6 +15,7 @@ hydrateIcons();
const api = window.cadide;
const viewer = new Viewer($('viewer'));
+viewer.attachCube($('cube-view'));
const terminals = new TerminalTabs($('term-tabs'), $('term-panes'), $('btn-term-add'), $('strip-tabs'));
let project: ProjectInfo | null = null;
@@ -630,11 +631,8 @@ async function doExport(fmt: string, label: string): Promise<void> {
// ---- Viewer-Bedienung -------------------------------------------------------------------------------------------
-document.querySelectorAll<HTMLElement>('[data-view]').forEach((b) => {
- const go = () => viewer.setView(b.dataset.view as ViewName);
- b.addEventListener('click', go);
- b.addEventListener('keydown', (e) => { if (b.tagName !== 'BUTTON' && (e.key === 'Enter' || e.key === ' ')) { e.preventDefault(); go(); } });
-});
+// Einpassen, Standardansicht und die Ansichten im Menü „Darstellung“ (der Würfel selbst steuert über viewcube.ts)
+document.querySelectorAll<HTMLButtonElement>('[data-view]').forEach((b) => b.addEventListener('click', () => viewer.setView(b.dataset.view as ViewName)));
$('btn-sel-close').addEventListener('click', () => selectPart(null, null));
$('btn-sel-code').addEventListener('click', () => {
const e = selection ? partEntry(selection.partId) : undefined;
diff --git a/app/src/renderer/style.css b/app/src/renderer/style.css
index 9009963..c8e161d 100644
--- a/app/src/renderer/style.css
+++ b/app/src/renderer/style.css
@@ -220,13 +220,9 @@ code { font-family:var(--mono); font-size:.95em; }
@container viewer (max-width: 900px) { .dock .lbl { display:none; } .dock button { padding:0 8px; gap:3px; } }
.cube { position:absolute; top:12px; right:14px; z-index:2; display:flex; flex-direction:column; align-items:center; gap:8px; }
-.cube .face { cursor:pointer; outline:none; }
-.cube .face polygon { stroke:#56606c; stroke-width:1; transition:fill .1s; }
-.cube .face[data-view=top] polygon { fill:#2b3139; }
-.cube .face[data-view=front] polygon { fill:#232830; }
-.cube .face[data-view=right] polygon { fill:#1e2228; }
-.cube .face:hover polygon, .cube .face:focus-visible polygon { fill:rgba(242,154,56,.35); stroke:var(--acc); }
-.cube text { font-size:7.5px; font-weight:600; fill:#c9ced4; font-family:var(--sans); letter-spacing:.3px; text-anchor:middle; pointer-events:none; }
+.cube-view { width:116px; height:116px; }
+.cube-view canvas { display:block; cursor:grab; }
+.chips.views .chip { min-width:62px; }
.vbtns { display:flex; flex-direction:column; gap:2px; padding:3px; background:rgba(24,27,31,.95); border:1px solid var(--line2); border-radius:9px; }
.vbtns button { width:30px; height:30px; display:flex; align-items:center; justify-content:center; border-radius:6px; color:#c9ced4; }
.vbtns button:hover { background:var(--s3); }
diff --git a/app/src/renderer/viewcube.ts b/app/src/renderer/viewcube.ts
new file mode 100644
index 0000000..c23f4b5
--- /dev/null
+++ b/app/src/renderer/viewcube.ts
@@ -0,0 +1,201 @@
+import * as THREE from 'three';
+
+/** Was der Würfel vom Viewer braucht. */
+export interface CubeHost {
+ camera: THREE.PerspectiveCamera;
+ target(): THREE.Vector3;
+ /** Ansicht aus dieser Richtung (vom Drehpunkt zur Kamera), animiert, Abstand und Drehpunkt bleiben. */
+ orient(dir: THREE.Vector3): void;
+ /** Um den Drehpunkt drehen: Winkel um die Hochachse und zur Hochachse hin (Bogenmaß). */
+ orbit(dTheta: number, dPhi: number): void;
+}
+
+/** Seiten des Würfels. CAD-Konvention der App: Z oben, vorne ist -Y (so zeigt auch „Vorne“ im Viewer). */
+const FACES: { n: [number, number, number]; up: [number, number, number]; text: string; bg: string }[] = [
+ { n: [0, 0, 1], up: [0, 1, 0], text: 'OBEN', bg: '#2b3139' },
+ { n: [0, 0, -1], up: [0, -1, 0], text: 'UNTEN', bg: '#2b3139' },
+ { n: [0, -1, 0], up: [0, 0, 1], text: 'VORNE', bg: '#262b33' },
+ { n: [0, 1, 0], up: [0, 0, 1], text: 'HINTEN', bg: '#262b33' },
+ { n: [1, 0, 0], up: [0, 0, 1], text: 'RECHTS', bg: '#20252c' },
+ { n: [-1, 0, 0], up: [0, 0, 1], text: 'LINKS', bg: '#20252c' },
+];
+/** Grenze zwischen Mitte und Rand einer Seite. Der Würfel reicht von -1 bis 1, außen liegen Kanten und Ecken. */
+const EDGE = 0.62;
+const SIZE = 116; // CSS-Pixel
+const DRAG_PX = 3;
+const AXES: { dir: [number, number, number]; color: string; label: string }[] = [
+ { dir: [1, 0, 0], color: '#e5534b', label: 'X' }, { dir: [0, 1, 0], color: '#57ab5a', label: 'Y' }, { dir: [0, 0, 1], color: '#539bf5', label: 'Z' },
+];
+
+/** Richtung in Worten, für den Hinweis beim Überfahren: „Oben vorne rechts“. */
+function dirName(s: number[]): string {
+ const parts = [s[2] > 0 ? 'oben' : s[2] < 0 ? 'unten' : '', s[1] < 0 ? 'vorne' : s[1] > 0 ? 'hinten' : '', s[0] > 0 ? 'rechts' : s[0] < 0 ? 'links' : ''].filter(Boolean);
+ const t = parts.join(' ');
+ return t.charAt(0).toUpperCase() + t.slice(1);
+}
+
+/**
+ * Ansichtswürfel wie in CAD-Programmen: eine eigene kleine 3D-Szene, die sich mit der Kamera dreht. Ein Klick auf eine
+ * Seite, Kante oder Ecke (3 × 3 Felder je Seite, 26 Richtungen) dreht die Ansicht dorthin, Ziehen dreht frei.
+ * Drehpunkt und Abstand bleiben dabei, damit man nah an einer Stelle bleiben kann. Einpassen macht der Knopf darunter.
+ */
+export class ViewCube {
+ private renderer: THREE.WebGLRenderer;
+ private scene = new THREE.Scene();
+ private cam = new THREE.OrthographicCamera(-2.05, 2.05, 2.05, -2.05, 0.1, 20);
+ private faces: THREE.Mesh[] = [];
+ private textures: { tex: THREE.CanvasTexture; draw: () => void }[] = [];
+ private hl = new THREE.Group();
+ private hoverKey = '';
+ private raycaster = new THREE.Raycaster();
+
+ constructor(private el: HTMLElement, private host: CubeHost) {
+ this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+ this.renderer.setPixelRatio(window.devicePixelRatio);
+ this.renderer.setSize(SIZE, SIZE);
+ this.renderer.setClearColor(0x000000, 0);
+ el.appendChild(this.renderer.domElement);
+ this.build();
+ this.installPointer();
+ // Beschriftung erst mit der eigenen Schrift sauber: nachzeichnen, sobald sie geladen ist
+ void document.fonts?.ready.then(() => { for (const t of this.textures) { t.draw(); t.tex.needsUpdate = true; } this.render(); });
+ }
+
+ private build(): void {
+ for (const f of FACES) {
+ const c = document.createElement('canvas');
+ c.width = c.height = 256;
+ const draw = () => {
+ const g = c.getContext('2d')!;
+ g.fillStyle = f.bg;
+ g.fillRect(0, 0, 256, 256);
+ g.fillStyle = '#c9ced4';
+ g.font = `600 44px "IBM Plex Sans", "Segoe UI", sans-serif`;
+ g.textAlign = 'center';
+ g.textBaseline = 'middle';
+ g.fillText(f.text, 128, 132);
+ };
+ draw();
+ const tex = new THREE.CanvasTexture(c);
+ tex.colorSpace = THREE.SRGBColorSpace;
+ tex.anisotropy = 4;
+ this.textures.push({ tex, draw });
+ // Ebene 2 × 2 ausrichten: rechts = oben × Normale, damit die Schrift aus der Ansicht dieser Seite lesbar steht
+ const n = new THREE.Vector3(...f.n), up = new THREE.Vector3(...f.up), right = up.clone().cross(n);
+ const m = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), new THREE.MeshBasicMaterial({ map: tex }));
+ m.applyMatrix4(new THREE.Matrix4().makeBasis(right, up, n).setPosition(n));
+ m.userData.normal = n;
+ this.faces.push(m);
+ this.scene.add(m);
+ }
+ const edges = new THREE.LineSegments(new THREE.EdgesGeometry(new THREE.BoxGeometry(2.01, 2.01, 2.01)), new THREE.LineBasicMaterial({ color: 0x56606c }));
+ this.scene.add(edges, this.hl);
+ // Achsen an der Ecke links vorne unten, wie gewohnt X rot, Y grün, Z blau
+ const o = new THREE.Vector3(-1.02, -1.02, -1.02);
+ for (const a of AXES) {
+ const d = new THREE.Vector3(...a.dir);
+ const g = new THREE.BufferGeometry().setFromPoints([o, o.clone().addScaledVector(d, 2.4)]);
+ this.scene.add(new THREE.Line(g, new THREE.LineBasicMaterial({ color: a.color })));
+ const lc = document.createElement('canvas');
+ lc.width = lc.height = 64;
+ const lg = lc.getContext('2d')!;
+ lg.fillStyle = a.color;
+ lg.font = '700 44px "IBM Plex Sans", "Segoe UI", sans-serif';
+ lg.textAlign = 'center';
+ lg.textBaseline = 'middle';
+ lg.fillText(a.label, 32, 34);
+ const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(lc), depthTest: false }));
+ sp.position.copy(o).addScaledVector(d, 2.66);
+ sp.scale.setScalar(0.38);
+ this.scene.add(sp);
+ }
+ }
+
+ /** Nach jedem Bild des Viewers: dieselbe Blickrichtung wie die Hauptkamera. */
+ render(): void {
+ const dir = this.host.camera.position.clone().sub(this.host.target());
+ if (dir.lengthSq() < 1e-18) return;
+ this.cam.position.copy(dir.normalize().multiplyScalar(6));
+ this.cam.up.copy(this.host.camera.up);
+ this.cam.lookAt(0, 0, 0);
+ this.renderer.render(this.scene, this.cam);
+ }
+
+ // ---- Eingabe --------------------------------------------------------------------------------------------------
+
+ /** Feld unter dem Zeiger als Richtung mit Komponenten -1, 0, 1 (Mitte einer Seite, Kante oder Ecke). */
+ private regionAt(clientX: number, clientY: number): number[] | null {
+ const r = this.renderer.domElement.getBoundingClientRect();
+ this.raycaster.setFromCamera(new THREE.Vector2(((clientX - r.left) / r.width) * 2 - 1, -((clientY - r.top) / r.height) * 2 + 1), this.cam);
+ const hit = this.raycaster.intersectObjects(this.faces, false)[0];
+ if (!hit) return null;
+ const p = hit.point, n = hit.object.userData.normal as THREE.Vector3;
+ return [p.x, p.y, p.z].map((v, k) => (n.getComponent(k) !== 0 ? n.getComponent(k) : v > EDGE ? 1 : v < -EDGE ? -1 : 0));
+ }
+
+ private installPointer(): void {
+ const c = this.renderer.domElement;
+ let down: { x: number; y: number; lx: number; ly: number; dragged: boolean } | null = null;
+ c.addEventListener('pointerdown', (e) => {
+ if (e.button !== 0) return;
+ e.preventDefault();
+ down = { x: e.clientX, y: e.clientY, lx: e.clientX, ly: e.clientY, dragged: false };
+ try { c.setPointerCapture(e.pointerId); } catch { /* synthetische Ereignisse (Tests) */ }
+ });
+ c.addEventListener('pointermove', (e) => {
+ if (down) {
+ if (!down.dragged && Math.hypot(e.clientX - down.x, e.clientY - down.y) > DRAG_PX) { down.dragged = true; this.setHover(null); }
+ if (down.dragged) {
+ // Wie Ziehen im Viewer: nach rechts ziehen dreht das Modell nach rechts
+ const k = (2 * Math.PI) / (SIZE * 3);
+ this.host.orbit(-(e.clientX - down.lx) * k, -(e.clientY - down.ly) * k);
+ down.lx = e.clientX; down.ly = e.clientY;
+ }
+ return;
+ }
+ this.setHover(this.regionAt(e.clientX, e.clientY));
+ });
+ c.addEventListener('pointerup', (e) => {
+ const d = down;
+ down = null;
+ if (!d || d.dragged) return;
+ const s = this.regionAt(e.clientX, e.clientY);
+ if (s) this.host.orient(new THREE.Vector3(s[0], s[1], s[2]));
+ });
+ c.addEventListener('pointerleave', () => { if (!down) this.setHover(null); });
+ }
+
+ /** Feld hervorheben: auf jeder Seite, die zur Richtung gehört, das passende der 3 × 3 Felder. */
+ private setHover(s: number[] | null): void {
+ const key = s ? s.join(',') : '';
+ if (key === this.hoverKey) return;
+ this.hoverKey = key;
+ for (const o of [...this.hl.children]) { this.hl.remove(o); (o as THREE.Mesh).geometry.dispose(); ((o as THREE.Mesh).material as THREE.Material).dispose(); }
+ this.el.title = s ? `${dirName(s)}: Ansicht von dort (Klick). Ziehen dreht.` : 'Seite, Kante oder Ecke anklicken: Ansicht von dort. Ziehen dreht die Ansicht.';
+ if (s) {
+ const range = (v: number): [number, number] => (v < 0 ? [-1, -EDGE] : v > 0 ? [EDGE, 1] : [-EDGE, EDGE]);
+ for (let a = 0; a < 3; a++) {
+ if (!s[a]) continue;
+ const [b, c] = [0, 1, 2].filter((k) => k !== a);
+ const [b0, b1] = range(s[b]), [c0, c1] = range(s[c]);
+ const corner = (vb: number, vc: number) => { const v = [0, 0, 0]; v[a] = s[a] * 1.004; v[b] = vb; v[c] = vc; return v; };
+ const pos = [...corner(b0, c0), ...corner(b1, c0), ...corner(b1, c1), ...corner(b0, c0), ...corner(b1, c1), ...corner(b0, c1)];
+ const g = new THREE.BufferGeometry();
+ g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+ this.hl.add(new THREE.Mesh(g, new THREE.MeshBasicMaterial({ color: 0xf29a38, transparent: true, opacity: 0.6, side: THREE.DoubleSide })));
+ }
+ }
+ this.renderer.domElement.style.cursor = s ? 'pointer' : 'grab';
+ this.render();
+ }
+
+ // ---- Prüfhilfe (nur Tests) ------------------------------------------------------------------------------------
+
+ /** Bildschirmposition (Fenster-Pixel) eines Punkts auf dem Würfel, etwa (0, -1, 0) für die Mitte von „Vorne“. */
+ screenOf(p: number[]): { x: number; y: number } {
+ this.render();
+ const v = new THREE.Vector3(p[0], p[1], p[2]).project(this.cam);
+ const r = this.renderer.domElement.getBoundingClientRect();
+ return { x: r.left + ((v.x + 1) / 2) * r.width, y: r.top + ((1 - v.y) / 2) * r.height };
+ }
+}
diff --git a/app/src/renderer/viewer.ts b/app/src/renderer/viewer.ts
index 7228c63..a589417 100644
--- a/app/src/renderer/viewer.ts
+++ b/app/src/renderer/viewer.ts
@@ -4,6 +4,7 @@ import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import { ViewCube } from './viewcube';
// CAD-Konvention: Z ist oben, Einheit mm. Muss vor dem Anlegen von Kamera und Objekten gesetzt sein.
THREE.Object3D.DEFAULT_UP.set(0, 0, 1);
@@ -20,7 +21,7 @@ export interface PickResult {
point: number[];
}
-export type ViewName = 'iso' | 'front' | 'top' | 'right' | 'fit';
+export type ViewName = 'iso' | 'front' | 'back' | 'top' | 'bottom' | 'right' | 'left' | 'fit';
/** Treffer beim Messen: Fläche, Kante oder Eckpunkt eines Bauteils, mit Punkt auf dem Netz (beim Eckpunkt seine Lage). */
export interface ProbeHit {
@@ -70,6 +71,14 @@ export class Viewer {
/** HTML-Ebene über dem Bild: Messpunkte und Beschriftung, bei jedem Zeichnen neu positioniert. */
private overlay: HTMLElement;
private overlayItems: { el: HTMLElement; at: THREE.Vector3 }[] = [];
+ /** Mitte und Radius aller Bauteile, für die Schnittebenen der Kamera. */
+ private center = new THREE.Vector3();
+ private radius = 1;
+ private cube: ViewCube | null = null;
+ private anim: { stop(): void } | null = null;
+ /** Punkt am Drehpunkt, sichtbar während der Bewegung und kurz nach dem Setzen. */
+ private pivot: THREE.Points;
+ private pivotTimer: ReturnType<typeof setTimeout> | undefined;
onPick: (r: PickResult | null) => void = () => {};
/** Klick im Messmodus. null: daneben geklickt. */
onMeasurePick: (h: ProbeHit | null) => void = () => {};
@@ -90,7 +99,18 @@ export class Viewer {
container.appendChild(this.overlay);
this.controls = new OrbitControls(this.camera, this.renderer.domElement);
this.controls.enableDamping = false; // gerendert wird nur bei Änderungen
- this.controls.addEventListener('change', () => this.requestRender());
+ // Zoomen zur Mausposition statt zur Mitte: So kommt man an Ecken und Kanten heran, ohne erst zu verschieben
+ this.controls.zoomToCursor = true;
+ this.controls.minDistance = 0.05;
+ this.controls.addEventListener('change', () => { this.fitClip(); this.requestRender(); });
+ this.controls.addEventListener('start', () => { this.anim?.stop(); this.showPivot(true); });
+ this.controls.addEventListener('end', () => this.showPivot(false, 350));
+ const pg = new THREE.BufferGeometry();
+ pg.setAttribute('position', new THREE.Float32BufferAttribute([0, 0, 0], 3));
+ this.pivot = new THREE.Points(pg, new THREE.PointsMaterial({ color: 0xe6e8eb, size: 11, sizeAttenuation: false, map: Viewer.dot(), transparent: true, alphaTest: 0.2, depthTest: false }));
+ this.pivot.renderOrder = 12;
+ this.pivot.visible = false;
+ this.scene.add(this.pivot);
new ResizeObserver(() => this.resize()).observe(container);
this.resize();
this.installPicking();
@@ -135,7 +155,10 @@ export class Viewer {
this.hoverKey = '';
if (this.selectedId && !this.parts.has(this.selectedId)) this.selectedId = null;
this.applySelection();
+ const box = this.bounds([...this.parts.keys()]);
+ if (!box.isEmpty()) { box.getCenter(this.center); this.radius = Math.max(box.getSize(new THREE.Vector3()).length() / 2, 1); }
if (!this.hasFitted && this.parts.size) { this.setView('iso'); this.hasFitted = true; }
+ this.fitClip();
this.requestRender();
}
@@ -230,20 +253,119 @@ export class Viewer {
const center = box.getCenter(new THREE.Vector3());
const radius = Math.max(box.getSize(new THREE.Vector3()).length() / 2, 1);
const dir = {
- iso: new THREE.Vector3(0.8, -1.2, 0.9), front: new THREE.Vector3(0, -1, 0),
- top: new THREE.Vector3(0, -0.0001, 1), right: new THREE.Vector3(1, 0, 0),
+ iso: new THREE.Vector3(0.8, -1.2, 0.9), front: new THREE.Vector3(0, -1, 0), back: new THREE.Vector3(0, 1, 0),
+ top: new THREE.Vector3(0, -0.0001, 1), bottom: new THREE.Vector3(0, -0.0001, -1),
+ right: new THREE.Vector3(1, 0, 0), left: new THREE.Vector3(-1, 0, 0),
fit: this.camera.position.clone().sub(this.controls.target),
}[name].clone().normalize();
const dist = radius / Math.sin(THREE.MathUtils.degToRad(this.camera.fov / 2)) * 1.05;
+ this.anim?.stop();
this.controls.target.copy(center);
this.camera.position.copy(center).addScaledVector(dir, dist);
- this.camera.near = Math.max(dist / 1000, 0.05);
- this.camera.far = dist * 20;
- this.camera.updateProjectionMatrix();
this.controls.update();
+ this.fitClip();
this.requestRender();
}
+ // ---- Ansichtswürfel und Drehpunkt -----------------------------------------------------------------------------
+
+ /** Den Ansichtswürfel in diesem Element anzeigen. Er dreht sich mit der Kamera und dreht sie auf Klick oder Ziehen. */
+ attachCube(el: HTMLElement): void {
+ this.cube = new ViewCube(el, {
+ camera: this.camera,
+ target: () => this.controls.target,
+ orient: (d) => this.orient(d),
+ orbit: (t, p) => this.orbit(t, p),
+ });
+ this.cube.render();
+ }
+
+ /** Ansicht aus einer Richtung (vom Drehpunkt zur Kamera), animiert. Drehpunkt und Abstand bleiben, anders als bei setView. */
+ orient(dir: THREE.Vector3): void {
+ const target = this.controls.target.clone();
+ const dist = this.camera.position.distanceTo(target);
+ const from = this.camera.position.clone().sub(target).normalize();
+ const to = dir.clone().normalize();
+ // Genau senkrecht kann die Kamera nicht stehen (Hochachse Z): ein Hauch nach vorne, dann liegt „Vorne“ unten im Bild
+ if (Math.abs(to.z) > 0.999999) to.set(0, -1e-4, Math.sign(to.z)).normalize();
+ const q = new THREE.Quaternion().setFromUnitVectors(from, to), id = new THREE.Quaternion();
+ this.animate(280, (t) => {
+ this.camera.position.copy(target).addScaledVector(from.clone().applyQuaternion(id.clone().slerp(q, t)), dist);
+ this.controls.update();
+ });
+ }
+
+ /** Um den Drehpunkt drehen, wie OrbitControls es tut (Kugelkoordinaten zur Hochachse). */
+ orbit(dTheta: number, dPhi: number): void {
+ this.anim?.stop();
+ const target = this.controls.target;
+ const toY = new THREE.Quaternion().setFromUnitVectors(this.camera.up, new THREE.Vector3(0, 1, 0));
+ const off = this.camera.position.clone().sub(target).applyQuaternion(toY);
+ const sph = new THREE.Spherical().setFromVector3(off);
+ sph.theta += dTheta;
+ sph.phi = Math.min(Math.PI - 1e-4, Math.max(1e-4, sph.phi + dPhi));
+ off.setFromSpherical(sph).applyQuaternion(toY.invert());
+ this.camera.position.copy(target).add(off);
+ this.controls.update();
+ }
+
+ /**
+ * Neuer Drehpunkt: Die Ansicht verschiebt sich (ohne zu drehen), bis der Punkt in der Mitte liegt. Danach dreht und
+ * zoomt sie um ihn. So lassen sich Ecken und kleine Stellen genau ansehen. „Einpassen“ oder „Standardansicht“ setzen zurück.
+ */
+ setPivot(p: THREE.Vector3): void {
+ const t0 = this.controls.target.clone(), c0 = this.camera.position.clone();
+ const delta = p.clone().sub(t0);
+ this.animate(250, (t) => {
+ this.controls.target.copy(t0).addScaledVector(delta, t);
+ this.camera.position.copy(c0).addScaledVector(delta, t);
+ this.controls.update();
+ });
+ this.showPivot(true);
+ this.showPivot(false, 900);
+ }
+
+ /** Zeitgesteuerte Bewegung. Ohne Bildwiederholung (unsichtbares Fenster) steht sie nach Ablauf trotzdem am Ziel. */
+ private animate(ms: number, step: (t: number) => void): void {
+ this.anim?.stop();
+ const t0 = performance.now();
+ let raf = 0, done = false;
+ const stop = () => { done = true; cancelAnimationFrame(raf); clearTimeout(timer); if (this.anim === handle) this.anim = null; };
+ const finish = () => { if (done) return; stop(); step(1); };
+ const tick = () => {
+ if (done) return;
+ const t = Math.min(1, (performance.now() - t0) / ms);
+ if (t >= 1) { finish(); return; }
+ step(t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2);
+ raf = requestAnimationFrame(tick);
+ };
+ const timer = setTimeout(finish, ms + 60);
+ const handle = { stop };
+ this.anim = handle;
+ raf = requestAnimationFrame(tick);
+ }
+
+ private showPivot(on: boolean, afterMs = 0): void {
+ clearTimeout(this.pivotTimer);
+ const apply = () => { this.pivot.visible = on && this.parts.size > 0; this.requestRender(); };
+ if (afterMs) this.pivotTimer = setTimeout(apply, afterMs); else apply();
+ }
+
+ /**
+ * Schnittebenen der Kamera nach Abstand: Nah am Drehpunkt muss die vordere Ebene nah heran, sonst schneidet sie die
+ * Ecke weg, die man ansehen will. Die hintere reicht über das ganze Modell.
+ */
+ private fitClip(): void {
+ const dist = Math.max(this.camera.position.distanceTo(this.controls.target), 1e-3);
+ const near = Math.max(dist / 200, 1e-3);
+ const far = Math.max(this.camera.position.distanceTo(this.center) + this.radius * 2, near * 100);
+ if (Math.abs(near - this.camera.near) > near * 0.02 || Math.abs(far - this.camera.far) > far * 0.02) {
+ this.camera.near = near;
+ this.camera.far = far;
+ this.camera.updateProjectionMatrix();
+ }
+ }
+
focusPart(id: string): void { if (this.parts.has(id)) this.setView('fit', [id]); }
// ---- Auswahl --------------------------------------------------------------------------------------------------
@@ -308,6 +430,15 @@ export class Viewer {
queued = [e.clientX, e.clientY];
});
el.addEventListener('pointerleave', () => this.showHover(null));
+ // Doppelklick ins Modell: Drehpunkt dorthin (auch beim Messen)
+ el.addEventListener('dblclick', (e) => {
+ const r = el.getBoundingClientRect();
+ this.raycaster.setFromCamera(new THREE.Vector2(((e.clientX - r.left) / r.width) * 2 - 1, -((e.clientY - r.top) / r.height) * 2 + 1), this.camera);
+ const targets: THREE.Mesh[] = [];
+ for (const p of this.parts.values()) if (p.group.visible) targets.push(...p.meshes);
+ const hit = this.raycaster.intersectObjects(targets, false)[0];
+ if (hit) this.setPivot(hit.point.clone());
+ });
}
// ---- Messen ---------------------------------------------------------------------------------------------------
@@ -575,7 +706,13 @@ export class Viewer {
requestRender(): void {
if (this.renderQueued) return;
this.renderQueued = true;
- requestAnimationFrame(() => { this.renderQueued = false; this.renderer.render(this.scene, this.camera); this.placeOverlay(); });
+ requestAnimationFrame(() => {
+ this.renderQueued = false;
+ this.pivot.position.copy(this.controls.target);
+ this.renderer.render(this.scene, this.camera);
+ this.placeOverlay();
+ this.cube?.render();
+ });
}
/**
@@ -590,6 +727,8 @@ export class Viewer {
this.highlight.visible = false;
this.hover.visible = false; // Messlinien ohne ihre Beschriftung wären im Bild nur verwirrend
this.marks.visible = false;
+ const pivotShown = this.pivot.visible;
+ this.pivot.visible = false;
this.renderer.render(this.scene, this.camera);
const c = document.createElement('canvas');
try { this.paintSnapshot(c); } finally {
@@ -598,6 +737,7 @@ export class Viewer {
this.highlight.visible = true;
this.hover.visible = true;
this.marks.visible = true;
+ this.pivot.visible = pivotShown;
this.requestRender();
}
return c;
@@ -671,6 +811,16 @@ export class Viewer {
return (this.parts.get(partId)?.meta.vertices ?? []).map((v) => ({ id: v.id, p: v.p, screen: this.screenAt(v.p) }));
}
+ /** Kamera, Drehpunkt und Schnittebenen, für Tests. */
+ viewState() {
+ const d = this.camera.position.clone().sub(this.controls.target);
+ return { target: this.controls.target.toArray(), dir: d.clone().normalize().toArray(), dist: d.length(), near: this.camera.near, far: this.camera.far,
+ zoomToCursor: this.controls.zoomToCursor, animating: !!this.anim };
+ }
+
+ /** Bildschirmposition eines Punkts auf dem Ansichtswürfel, für Tests. */
+ cubeScreen(p: number[]): { x: number; y: number } | null { return this.cube ? this.cube.screenOf(p) : null; }
+
/** Bildschirmposition (Pixel im Fenster) eines Weltpunkts. */
screenAt(p: number[]): { x: number; y: number } {
this.camera.updateMatrixWorld();
diff --git a/app/test/smoke.mjs b/app/test/smoke.mjs
index 9234651..57e1c10 100644
--- a/app/test/smoke.mjs
+++ b/app/test/smoke.mjs
@@ -236,6 +236,51 @@ try {
const exp = await ev(() => window.cadide.build.export('stl', null));
check('Export STL: alle Bauteile nach exports/', exp.ok && ['exports/Body.stl', 'exports/Lid.stl'].every((f) => exp.files.includes(f) && fs.existsSync(path.join(proj.dir, f))), exp.error ?? exp.files.join(','));
+ // 7b) Ansicht: Würfel (Seite, Ecke, Ziehen), Drehpunkt per Doppelklick, Zoom zur Maus, Ansichten im Menü
+ const vs = () => ev(() => window.__t.viewer.viewState());
+ const settle = () => waitFor('Ansicht steht', () => !window.__t.viewer.viewState().animating, 5000).catch(() => {});
+ const near = (a, b, tol = 1e-3) => a.every((v, i) => Math.abs(v - b[i]) < tol);
+ const unit = (v) => { const l = Math.hypot(...v); return v.map((x) => x / l); };
+ await ev(() => window.__t.viewer.setView('iso'));
+ const v0 = await vs();
+ check('Ansichtswürfel ist da (3D, eigene Zeichenfläche)', await ev(() => { const c = document.querySelector('#cube-view canvas'); return !!c && c.width > 0; }));
+ await page.click(...Object.values(await ev(() => window.__t.viewer.cubeScreen([0, -1, 0]))));
+ await settle();
+ let v1 = await vs();
+ check('Würfel „Vorne" anklicken: Ansicht von vorne, Drehpunkt und Abstand bleiben', near(v1.dir, [0, -1, 0]) && near(v1.target, v0.target) && Math.abs(v1.dist - v0.dist) < 1e-6, v1.dir.map((x) => x.toFixed(3)).join(','));
+ await page.click(...Object.values(await ev(() => window.__t.viewer.cubeScreen([0.85, -1, 0.85]))));
+ await settle();
+ v1 = await vs();
+ check('Ecke „oben vorne rechts" anklicken: Blick schräg von dort', near(v1.dir, unit([1, -1, 1])), v1.dir.map((x) => x.toFixed(3)).join(','));
+ await ev((p) => {
+ const c = document.querySelector('#cube-view canvas'), f = (type, x) => c.dispatchEvent(new PointerEvent(type, { clientX: x, clientY: p.y, bubbles: true, button: 0, buttons: 1, pointerId: 1 }));
+ f('pointerdown', p.x); f('pointermove', p.x + 20); f('pointermove', p.x + 40); f('pointerup', p.x + 40);
+ }, await ev(() => window.__t.viewer.cubeScreen([0, -1, 0])));
+ const v2 = await vs();
+ check('Würfel ziehen dreht die Ansicht um den Drehpunkt', !near(v2.dir, v1.dir, 1e-2) && near(v2.target, v1.target) && Math.abs(v2.dir[2] - v1.dir[2]) < 1e-6, v2.dir.map((x) => x.toFixed(3)).join(','));
+ await ev(() => window.__t.viewer.setView('iso'));
+ const corner = await ev(() => {
+ const v = window.__t.viewer, id = window.__t.parts().find((p) => p.name === 'Lid').id;
+ const f = v.facesOf(id).filter((x) => x.surface === 'PLANE').sort((a, b) => b.center[2] - a.center[2])[0];
+ return { s: v.screenOf(id, f.id), c: f.center };
+ });
+ const before = await vs();
+ await ev((p) => document.querySelector('#viewer > canvas').dispatchEvent(new MouseEvent('dblclick', { clientX: p.x, clientY: p.y, bubbles: true })), corner.s);
+ await settle();
+ const v3 = await vs();
+ check('Doppelklick ins Modell: Drehpunkt dorthin, die Ansicht verschiebt sich nur (dreht nicht)', near(v3.target, corner.c, 0.2) && near(v3.dir, before.dir, 1e-6),
+ `${v3.target.map((x) => x.toFixed(2)).join(',')} statt ${corner.c.join(',')}`);
+ check('Zoom zur Mausposition an, vordere Schnittebene folgt dem Abstand', v3.zoomToCursor && Math.abs(v3.near - v3.dist / 200) < 1e-9 && v3.far > v3.dist, `near ${v3.near.toFixed(3)}, Abstand ${v3.dist.toFixed(1)}`);
+ await ev(() => document.querySelector('#menu-display [data-view="back"]').click());
+ check('Ansicht „Hinten" im Menü Darstellung', near((await vs()).dir, [0, 1, 0]));
+ await domClick(await ev(() => { const b = document.querySelector('.vbtns [data-view="iso"]'); b.id ||= 'btn-view-iso'; return b.id; }));
+ check('Standardansicht setzt den Drehpunkt zurück in die Mitte des Modells', near((await vs()).target, v0.target, 1e-6));
+ // Zum Ansehen: Zeiger über der Ecke oben vorne rechts (Felder in Orange)
+ await ev((p) => document.querySelector('#cube-view canvas').dispatchEvent(new PointerEvent('pointermove', { clientX: p.x, clientY: p.y, bubbles: true, pointerId: 1 })),
+ await ev(() => window.__t.viewer.cubeScreen([0.85, -0.85, 1])));
+ await shot('8-ansichtswuerfel');
+ await ev(() => document.querySelector('#cube-view canvas').dispatchEvent(new PointerEvent('pointerleave', { bubbles: true })));
+
// 8) Neues Projekt: anderer Ordner, Terminals des alten sind zu, frischer erster Build
await domClick('btn-new');
await waitFor('neues Projekt', (oldId) => window.__t.project().id !== oldId && window.__t.status().state === 'ok' && window.__t.partCount() === 2, 90000, proj.id).catch(() => {});