@rslsp1/fa-app-tools 10.1.3 → 10.3.3

package/dist/chunk-GKLCL2VQ.mjs

@@ -0,0 +1,311 @@
+// src/lib/szenen/cameraContract.ts
+var CAMERA_ASPECT_RATIOS = ["1:1", "4:3", "3:4", "16:9", "9:16"];
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+function cameraAspectRatioValue(aspectRatio) {
+  if (!/^[1-9][0-9]*(\.[0-9]+)?:[1-9][0-9]*(\.[0-9]+)?$/.test(aspectRatio)) {
+    throw new Error(`Ung\xFCltiges Kamera-Seitenverh\xE4ltnis \u201E${aspectRatio}\u201C.`);
+  }
+  const [width, height] = aspectRatio.split(":").map(Number);
+  const ratio = width / height;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(ratio) || ratio <= 0) {
+    throw new Error(`Kamera-Seitenverh\xE4ltnis \u201E${aspectRatio}\u201C ist nicht darstellbar.`);
+  }
+  return ratio;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  const record = object(value);
+  if (record) return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "undefined";
+}
+function camerasOf(payload) {
+  const cameras = object(object(payload)?.camera_rig)?.cameras;
+  return Array.isArray(cameras) ? cameras : [];
+}
+function checkCameraAspectRatioChanges(type, payload, previousPayloads = []) {
+  if (type !== "scene_setup") return [];
+  const previous = previousPayloads.flatMap(camerasOf);
+  return camerasOf(payload).flatMap((value, index) => {
+    const camera = object(value);
+    if (!camera) return [];
+    if (typeof camera.aspect_ratio === "string") {
+      try {
+        cameraAspectRatioValue(camera.aspect_ratio);
+        return [];
+      } catch (error) {
+        return [{ instancePath: `/camera_rig/cameras/${index}/aspect_ratio`, keyword: "aspect_ratio", message: error.message }];
+      }
+    }
+    if (camera.aspect_ratio === void 0 && previous.some((old) => canonical(old) === canonical(camera))) return [];
+    return [{
+      instancePath: `/camera_rig/cameras/${index}/aspect_ratio`,
+      keyword: "required",
+      message: `Kamera \u201E${String(camera.camera_id ?? index)}\u201C wurde neu angelegt oder ge\xE4ndert. Bitte ihr Seitenverh\xE4ltnis ausdr\xFCcklich speichern.`
+    }];
+  });
+}
+function cameraPerspective(camera) {
+  if (!camera.aspect_ratio) throw new Error(`Kamera \u201E${camera.camera_id}\u201C hat kein gespeichertes Seitenverh\xE4ltnis.`);
+  const lens = object(object(camera.preset)?.lens);
+  const focal = lens?.focal_length_mm;
+  const sensor = lens?.sensor_width_mm;
+  if (typeof focal !== "number" || !Number.isFinite(focal) || focal <= 0 || typeof sensor !== "number" || !Number.isFinite(sensor) || sensor <= 0) {
+    throw new Error(`Kamera \u201E${camera.camera_id}\u201C hat kein aufgel\xF6stes Objektiv mit Brennweite und Sensorbreite.`);
+  }
+  if (object(camera.preset)?.projection !== "perspective") {
+    throw new Error(`Kamera \u201E${camera.camera_id}\u201C verwendet keine perspektivische Projektion.`);
+  }
+  const aspect = cameraAspectRatioValue(camera.aspect_ratio);
+  return {
+    aspect_ratio: camera.aspect_ratio,
+    aspect,
+    focal_length_mm: focal,
+    sensor_width_mm: sensor,
+    vertical_fov_deg: 2 * Math.atan(sensor / (2 * focal * aspect)) * 180 / Math.PI
+  };
+}
+function frozenCameraAspectRatio(input) {
+  const aspect = object(object(input)?.camera)?.aspect_ratio;
+  if (aspect === void 0) return void 0;
+  if (typeof aspect !== "string") throw new Error("Das eingefrorene Kamera-Seitenverh\xE4ltnis ist kein Text.");
+  cameraAspectRatioValue(aspect);
+  return aspect;
+}
+
+// src/lib/szenen/stage3d.ts
+var STAGE_CATALOGUE = [
+  { label: "Mensch", type: "subject", dimensions: [0.55, 0.35, 1.75], primitive: "humanoid_proxy", pose_ref: "standing" },
+  { label: "Stuhl", type: "object", dimensions: [0.5, 0.5, 0.9], primitive: "furniture_proxy", variant: "chair" },
+  { label: "Tisch", type: "surface", dimensions: [1.2, 0.7, 0.75], primitive: "furniture_proxy", variant: "table" },
+  { label: "Lampe", type: "light", dimensions: [0.35, 0.35, 1.5], primitive: "furniture_proxy", variant: "floor_lamp" },
+  { label: "Raum", type: "object", dimensions: [5, 4, 2.8], primitive: "room_shell" }
+];
+var stageColor = (type) => ({ subject: "#df995f", light: "#ffe084", surface: "#65aabc", object: "#b998d9" })[type] ?? "#9bafbc";
+var PREVIEW_COLOR_PATTERN = /^#[0-9a-f]{6}$/;
+var PREVIEW_COLOR_MIN_DISTANCE = 75;
+function normalizePreviewColor(value) {
+  if (typeof value !== "string") return null;
+  const hex = value.trim().toLowerCase();
+  return PREVIEW_COLOR_PATTERN.test(hex) ? hex : null;
+}
+function rgb(hex) {
+  return [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16));
+}
+function previewColorDistance(a, b) {
+  const [r1, g1, b1] = rgb(a), [r2, g2, b2] = rgb(b);
+  const r = (r1 + r2) / 2, dr = r1 - r2, dg = g1 - g2, db = b1 - b2;
+  return Math.sqrt((2 + r / 256) * dr * dr + 4 * dg * dg + (2 + (255 - r) / 256) * db * db);
+}
+var HUE_NAMES = [
+  [15, "red"],
+  [40, "orange"],
+  [70, "yellow"],
+  [160, "green"],
+  [200, "cyan"],
+  [255, "blue"],
+  [290, "purple"],
+  [345, "pink"],
+  [360, "red"]
+];
+function previewColorName(hex) {
+  const [r, g, b] = rgb(hex).map((c) => c / 255);
+  const max = Math.max(r, g, b), min = Math.min(r, g, b), d = max - min;
+  if (d < 0.08) return `${max > 0.8 ? "white" : max < 0.25 ? "black" : "grey"} (${hex})`;
+  const hue = max === r ? ((g - b) / d + 6) % 6 : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+  const grad = hue * 60;
+  const l = (max + min) / 2;
+  const stufe = l < 0.3 ? "dark " : l > 0.82 ? "light " : "";
+  return `${stufe}${HUE_NAMES.find(([grenze]) => grad < grenze)[1]} (${hex})`;
+}
+function fallbackCandidate(n) {
+  const hue = (n * 137.508 + 25) % 360;
+  const channel = (k0) => {
+    const k = (k0 + hue / 30) % 12;
+    return Math.round(255 * (0.62 - 0.29 * Math.max(-1, Math.min(k - 3, 9 - k, 1)))).toString(16).padStart(2, "0");
+  };
+  return `#${channel(0)}${channel(8)}${channel(4)}`;
+}
+function stageColors(nodes) {
+  const result = /* @__PURE__ */ Object.create(null);
+  const used = [];
+  const names = { subject: "orange", light: "yellow", surface: "cyan", object: "purple" };
+  for (const node of nodes) {
+    const hex = normalizePreviewColor(node.proxy_3d?.preview_color);
+    if (hex) {
+      used.push(hex);
+      result[node.node_id] = { hex, name: previewColorName(hex), explicit: true };
+    }
+  }
+  const nah = (hex) => used.some((u) => previewColorDistance(u, hex) < PREVIEW_COLOR_MIN_DISTANCE);
+  let next = 0;
+  for (const node of [...nodes].filter((n) => !result[n.node_id]).sort((a, b) => a.node_id.localeCompare(b.node_id))) {
+    let hex = stageColor(node.type), name = names[node.type] ?? "blue grey";
+    for (let tries = 0; nah(hex) && tries < 64; tries++) {
+      hex = fallbackCandidate(next++);
+      name = previewColorName(hex);
+    }
+    used.push(hex);
+    result[node.node_id] = { hex, name, explicit: false };
+  }
+  return result;
+}
+function previewColorLegibility(hex) {
+  const [r, g, b] = rgb(hex).map((c) => c / 255);
+  const l = (Math.max(r, g, b) + Math.min(r, g, b)) / 2;
+  return l < 0.3 ? "too_dark" : l > 0.85 ? "too_light" : null;
+}
+function previewColorConflicts(nodes) {
+  const colors = stageColors(nodes);
+  const ids = Object.keys(colors).sort();
+  const out = [];
+  for (let i = 0; i < ids.length; i++) for (let j = i + 1; j < ids.length; j++) {
+    const a = colors[ids[i]].hex, b = colors[ids[j]].hex, distance = previewColorDistance(a, b);
+    if (distance < PREVIEW_COLOR_MIN_DISTANCE) out.push({ node_ids: [ids[i], ids[j]], hexes: [a, b], distance: Math.round(distance), identical: a === b });
+  }
+  return out;
+}
+function distinctPreviewColor(type, taken) {
+  const nah = (hex2) => taken.some((u) => previewColorDistance(u, hex2) < PREVIEW_COLOR_MIN_DISTANCE);
+  let hex = stageColor(type);
+  for (let n = 0; nah(hex) && n < 64; n++) hex = fallbackCandidate(n);
+  return hex;
+}
+var stageTypeLabel = (type) => ({ subject: "Person", light: "Licht", surface: "Fl\xE4che", object: "Objekt" })[type] ?? type;
+function vector3(value, label) {
+  if (!Array.isArray(value) || value.length !== 3 || value.some((n) => typeof n !== "number" || !Number.isFinite(n))) {
+    throw new Error(`${label}: drei endliche Koordinaten erforderlich.`);
+  }
+  return [...value];
+}
+function dragPosition(position, point, plane) {
+  const p = vector3(position, "Position");
+  const q = vector3(point, "Drag");
+  return plane === "top" ? [q[0], q[1], p[2]] : plane === "side" ? [q[0], p[1], q[2]] : p;
+}
+function stageNode(node) {
+  if (!node.placement) throw new Error(`\u201E${node.node_id}\u201C hat keine Weltplatzierung.`);
+  if (!node.proxy_3d) throw new Error(`\u201E${node.node_id}\u201C hat keine Proxy-Geometrie. Bitte Ma\xDFe festlegen.`);
+  const dimensions = vector3(node.proxy_3d.dimensions, `Ma\xDFe von ${node.node_id}`);
+  if (dimensions.some((d) => d <= 0)) throw new Error(`\u201E${node.node_id}\u201C braucht positive Proxy-Ma\xDFe.`);
+  return {
+    node_id: node.node_id,
+    type: node.type,
+    primitive: node.proxy_3d.primitive,
+    dimensions,
+    variant: node.proxy_3d.variant,
+    pose_ref: node.proxy_3d.pose_ref,
+    morph: node.proxy_3d.morph,
+    position: vector3(node.placement.position, `Position von ${node.node_id}`),
+    rotation: vector3(node.placement.rotation_euler_deg ?? [0, 0, 0], "Rotation"),
+    scale: vector3(node.placement.scale ?? [1, 1, 1], "Skalierung"),
+    anchors: node.anchors
+  };
+}
+function stageFrame(input) {
+  if (input.capabilities.can_place !== "yes") throw new Error("Die Szene ben\xF6tigt Meterma\xDFe und ein Scene Setup in Z-up-Koordinaten.");
+  const visible = input.scene.nodes.filter((n) => !n.hidden);
+  const colors = stageColors(visible);
+  const nodes = visible.map((n) => ({ ...stageNode(n), preview_color: { hex: colors[n.node_id].hex, name: colors[n.node_id].name } }));
+  if (!input.camera) throw new Error("Bitte eine Kamera ausw\xE4hlen.");
+  const optical = cameraPerspective(input.camera);
+  const placement = input.camera.placement;
+  if (placement?.mode !== "absolute") throw new Error("Diese Kamera verwendet eine Pattern-Platzierung. F\xFCr den MVP bitte eine explizite Weltposition speichern.");
+  const position = vector3(placement.position, "Kameraposition");
+  const orientation = input.camera.orientation;
+  if (orientation?.mode !== "explicit" && orientation?.mode !== "look_at") throw new Error("Bitte eine explizite Kameraausrichtung oder ein Blickziel festlegen.");
+  if (orientation.mode === "explicit") vector3(orientation.rotation_euler_deg, "Kameraausrichtung");
+  return { nodes, camera: { ...input.camera, ...optical, position, orientation } };
+}
+function planeAxes(plane) {
+  return plane === "top" ? [0, 1] : [0, 2];
+}
+function snapPosition(position, plane, step) {
+  const p = vector3(position, "Position");
+  for (const axis of planeAxes(plane)) p[axis] = Math.round(p[axis] / step) * step;
+  return p.map((v) => Number(v.toFixed(6)));
+}
+function nudgePosition(position, plane, right, up) {
+  const p = vector3(position, "Position");
+  const [u, v] = planeAxes(plane);
+  p[u] = Number((p[u] + right).toFixed(6));
+  p[v] = Number((p[v] + up).toFixed(6));
+  return p;
+}
+function fitPlaneView(points, plane, width, height) {
+  if (!points.length || width <= 0 || height <= 0) return { center: [0, 0], zoom: 60 };
+  const [u, v] = planeAxes(plane);
+  const us = points.map((p) => p[u]), vs = points.map((p) => p[v]);
+  const [minU, maxU, minV, maxV] = [Math.min(...us), Math.max(...us), Math.min(...vs), Math.max(...vs)];
+  const spanU = Math.max(maxU - minU, 2), spanV = Math.max(maxV - minV, 2);
+  const zoom = Math.min(width / (spanU * 1.25), height / (spanV * 1.25));
+  return { center: [(minU + maxU) / 2, (minV + maxV) / 2], zoom: clampZoom(zoom) };
+}
+var clampZoom = (zoom) => Math.min(800, Math.max(8, zoom));
+function screenToPlane(view, dx, dy) {
+  return [view.center[0] + dx / view.zoom, view.center[1] - dy / view.zoom];
+}
+function zoomPlaneView(view, factor, dx, dy) {
+  const zoom = clampZoom(view.zoom * factor);
+  const [u, v] = screenToPlane(view, dx, dy);
+  return { zoom, center: [u - dx / zoom, v + dy / zoom] };
+}
+function gridStep(zoom, minPx = 14) {
+  return [0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 25, 50].find((step) => step * zoom >= minPx) ?? 100;
+}
+function withStagePositions(input, nodes, camera) {
+  if (!nodes.size && !camera) return input;
+  const next = {
+    ...input,
+    scene: { ...input.scene, nodes: input.scene.nodes.map((n) => nodes.has(n.node_id) && n.placement ? { ...n, placement: { ...n.placement, position: nodes.get(n.node_id) } } : n) }
+  };
+  if (camera && input.camera) next.camera = { ...input.camera, placement: { ...input.camera.placement, position: camera } };
+  return next;
+}
+var roundMeters = (value) => Math.round(value * 1e3) / 1e3;
+function facingRotationZ(position, target) {
+  const dx = target[0] - position[0], dy = target[1] - position[1];
+  if (!Number.isFinite(dx) || !Number.isFinite(dy) || Math.hypot(dx, dy) < 1e-8) throw new Error("F\xFCr die Ausrichtung m\xFCssen Quelle und Ziel unterschiedliche Bodenpositionen haben.");
+  return Math.round(Math.atan2(dx, -dy) * 180 / Math.PI * 1e3) / 1e3;
+}
+var snapRotationZ = (degrees) => Math.round(degrees / 15) * 15;
+function stagePreviewResolution(aspectRatio) {
+  const [rw, rh] = aspectRatio.split(":").map(Number), scale = 768 / Math.max(rw, rh);
+  const width = Math.round(rw * scale), height = Math.round(rh * scale);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1 || Math.abs(width / height - rw / rh) > 1e-9) throw new Error("Dieses Kameraformat l\xE4sst sich mit der Preview-Aufl\xF6sung nicht exakt abbilden. Bitte ein Format-Preset w\xE4hlen.");
+  return { width, height };
+}
+
+export {
+  CAMERA_ASPECT_RATIOS,
+  cameraAspectRatioValue,
+  checkCameraAspectRatioChanges,
+  cameraPerspective,
+  frozenCameraAspectRatio,
+  STAGE_CATALOGUE,
+  stageColor,
+  PREVIEW_COLOR_MIN_DISTANCE,
+  normalizePreviewColor,
+  previewColorDistance,
+  stageColors,
+  previewColorLegibility,
+  previewColorConflicts,
+  distinctPreviewColor,
+  stageTypeLabel,
+  vector3,
+  dragPosition,
+  stageNode,
+  stageFrame,
+  planeAxes,
+  snapPosition,
+  nudgePosition,
+  fitPlaneView,
+  clampZoom,
+  screenToPlane,
+  zoomPlaneView,
+  gridStep,
+  withStagePositions,
+  roundMeters,
+  facingRotationZ,
+  snapRotationZ,
+  stagePreviewResolution
+};