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

10.1 KB
Raw Blame
import * as THREE from 'three';

/** Was der Würfel vom Viewer braucht. */
export interface CubeHost {
  /** Die gerade benutzte Kamera des Viewers (perspektivisch oder orthografisch, E81). */
  camera(): THREE.Camera;
  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: 'TOP', bg: '#2b3139' },
  { n: [0, 0, -1], up: [0, -1, 0], text: 'BOTTOM', bg: '#2b3139' },
  { n: [0, -1, 0], up: [0, 0, 1], text: 'FRONT', bg: '#262b33' },
  { n: [0, 1, 0], up: [0, 0, 1], text: 'BACK', bg: '#262b33' },
  { n: [1, 0, 0], up: [0, 0, 1], text: 'RIGHT', bg: '#20252c' },
  { n: [-1, 0, 0], up: [0, 0, 1], text: 'LEFT', 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 ? 'top' : s[2] < 0 ? 'bottom' : '', s[1] < 0 ? 'front' : s[1] > 0 ? 'back' : '', s[0] > 0 ? 'right' : s[0] < 0 ? 'left' : ''].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 cam = this.host.camera();
    const dir = cam.position.clone().sub(this.host.target());
    if (dir.lengthSq() < 1e-18) return;
    this.cam.position.copy(dir.normalize().multiplyScalar(6));
    this.cam.up.copy(cam.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)}: view from there (click). Drag to rotate.` : 'Click a face, edge or corner to view from there. Drag to rotate the view.';
    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 };
  }
}