TURBOPRIMITIVES

Live ↗ZIP (lokal ausführbar)
Beschreibung

Web-based prototype for building a shape from simple geometric primitives and cutting a negative form out of it. The shape is assembled from a base layer of primitives and a negative layer whose primitives are subtracted from the base. The subtraction is done with constructive solid geometry, and the result is shown as a single mesh. Primitives can be moved, rotated and scaled, optionally snapped to a grid and an angle step. Symmetry across the X, Y and Z axes creates mirrored copies of every primitive, and overlapping copies are skipped during the calculation. The prototype shows the base layer and the negative layer separately in an edit view and the combined result in a result view. The result can be exported as a GLB file, either with or without the cut. The prototype is meant for shape exploration, design studies and as a starting point for further tools or 3D printing.

  • Version: v1.0
  • Seven primitives: cube, sphere, cylinder, cone, pyramid, torus, capsule
  • Two layers: base and negative form
  • Boolean subtraction of the negative layer from the base layer
  • Symmetry across X, Y and Z axes with mirrored copies
  • Move, rotate and scale with optional grid and angle snap
  • Undo and redo history, copy, paste and duplicate
  • Export of the result as a GLB file
  • Tech: Three.js r160, three-mesh-bvh 0.7.6, three-bvh-csg 0.0.16, WebGL
  • Requires: WebGL-capable browser, internet connection for libraries loaded from a CDN
index.html
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>TURBOPRIMITIVES</title>
<style>
  :root{--line:#e7e7e7;--txt:#111;--mut:#9a9a9a;--hover:#f4f4f4}
  *{box-sizing:border-box}
  html,body{margin:0;height:100%;overflow:hidden;background:#2a2a2a;color:var(--txt);
    font:13px/1.4 -apple-system,BlinkMacSystemFont,"Helvetica Neue",Helvetica,Arial,sans-serif}
  #view{position:fixed;inset:0;touch-action:none}
  #panel{position:fixed;left:16px;top:16px;width:232px;max-height:calc(100vh - 32px);overflow:auto;
    background:#fff;border:1px solid var(--line);border-radius:10px;padding:16px;
    display:flex;flex-direction:column;gap:16px;box-shadow:0 2px 16px rgba(0,0,0,.18)}
  h1{margin:0;font-size:12px;font-weight:600;letter-spacing:.22em}
  h1 small{display:block;margin-top:3px;font-weight:400;letter-spacing:0;color:var(--mut);font-size:11px}
  .sec{display:flex;flex-direction:column;gap:7px}
  .lab{font-size:10px;letter-spacing:.14em;text-transform:uppercase;color:var(--mut)}
  .grid2{display:grid;grid-template-columns:1fr 1fr;gap:6px}
  .grid3{display:grid;grid-template-columns:1fr 1fr 1fr;gap:6px}
  button{font:inherit;color:var(--txt);background:#fff;border:1px solid #dcdcdc;border-radius:6px;
    padding:6px 8px;cursor:pointer;transition:background .12s,border-color .12s}
  button:hover{background:var(--hover)}
  button.on{background:#111;border-color:#111;color:#fff}
  button.primary{background:#111;border-color:#111;color:#fff;padding:9px 8px;font-weight:500}
  button.primary:hover{background:#333}
  button.link{border:none;background:none;color:var(--mut);padding:2px;text-decoration:underline;font-size:12px}
  button.link:hover{color:var(--txt);background:none}
  button:disabled{opacity:.35;cursor:default}
  .layer{display:flex;align-items:center;gap:8px}
  .layer button{flex:1;display:flex;align-items:center;gap:8px;text-align:left}
  .dot{width:11px;height:11px;border-radius:50%;border:1px solid rgba(0,0,0,.25);flex:none}
  .layer button.on .dot{border-color:rgba(255,255,255,.5)}
  label.chk{display:flex;align-items:center;gap:6px;color:#555;cursor:pointer;user-select:none}
  input[type=checkbox]{accent-color:#111;margin:0}
  .foot{font-size:11px;color:var(--mut);line-height:1.5}
  label.num{display:flex;flex-direction:column;gap:3px;font-size:11px;color:var(--mut)}
  label.num input{font:inherit;font-size:12px;color:var(--txt);border:1px solid #dcdcdc;border-radius:6px;padding:5px 7px;width:100%;outline:none}
  label.num input:focus{border-color:#111}
  #status{font-size:11px;color:#555;min-height:15px}
</style>
</head>
<body>
<div id="view"></div>

<div id="panel">
  <h1>TURBOPRIMITIVES<small>Primitives · Symmetrie · Ausstanzen</small></h1>

  <div class="sec">
    <div class="lab">Layer</div>
    <div class="layer" data-layer="base">
      <button class="on"><span class="dot" style="background:#d6d6d6"></span>Basis</button>
      <label class="chk"><input type="checkbox" checked title="sichtbar"></label>
    </div>
    <div class="layer" data-layer="neg">
      <button><span class="dot" style="background:#4d4d4d"></span>Negativform</button>
      <label class="chk"><input type="checkbox" checked title="sichtbar"></label>
    </div>
  </div>

  <div class="sec">
    <div class="lab">Primitive hinzufügen</div>
    <div class="grid2" id="prims">
      <button data-p="box">Würfel</button>
      <button data-p="sphere">Kugel</button>
      <button data-p="cylinder">Zylinder</button>
      <button data-p="cone">Kegel</button>
      <button data-p="pyramid">Pyramide</button>
      <button data-p="torus">Torus</button>
      <button data-p="capsule">Kapsel</button>
    </div>
  </div>

  <div class="sec">
    <div class="lab">Transformieren</div>
    <div class="grid3" id="modes">
      <button data-m="translate" class="on" title="W">Bewegen</button>
      <button data-m="rotate" title="E">Drehen</button>
      <button data-m="scale" title="R">Skalieren</button>
    </div>
    <label class="chk"><input type="checkbox" id="snap">Raster-Snap</label>
    <div class="grid2">
      <label class="num">Raster<input type="number" id="gstep" value="0.25" min="0.01" step="0.05"></label>
      <label class="num">Winkel °<input type="number" id="rstep" value="15" min="1" step="5"></label>
    </div>
  </div>

  <div class="sec">
    <div class="lab">Symmetrie</div>
    <div class="grid3" id="sym">
      <button data-a="x">X</button>
      <button data-a="y">Y</button>
      <button data-a="z">Z</button>
    </div>
  </div>

  <div class="sec">
    <div class="lab">Auswahl</div>
    <div class="grid2">
      <button id="dup" disabled>Duplizieren</button>
      <button id="del" disabled>Löschen</button>
    </div>
    <button id="swap" disabled>Layer wechseln</button>
  </div>

  <div class="sec">
    <div class="lab">Ansicht</div>
    <div class="grid2" id="views">
      <button data-v="edit" class="on">Bearbeiten</button>
      <button data-v="result">Ergebnis</button>
    </div>
  </div>

  <div class="sec">
    <button class="primary" id="exp">Export .glb</button>
    <button class="link" id="expBase">nur Basis, ohne Ausstanzung</button>
    <div id="status"></div>
  </div>

  <div class="foot">W E R Modus · Entf löschen · ⌘/Ctrl C / V kopieren · ⌘/Ctrl D duplizieren · ⌘/Ctrl Z zurück · V Ansicht · 1 / 2 Layer</div>
</div>

<script type="importmap">
{"imports":{
  "three":"https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js",
  "three/addons/":"https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/",
  "three-mesh-bvh":"https://cdn.jsdelivr.net/npm/three-mesh-bvh@0.7.6/build/index.module.js",
  "three-bvh-csg":"https://cdn.jsdelivr.net/npm/three-bvh-csg@0.0.16/build/index.module.js"
}}
</script>
<script type="module">
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
import { TransformControls } from 'three/addons/controls/TransformControls.js';
import { GLTFExporter } from 'three/addons/exporters/GLTFExporter.js';
import { Brush, Evaluator, ADDITION, SUBTRACTION } from 'three-bvh-csg';

/* ---------- Szene ---------- */
const host = document.getElementById('view');
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.setSize(innerWidth, innerHeight);
host.appendChild(renderer.domElement);
const dom = renderer.domElement;

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x2a2a2a);

const camera = new THREE.PerspectiveCamera(45, innerWidth / innerHeight, 0.05, 500);
camera.position.set(5, 4, 7);

scene.add(new THREE.HemisphereLight(0xffffff, 0x555555, 1.1));
const key = new THREE.DirectionalLight(0xffffff, 2.2); key.position.set(5, 8, 6); scene.add(key);
const fill = new THREE.DirectionalLight(0xffffff, 0.8); fill.position.set(-6, 3, -5); scene.add(fill);

let grid = new THREE.GridHelper(12, 24, 0x5a5a5a, 0x3a3a3a);
scene.add(grid);

const orbit = new OrbitControls(camera, dom);
orbit.enableDamping = true;
orbit.dampingFactor = 0.12;

/* Symmetrie-Ebenen (nur Anzeige) */
const planeMat = new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true, opacity: 0.05, side: THREE.DoubleSide, depthWrite: false });
const planes = {
  x: new THREE.Mesh(new THREE.PlaneGeometry(12, 12).rotateY(Math.PI / 2), planeMat),
  y: new THREE.Mesh(new THREE.PlaneGeometry(12, 12).rotateX(Math.PI / 2), planeMat),
  z: new THREE.Mesh(new THREE.PlaneGeometry(12, 12), planeMat)
};
Object.values(planes).forEach(p => { p.visible = false; p.raycast = () => {}; scene.add(p); });

/* ---------- Materialien ---------- */
const matBase = new THREE.MeshStandardMaterial({ color: 0xd6d6d6, roughness: 0.85, metalness: 0 });
const matNeg  = new THREE.MeshStandardMaterial({ color: 0x4d4d4d, roughness: 0.85, metalness: 0, transparent: true, opacity: 0.6, depthWrite: false });

/* ---------- Primitive ---------- */
const GEO = {
  box:      () => new THREE.BoxGeometry(1, 1, 1),
  sphere:   () => new THREE.SphereGeometry(0.5, 48, 32),
  cylinder: () => new THREE.CylinderGeometry(0.5, 0.5, 1, 48),
  cone:     () => new THREE.ConeGeometry(0.5, 1, 48),
  pyramid:  () => new THREE.ConeGeometry(Math.SQRT1_2, 1, 4, 1).rotateY(Math.PI / 4),
  torus:    () => new THREE.TorusGeometry(0.5, 0.18, 24, 64),
  capsule:  () => new THREE.CapsuleGeometry(0.3, 0.5, 8, 24)
};
function makeGeo(type) {
  const g = GEO[type]();
  g.deleteAttribute('uv');           // gleiche Attribute für CSG
  return g;
}

const gBase = new THREE.Group(), gNeg = new THREE.Group();
scene.add(gBase, gNeg);
const groups = { base: gBase, neg: gNeg };
const vis = { base: true, neg: true };
const items = [];

function makeMesh(type, layer) {
  const m = new THREE.Mesh(makeGeo(type), layer === 'base' ? matBase : matNeg);
  m.userData = { type, layer, mirrors: [] };
  groups[layer].add(m);
  items.push(m);
  return m;
}
function removeItem(m) {
  m.userData.mirrors.forEach(x => x.parent && x.parent.remove(x));
  m.parent && m.parent.remove(m);
  m.geometry.dispose();
  items.splice(items.indexOf(m), 1);
}

/* ---------- Symmetrie ---------- */
const sym = { x: false, y: false, z: false };
function mirrorScales() {
  const ax = [sym.x, sym.y, sym.z], res = [];
  for (let mask = 1; mask < 8; mask++) {
    let ok = true;
    for (let i = 0; i < 3; i++) if ((mask >> i & 1) && !ax[i]) ok = false;
    if (ok) res.push(new THREE.Vector3(mask & 1 ? -1 : 1, mask & 2 ? -1 : 1, mask & 4 ? -1 : 1));
  }
  return res;
}
function syncMirrors() {
  for (const m of items) { m.userData.mirrors.forEach(x => x.parent && x.parent.remove(x)); m.userData.mirrors = []; }
  const sc = mirrorScales();
  for (const m of items) for (const s of sc) {
    const g = new THREE.Mesh(m.geometry, m.material);
    g.matrixAutoUpdate = false;
    g.userData = { source: m, s };
    m.userData.mirrors.push(g);
    m.parent.add(g);
  }
}
const _S = new THREE.Matrix4();
function updateMirrorMatrices() {
  for (const m of items) {
    if (!m.userData.mirrors.length) continue;
    m.updateMatrix();
    for (const g of m.userData.mirrors) {
      const s = g.userData.s;
      g.matrix.copy(_S.makeScale(s.x, s.y, s.z)).multiply(m.matrix);
      g.matrixWorldNeedsUpdate = true;
    }
  }
}

/* ---------- Auswahl / Transform ---------- */
const tc = new TransformControls(camera, dom);
tc.setSize(0.8);
const tcHelper = tc.getHelper ? tc.getHelper() : tc;   // r160: tc ist selbst das Object3D
scene.add(tcHelper);
tc.addEventListener('dragging-changed', e => {
  orbit.enabled = !e.value;
  if (!e.value) commit();
});
const box = new THREE.BoxHelper(new THREE.Object3D(), 0xffffff);
box.visible = false;
scene.add(box);

let selected = null;
const $ = id => document.getElementById(id);
function select(m) {
  selected = m;
  if (m) {
    tc.attach(m);
    box.visible = view === 'edit';
    setLayer(m.userData.layer);
  } else {
    tc.detach();
    box.visible = false;
  }
  ['dup', 'del', 'swap'].forEach(id => $(id).disabled = !m);
}

/* ---------- Layer-UI ---------- */
let layer = 'base';
function setLayer(l) {
  layer = l;
  document.querySelectorAll('.layer').forEach(r => r.querySelector('button').classList.toggle('on', r.dataset.layer === l));
}
document.querySelectorAll('.layer').forEach(r => {
  const l = r.dataset.layer;
  r.querySelector('button').onclick = () => setLayer(l);
  r.querySelector('input').onchange = e => {
    vis[l] = e.target.checked;
    groups[l].visible = vis[l] && view === 'edit';
    if (selected && selected.userData.layer === l && !vis[l]) select(null);
  };
});

/* ---------- Hinzufügen / Löschen / Duplizieren ---------- */
document.querySelectorAll('#prims button').forEach(b => b.onclick = () => {
  ensureEdit();
  const m = makeMesh(b.dataset.p, layer);
  const o = 1.2;
  m.position.set(sym.x ? o : 0, sym.y ? o : 0, sym.z ? o : 0);
  vis[layer] || (vis[layer] = true, groups[layer].visible = true, document.querySelector(`.layer[data-layer=${layer}] input`).checked = true);
  syncMirrors(); select(m); commit();
});
$('del').onclick = deleteSelected;
$('dup').onclick = duplicateSelected;
$('swap').onclick = () => {
  if (!selected) return;
  ensureEdit();
  const m = selected, nl = m.userData.layer === 'base' ? 'neg' : 'base';
  m.userData.layer = nl;
  m.material = nl === 'base' ? matBase : matNeg;
  groups[nl].add(m);
  vis[nl] = true; groups[nl].visible = true;
  document.querySelector(`.layer[data-layer=${nl}] input`).checked = true;
  syncMirrors(); select(m); commit();
};
function deleteSelected() {
  if (!selected) return;
  const m = selected; select(null); removeItem(m); commit();
}
function duplicateSelected() {
  if (!selected) return;
  ensureEdit();
  const s = selected, m = makeMesh(s.userData.type, s.userData.layer);
  s.updateMatrix();
  m.position.copy(s.position).add(new THREE.Vector3(0.3, 0, 0));
  m.quaternion.copy(s.quaternion); m.scale.copy(s.scale);
  syncMirrors(); select(m); commit();
}

/* ---------- Modus, Snap, Symmetrie-UI ---------- */
document.querySelectorAll('#modes button').forEach(b => b.onclick = () => setMode(b.dataset.m));
function setMode(m) {
  tc.setMode(m);
  tc.setSpace(m === 'scale' ? 'local' : 'world');
  document.querySelectorAll('#modes button').forEach(x => x.classList.toggle('on', x.dataset.m === m));
}
function applySnap() {
  const on = $('snap').checked;
  const step = Math.max(0.01, parseFloat($('gstep').value) || 0.25);
  const deg = Math.max(1, parseFloat($('rstep').value) || 15);
  tc.setTranslationSnap(on ? step : null);
  tc.setRotationSnap(on ? THREE.MathUtils.degToRad(deg) : null);
  tc.setScaleSnap(on ? step : null);
  setGrid(step);
}
function setGrid(step) {
  const div = Math.min(600, Math.max(1, Math.round(12 / step)));
  scene.remove(grid); grid.geometry.dispose();
  grid = new THREE.GridHelper(div * step, div, 0x5a5a5a, 0x3a3a3a);
  scene.add(grid);
}
['snap', 'gstep', 'rstep'].forEach(id => $(id).addEventListener('input', applySnap));
$('gstep').addEventListener('change', applySnap);
$('rstep').addEventListener('change', applySnap);

/* ---------- Kopieren / Einfügen ---------- */
let clip = null, pasteN = 0;
function copySelected() {
  if (!selected) return;
  selected.updateMatrix();
  clip = { t: selected.userData.type, l: selected.userData.layer, p: selected.position.clone(), q: selected.quaternion.clone(), s: selected.scale.clone() };
  pasteN = 0;
  status('Kopiert');
}
function paste() {
  if (!clip) return;
  ensureEdit();
  pasteN++;
  const off = $('snap').checked ? Math.max(0.01, parseFloat($('gstep').value) || 0.25) : 0.3;
  const m = makeMesh(clip.t, clip.l);
  m.position.copy(clip.p).add(new THREE.Vector3(off * pasteN, 0, off * pasteN));
  m.quaternion.copy(clip.q); m.scale.copy(clip.s);
  if (!vis[clip.l]) { vis[clip.l] = true; groups[clip.l].visible = true; document.querySelector(`.layer[data-layer=${clip.l}] input`).checked = true; }
  syncMirrors(); select(m); commit();
  status('Eingefügt');
}
document.querySelectorAll('#sym button').forEach(b => b.onclick = () => {
  const a = b.dataset.a;
  sym[a] = !sym[a];
  b.classList.toggle('on', sym[a]);
  planes[a].visible = sym[a];
  syncMirrors();
  if (view === 'result') showResult();
});

/* ---------- Picking ---------- */
const ray = new THREE.Raycaster(), ndc = new THREE.Vector2();
let down = null;
dom.addEventListener('pointerdown', e => { down = tc.axis ? null : { x: e.clientX, y: e.clientY }; });
dom.addEventListener('pointerup', e => {
  if (!down || view !== 'edit') return;
  const d = Math.hypot(e.clientX - down.x, e.clientY - down.y);
  down = null;
  if (d > 4) return;
  ndc.set(e.clientX / innerWidth * 2 - 1, -(e.clientY / innerHeight) * 2 + 1);
  ray.setFromCamera(ndc, camera);
  const cands = [];
  for (const m of items) if (vis[m.userData.layer]) { cands.push(m, ...m.userData.mirrors); }
  const hit = ray.intersectObjects(cands, false)[0];
  select(hit ? (hit.object.userData.source || hit.object) : null);
});

/* ---------- Undo / Redo ---------- */
const hist = []; let hi = -1;
function snap() { return items.map(m => { m.updateMatrix(); return { t: m.userData.type, l: m.userData.layer, m: m.matrix.toArray() }; }); }
function commit() {
  hist.splice(hi + 1);
  hist.push(snap()); hi = hist.length - 1;
  if (hist.length > 100) { hist.shift(); hi--; }
  if (view === 'result') showResult();
}
function restore(s) {
  select(null);
  [...items].forEach(removeItem);
  s.forEach(o => {
    const m = makeMesh(o.t, o.l);
    m.matrix.fromArray(o.m); m.matrix.decompose(m.position, m.quaternion, m.scale);
  });
  syncMirrors();
  if (view === 'result') showResult();
}
function undo() { if (hi > 0) { hi--; restore(hist[hi]); } }
function redo() { if (hi < hist.length - 1) { hi++; restore(hist[hi]); } }

/* ---------- CSG ---------- */
function vset(geo, mat) {
  const p = geo.attributes.position, v = new THREE.Vector3(), s = new Set();
  for (let i = 0; i < p.count; i++) {
    v.fromBufferAttribute(p, i).applyMatrix4(mat);
    s.add(Math.round(v.x * 1e4) + ',' + Math.round(v.y * 1e4) + ',' + Math.round(v.z * 1e4));
  }
  return s;
}
function sameSet(a, b) { if (a.size !== b.size) return false; for (const k of a) if (!b.has(k)) return false; return true; }

function bake(geo, mat) {
  const g = geo.clone();
  g.applyMatrix4(mat);
  if (mat.determinant() < 0) {          // gespiegelt → Windungsrichtung drehen
    const ix = g.index;
    for (let i = 0; i < ix.count; i += 3) { const a = ix.getX(i + 1), b = ix.getX(i + 2); ix.setX(i + 1, b); ix.setX(i + 2, a); }
    ix.needsUpdate = true;
  }
  const b = new Brush(g, matBase);
  b.updateMatrixWorld(true);
  return b;
}
function collect(l) {
  const out = [], scales = mirrorScales();
  for (const m of items) {
    if (m.userData.layer !== l) continue;
    m.updateMatrix();
    const mats = [m.matrix.clone()], sets = [vset(m.geometry, m.matrix)];
    for (const s of scales) {
      const mm = new THREE.Matrix4().makeScale(s.x, s.y, s.z).multiply(m.matrix);
      const vs = vset(m.geometry, mm);
      if (sets.some(x => sameSet(x, vs))) continue;   // deckungsgleiche Spiegelung überspringen
      mats.push(mm); sets.push(vs);
    }
    for (const mm of mats) out.push(bake(m.geometry, mm));
  }
  return out;
}
function computeResult(cut) {
  const B = collect('base');
  if (!B.length) return null;
  const ev = new Evaluator();
  ev.attributes = ['position', 'normal'];
  ev.useGroups = false;
  let r = B[0];
  for (let i = 1; i < B.length; i++) r = ev.evaluate(r, B[i], ADDITION);
  if (cut) for (const n of collect('neg')) r = ev.evaluate(r, n, SUBTRACTION);
  return new THREE.Mesh(r.geometry, new THREE.MeshStandardMaterial({ color: 0xd6d6d6, roughness: 0.85, metalness: 0, name: 'hellgrau' }));
}

/* ---------- Ansicht ---------- */
let view = 'edit', resultMesh = null;
const status = t => $('status').textContent = t || '';
const tick = () => new Promise(r => setTimeout(r, 30));

function setView(v) {
  view = v;
  document.querySelectorAll('#views button').forEach(b => b.classList.toggle('on', b.dataset.v === v));
  const edit = v === 'edit';
  gBase.visible = edit && vis.base;
  gNeg.visible = edit && vis.neg;
  tcHelper.visible = edit;
  box.visible = edit && !!selected;
  if (resultMesh) { resultMesh.visible = !edit; }
  if (!edit) showResult();
}
function ensureEdit() { if (view !== 'edit') setView('edit'); }
document.querySelectorAll('#views button').forEach(b => b.onclick = () => setView(b.dataset.v));

let busy = false;
async function showResult() {
  if (busy) return;
  busy = true;
  status('Berechne …');
  await tick();
  try {
    if (resultMesh) { scene.remove(resultMesh); resultMesh.geometry.dispose(); resultMesh = null; }
    const m = computeResult(true);
    if (!m) status('Basis-Layer ist leer.');
    else { resultMesh = m; resultMesh.visible = view === 'result'; scene.add(m); status(triCount(m) + ' Dreiecke'); }
  } catch (err) { console.error(err); status('Fehler bei der Berechnung.'); }
  busy = false;
}
const triCount = m => { const g = m.geometry; return Math.round((g.index ? g.index.count : g.attributes.position.count) / 3).toLocaleString('de-DE'); };

/* ---------- Export ---------- */
const exporter = new GLTFExporter();
async function exportGLB(cut) {
  status('Berechne …');
  await tick();
  try {
    const mesh = computeResult(cut);
    if (!mesh) { status('Basis-Layer ist leer.'); return; }
    mesh.name = cut ? 'TurboPrimitives' : 'Basis';
    exporter.parse(mesh, buf => {
      const a = document.createElement('a');
      a.href = URL.createObjectURL(new Blob([buf], { type: 'model/gltf-binary' }));
      a.download = cut ? 'turboprimitives.glb' : 'basis.glb';
      a.click();
      setTimeout(() => URL.revokeObjectURL(a.href), 2000);
      status('Exportiert · ' + triCount(mesh) + ' Dreiecke');
      mesh.geometry.dispose();
    }, err => { console.error(err); status('Export fehlgeschlagen.'); }, { binary: true });
  } catch (err) { console.error(err); status('Fehler beim Export.'); }
}
$('exp').onclick = () => exportGLB(true);
$('expBase').onclick = () => exportGLB(false);

/* ---------- Tastatur ---------- */
addEventListener('keydown', e => {
  if (/INPUT|TEXTAREA|SELECT/.test(e.target.tagName)) return;
  const mod = e.metaKey || e.ctrlKey, k = e.key.toLowerCase();
  if (mod && k === 'z') { e.preventDefault(); e.shiftKey ? redo() : undo(); return; }
  if (mod && k === 'y') { e.preventDefault(); redo(); return; }
  if (mod && k === 'd') { e.preventDefault(); duplicateSelected(); return; }
  if (mod && k === 'c') { e.preventDefault(); copySelected(); return; }
  if (mod && k === 'v') { e.preventDefault(); paste(); return; }
  if (mod) return;
  if (k === 'w') setMode('translate');
  else if (k === 'e') setMode('rotate');
  else if (k === 'r') setMode('scale');
  else if (k === 'v') setView(view === 'edit' ? 'result' : 'edit');
  else if (k === '1') setLayer('base');
  else if (k === '2') setLayer('neg');
  else if (k === 'delete' || k === 'backspace') deleteSelected();
  else if (k === 'escape') select(null);
});

/* ---------- Loop ---------- */
addEventListener('resize', () => {
  renderer.setSize(innerWidth, innerHeight);
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
});
function loop() {
  requestAnimationFrame(loop);
  orbit.update();
  updateMirrorMatrices();
  if (selected && view === 'edit') box.setFromObject(selected);
  renderer.render(scene, camera);
}
applySnap();
commit();
loop();
</script>
</body>
</html>