Native wgpu-Viewports (2D+3D) im Tauri-Prozess: echtes Modell + gehrte Ecken

- native.rs: EINE winit-EventLoop hostet 2D- und 3D-Fenster (winit erlaubt nur
  eine Loop pro Prozess) — loest den RecreationAttempt-Panic zweier Loops; ersetzt
  native2d.rs/native3d.rs. Feature-gegated (native2d/native3d, einzeln oder zusammen).
- render2d/render3d laden das ECHTE Modell aus assets/native2d_scene.json bzw.
  native3d_walls.json (Demo-Szene als Fallback); initialer Ausschnitt/Kamera aus
  den Modell-Grenzen gerahmt, initialer Redraw + gesetzte Fenstergroesse.
- TS-Konverter toRenderScene/toWalls3d + scripts/dump-native-scene erzeugen die
  JSON aus sampleProject/generatePlan (npm run dump:native).
- render2d: Scene.polylines fuer zusammenhaengende Umriss-/Zeichnungslaeufe →
  Gehrung statt Stumpfkappen an Wandecken/2D-Geometrien; MITER_LIMIT 4→8
  (deckungsgleich mit SVG stroke-miterlimit:8 und WebGL2).
- native3d-Feature + render3d-Pfad-Dep in der Tauri-Crate.

package.json

@@ -11,7 +11,8 @@
     "test:watch": "vitest",
     "tauri": "tauri",
     "tauri:dev": "tauri dev",
-    "tauri:build": "tauri build"
+    "tauri:build": "tauri build",
+    "dump:native": "node scripts/dump-native-scene.mjs"
   },
   "dependencies": {
     "@mlightcad/libredwg-web": "^0.7.7",

scripts/dump-native-scene.mjs

@@ -0,0 +1,20 @@
+// Bundlet scripts/dumpNativeScene.ts mit esbuild für Node und führt es aus.
+// So läuft die echte TS-Modellpipeline (generatePlan) headless, ohne tsx.
+import esbuild from "esbuild";
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { tmpdir } from "node:os";
+
+const out = resolve(tmpdir(), `dump-native-scene.${process.pid}.mjs`);
+
+await esbuild.build({
+  entryPoints: ["scripts/dumpNativeScene.ts"],
+  bundle: true,
+  platform: "node",
+  format: "esm",
+  target: "node18",
+  outfile: out,
+  logLevel: "warning",
+});
+
+await import(pathToFileURL(out).href);

scripts/dumpNativeScene.ts

@@ -0,0 +1,36 @@
+// Erzeugt aus dem echten Modell (sampleProject → generatePlan) die JSON-Dateien,
+// die die nativen wgpu-Fenster (render2d/render3d) beim Start laden:
+//   src-tauri/assets/native2d_scene.json   (RScene: fills/outlines/lines)
+//   src-tauri/assets/native3d_walls.json    (RWall[])
+// Wird via scripts/dump-native-scene.mjs (esbuild-Bundle) unter Node ausgeführt.
+
+import { writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { sampleProject } from "../src/model/sampleProject";
+import { generatePlan } from "../src/plan/generatePlan";
+import { planToRenderScene } from "../src/plan/toRenderScene";
+import { projectToWalls3d } from "../src/plan/toWalls3d";
+
+const root = process.cwd();
+const outDir = resolve(root, "src-tauri", "assets");
+mkdirSync(outDir, { recursive: true });
+
+// 2D: Erdgeschoss-Grundriss, alle sichtbaren Kategorien, Detailgrad „mittel".
+const floorId = "eg";
+const visibleCodes = new Set(sampleProject.layers.map((l) => l.code));
+const plan = generatePlan(sampleProject, floorId, visibleCodes);
+const scene = planToRenderScene(plan);
+
+// 3D: alle Wände aller Geschosse, korrekt gestapelt.
+const walls = projectToWalls3d(sampleProject);
+
+const scenePath = resolve(outDir, "native2d_scene.json");
+const wallsPath = resolve(outDir, "native3d_walls.json");
+writeFileSync(scenePath, JSON.stringify(scene));
+writeFileSync(wallsPath, JSON.stringify(walls));
+
+console.log(
+  `native2d_scene.json: ${scene.fills.length} fills, ${scene.outlines.length} outlines, ${scene.lines.length} lines`,
+);
+console.log(`native3d_walls.json: ${walls.length} walls`);
+console.log(`→ ${outDir}`);

src-tauri/Cargo.lock

@@ -381,6 +381,7 @@ dependencies = [
  "geometry",
  "pollster",
  "render2d",
+ "render3d",
  "serde",
  "serde_json",
  "tauri",
@@ -3496,6 +3497,20 @@ dependencies = [
  "winit",
 ]
 
+[[package]]
+name = "render3d"
+version = "0.1.0"
+dependencies = [
+ "bytemuck",
+ "env_logger",
+ "naga",
+ "pollster",
+ "serde",
+ "serde_json",
+ "wgpu",
+ "winit",
+]
+
 [[package]]
 name = "renderdoc-sys"
 version = "1.1.0"

src-tauri/Cargo.toml

@@ -23,6 +23,10 @@ default = []
 # Zieht render2d(+window) sowie winit/wgpu/pollster. Bewusst OPT-IN, damit der
 # normale Build unveraendert schlank bleibt.
 native2d = ["dep:render2d", "dep:winit", "dep:wgpu", "dep:pollster"]
+# M2-Spike: nativer wgpu-3D-Viewport im Tauri-Prozess (eigenes winit-Fenster).
+# Zieht render3d(+window) sowie winit/wgpu/pollster. Kann gemeinsam mit `native2d`
+# aktiviert werden (dann zwei native Fenster). Ebenfalls OPT-IN.
+native3d = ["dep:render3d", "dep:winit", "dep:wgpu", "dep:pollster"]
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
@@ -37,6 +41,10 @@ geometry = { path = "geometry" }
 # render2d ist eine eigenstaendige Crate (eigener leerer [workspace]); wir binden
 # sie hier per Pfad ein und aktivieren ihr GPU-Fenster-Feature "window".
 render2d = { path = "render2d", features = ["window"], optional = true }
+# render3d analog: eigenstaendige Crate (via Parent-`exclude` aus dem Workspace
+# genommen, ohne eigenen [workspace]-Block); per Pfad mit GPU-Fenster-Feature
+# "window" eingebunden.
+render3d = { path = "render3d", features = ["window"], optional = true }
 # Versionen an render2d gekoppelt (identische raw-window-handle 0.6-Kette).
 winit = { version = "0.30", optional = true }
 wgpu = { version = "22", optional = true }

src-tauri/render2d/src/demo.rs

@@ -50,6 +50,7 @@ pub fn demo_scene() -> Scene {
                 width_mm: 0.18,
             },
         ],
+        polylines: vec![],
         lines: vec![Line {
             a: [0.0, -1.0],
             b: [9.0, -1.0],

src-tauri/render2d/src/tessellate.rs

@@ -16,7 +16,7 @@
 //    Schicht, die ohne Display gruen bleiben muss.
 //  - Ergebnis ist byte-fuer-byte-vergleichbar mit dem WebGL-Referenzpfad.
 
-use crate::types::{FillPolygon, Line, Point, Rgba, Scene};
+use crate::types::{FillPolygon, Line, Point, Polyline, Rgba, Scene};
 
 /// viewBox-Einheiten je Meter (identisch zu PlanView/toScreen im Web-Pfad).
 pub const PX_PER_M: f32 = 90.0;
@@ -46,7 +46,7 @@ fn cross(a: Point, b: Point, c: Point) -> f32 {
 }
 
 /// Maximaler Miter-Laengenfaktor; darueber wird geklemmt (kein Spike an spitzen Ecken).
-const MITER_LIMIT: f32 = 4.0;
+const MITER_LIMIT: f32 = 8.0;
 
 /// Einheits-Links-Normale von `from` nach `to` (Bildschirm-Raum); None bei Nulllaenge.
 #[inline]
@@ -380,7 +380,13 @@ pub fn compile_scene(scene: &Scene) -> GpuGeometry {
             geo.stroke_polyline(&o.pts, true, o.color, o.width_mm, &mut bounds);
         }
     }
-    // 3) Freie Linien.
+    // 3) Offene Polylinien (verbundene Umrisskanten / 2D-Zeichnungszuege) als EIN
+    //    gehrter Streifen — die inneren Ecken bekommen so eine Gehrung statt
+    //    Stumpfkappen (closed=false).
+    for pl in &scene.polylines {
+        compile_polyline(&mut geo, pl, &mut bounds);
+    }
+    // 4) Freie Einzel-Linien (Tuerblaetter, Bogen-Sehnen, Referenzlinien).
     for l in &scene.lines {
         compile_line(&mut geo, l, &mut bounds);
     }
@@ -389,6 +395,12 @@ pub fn compile_scene(scene: &Scene) -> GpuGeometry {
     geo
 }
 
+fn compile_polyline(geo: &mut GpuGeometry, pl: &Polyline, bounds: &mut Bounds) {
+    if pl.width_mm > 0.0 && pl.pts.len() >= 2 {
+        geo.stroke_polyline(&pl.pts, false, pl.color, pl.width_mm, bounds);
+    }
+}
+
 fn compile_fill(geo: &mut GpuGeometry, poly: &FillPolygon, bounds: &mut Bounds) {
     let tris = triangulate(&poly.pts);
     if tris.is_empty() {

src-tauri/render2d/src/types.rs

@@ -52,9 +52,25 @@ pub struct Outline {
     pub width_mm: f32,
 }
 
+/// Ein OFFENER Linienzug mit echter Papier-mm-Breite. Anders als `Outline`
+/// (geschlossener Ring) und `Line` (Einzelsegment) traegt er >=2 zusammenhaengende
+/// Punkte, deren INNERE Ecken korrekt gehrt (mitred) werden — genau das, was die
+/// nicht-unterdrueckten Umrisskanten einer Wandecke bzw. eine 2D-Zeichnungs-
+/// Polylinie brauchen (sonst Stumpfkappen statt Gehrung).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Polyline {
+    /// Zusammenhaengende Punkte in Modell-Metern (offen, nicht geschlossen).
+    pub pts: Vec<Point>,
+    /// Strichfarbe (RGBA 0..1).
+    pub color: Rgba,
+    /// Strichbreite in echten Papier-Millimetern.
+    #[serde(rename = "widthMm")]
+    pub width_mm: f32,
+}
+
 /// Die vollstaendige Szene: alles, was ein Frame zeichnet. Reihenfolge ist
 /// signifikant (Z-/Alpha-Ueberlagerung): erst Fuellungen, dann Umrisse, dann
-/// freie Linien — analog zur Draw-Reihenfolge im WebGL-Pfad.
+/// offene Polylinien, dann freie Linien — analog zur Draw-Reihenfolge im WebGL-Pfad.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct Scene {
     #[serde(default)]
@@ -62,6 +78,8 @@ pub struct Scene {
     #[serde(default)]
     pub outlines: Vec<Outline>,
     #[serde(default)]
+    pub polylines: Vec<Polyline>,
+    #[serde(default)]
     pub lines: Vec<Line>,
 }
 

src-tauri/render3d/Cargo.toml

@@ -5,10 +5,15 @@ edition = "2021"
 description = "Nativer wgpu-3D-Renderer fuer die CAD-Modellsicht (Wand-Extrusion + Kamera + Pipeline)"
 
 # Bewusst NICHT Teil des src-tauri-Workspaces: die Mesh-Bibliothek soll unabhaengig
-# von Tauri baubar/testbar bleiben (headless, ohne Webview-Toolchain). Der leere
+# von Tauri baubar/testbar bleiben (headless, ohne Webview-Toolchain). Ausschluss
-# [workspace]-Block schliesst die Crate aus einem uebergeordneten Workspace aus,
+# laeuft ueber `exclude = ["render3d"]` im uebergeordneten src-tauri/Cargo.toml.
-# sodass `cargo test`/`cargo build` hier eigenstaendig laufen (Muster: render2d).
+# Standalone (`cd render3d && cargo test/build`) bildet die Crate automatisch ihren
-[workspace]
+# eigenen Ein-Paket-Workspace (eigene Cargo.lock) — Muster: render2d.
+#
+# KEIN eigener `[workspace]`-Block hier: sobald `cad-tauri` render3d per Pfad als
+# (optionale) Abhaengigkeit einbindet (Feature `native3d`), wuerde ein zweiter
+# Workspace-Root INNERHALB des src-tauri-Baums Cargo mit "multiple workspace
+# roots" abbrechen. Der Parent-`exclude` haelt die Crate trotzdem eigenstaendig.
 
 [features]
 # Standard: nur Mesh-Erzeugung (Wand-Extrusion) + Kamera/Matrizen + WGSL-Quellen.

src-tauri/src/lib.rs

@@ -1,9 +1,10 @@
 // Tauri-v2-Einstieg. Die eigentliche Geometrie liegt im serde-only Crate
 // `geometry`; hier nur die Befehls-Bruecke und der App-Start.
 
-// M2-Spike: nativer wgpu-2D-Viewport im Tauri-Prozess (nur mit Feature `native2d`).
+// M2: native wgpu-Viewports (2D und/oder 3D) im Tauri-Prozess. EIN Modul, EINE
-#[cfg(feature = "native2d")]
+// winit-Event-Loop fuer beide Fenster (winit erlaubt nur eine Loop pro Prozess).
-mod native2d;
+#[cfg(any(feature = "native2d", feature = "native3d"))]
+mod native;
 
 /// Berechnet die Wand-Gehrungen im Rust-Kern und liefert sie ans Frontend.
 #[tauri::command]
@@ -17,10 +18,10 @@ async fn compute_joins(
 pub fn run() {
     tauri::Builder::default()
         .setup(|_app| {
-            // Nur mit Feature `native2d`: das native GPU-Fenster auf einem eigenen
+            // Native GPU-Fenster (2D und/oder 3D je nach Feature) auf einem eigenen
             // Thread hochfahren, damit der Tauri-/GTK-Hauptthread frei bleibt.
-            #[cfg(feature = "native2d")]
+            #[cfg(any(feature = "native2d", feature = "native3d"))]
-            native2d::spawn();
+            native::spawn();
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![compute_joins])

src-tauri/src/native.rs

@@ -0,0 +1,633 @@
+// M2: die nativen wgpu-Viewports (2D + 3D), gestartet AUS DEM Tauri-Prozess.
+//
+// Ziel: beweisen, dass die nativen GPU-Flaechen (render2d/render3d) im echten
+// Tauri-Prozess laufen — NICHT in der WebKitGTK-Webview (dem Perf-Flaschenhals)
+// und NICHT in einem separaten Chromium-Workaround-Fenster.
+//
+// Architektur (Ansatz B, siehe docs/welle-c-hlr-spike/m2-approach.md):
+//   - Der Tauri-Hauptthread haelt weiterhin die GTK-Hauptschleife + die Webview.
+//   - Dieses Modul oeffnet EIGENE native winit-Fenster mit eigener wgpu-Surface
+//     auf EINEM HINTERGRUND-Thread. winit spricht auf Linux direkt Wayland/X11
+//     (KEIN GTK) — die Fenster-/Surface-Ebene ist so voellig von WebKitGTK
+//     getrennt (keine Surface-Contention/Flicker).
+//   - winit erlaubt eine Event-Loop auf einem Nicht-Haupt-Thread via
+//     `EventLoopBuilderExtWayland/X11::with_any_thread(true)`.
+//
+// WICHTIG: winit erlaubt nur EINE Event-Loop pro Prozess. Darum hosten wir das
+// 2D- UND das 3D-Fenster in DERSELBEN Event-Loop (winit-Multi-Window-Muster) und
+// verteilen Events per `WindowId`. Zwei getrennte Event-Loops (je Fenster) wuerden
+// mit `RecreationAttempt` paniken.
+//
+// Die Renderer selbst werden NICHT reimplementiert: `render2d::gpu::Renderer` +
+// `render3d::gpu::Renderer` — exakt der Code der standalone-Spikes. Die echten
+// Szenen werden aus `assets/native2d_scene.json` bzw. `assets/native3d_walls.json`
+// geladen (aus dem echten Modell erzeugt); fehlen sie, greift die Demo-Szene.
+//
+// Hinter den Cargo-Features `native2d`/`native3d` — der normale Tauri-Build zieht
+// weder winit noch wgpu und bleibt unveraendert. Beide Features sind
+// gleichzeitig aktivierbar (dann oeffnen sich beide Fenster).
+
+use std::sync::Arc;
+
+use winit::application::ApplicationHandler;
+use winit::dpi::LogicalSize;
+use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::window::{Window, WindowId};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 2D
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "native2d")]
+use render2d::gpu::Renderer as Renderer2d;
+#[cfg(feature = "native2d")]
+use render2d::types::{Scene, ViewBox};
+#[cfg(feature = "native2d")]
+use render2d::{demo_scene, initial_view_box, meet_scale, PX_PER_M};
+
+#[cfg(feature = "native2d")]
+struct GpuState2d {
+    surface: wgpu::Surface<'static>,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    config: wgpu::SurfaceConfiguration,
+    renderer: Renderer2d,
+    window: Arc<Window>,
+}
+
+#[cfg(feature = "native2d")]
+impl GpuState2d {
+    fn new(window: Arc<Window>, scene: &Scene) -> Self {
+        let (surface, device, queue, config) = configure_surface(&window, "2d.device");
+        let mut renderer = Renderer2d::new(&device, config.format);
+        renderer.upload_scene(&device, scene);
+        Self { surface, device, queue, config, renderer, window }
+    }
+
+    fn resize(&mut self, w: u32, h: u32) {
+        if w == 0 || h == 0 {
+            return;
+        }
+        self.config.width = w;
+        self.config.height = h;
+        self.surface.configure(&self.device, &self.config);
+    }
+
+    fn render(&mut self, view_box: ViewBox) {
+        let frame = match self.surface.get_current_texture() {
+            Ok(f) => f,
+            Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
+                self.surface.configure(&self.device, &self.config);
+                return;
+            }
+            Err(e) => {
+                eprintln!("native2d Surface-Fehler: {e:?}");
+                return;
+            }
+        };
+        let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
+        self.renderer.render(
+            &self.device,
+            &self.queue,
+            &view,
+            view_box,
+            (self.config.width, self.config.height),
+        );
+        frame.present();
+    }
+}
+
+#[cfg(feature = "native2d")]
+const SCENE_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/native2d_scene.json");
+
+#[cfg(feature = "native2d")]
+fn load_scene() -> Scene {
+    match std::fs::read_to_string(SCENE_PATH) {
+        Ok(text) => match serde_json::from_str::<Scene>(&text) {
+            Ok(scene) => scene,
+            Err(e) => {
+                eprintln!("native2d: Szene-Parse-Fehler ({SCENE_PATH}): {e} — nutze Demo-Szene");
+                demo_scene()
+            }
+        },
+        Err(e) => {
+            eprintln!("native2d: Szene nicht ladbar ({SCENE_PATH}): {e} — nutze Demo-Szene");
+            demo_scene()
+        }
+    }
+}
+
+/// Initialer viewBox-Ausschnitt (BILDSCHIRM-Einheiten) aus den Modell-Grenzen
+/// einer Szene, mit ~1 m Rand. Bildschirm-Abbildung wie `tessellate::to_screen`:
+/// `sx = mx * PX_PER_M`, `sy = -my * PX_PER_M`. Leere Szene -> `initial_view_box`.
+#[cfg(feature = "native2d")]
+fn scene_view_box(scene: &Scene) -> ViewBox {
+    let mut min_x = f32::INFINITY;
+    let mut min_y = f32::INFINITY;
+    let mut max_x = f32::NEG_INFINITY;
+    let mut max_y = f32::NEG_INFINITY;
+    let mut acc = |p: &[f32; 2]| {
+        let sx = p[0] * PX_PER_M;
+        let sy = -p[1] * PX_PER_M;
+        min_x = min_x.min(sx);
+        min_y = min_y.min(sy);
+        max_x = max_x.max(sx);
+        max_y = max_y.max(sy);
+    };
+    for f in &scene.fills {
+        for p in &f.pts {
+            acc(p);
+        }
+    }
+    for o in &scene.outlines {
+        for p in &o.pts {
+            acc(p);
+        }
+    }
+    for l in &scene.lines {
+        acc(&l.a);
+        acc(&l.b);
+    }
+    if !(min_x.is_finite() && max_x >= min_x && max_y >= min_y) {
+        return initial_view_box();
+    }
+    let pad = 90.0_f32; // ~1 m Rand (PX_PER_M).
+    ViewBox::new(min_x - pad, min_y - pad, (max_x - min_x) + 2.0 * pad, (max_y - min_y) + 2.0 * pad)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 3D
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "native3d")]
+use render3d::gpu::Renderer as Renderer3d;
+#[cfg(feature = "native3d")]
+use render3d::math::orbit_eye;
+#[cfg(feature = "native3d")]
+use render3d::types::{Camera, Projection, WallInput};
+
+#[cfg(feature = "native3d")]
+struct GpuState3d {
+    surface: wgpu::Surface<'static>,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    config: wgpu::SurfaceConfiguration,
+    renderer: Renderer3d,
+    window: Arc<Window>,
+}
+
+#[cfg(feature = "native3d")]
+impl GpuState3d {
+    fn new(window: Arc<Window>, walls: &[WallInput]) -> Self {
+        let (surface, device, queue, config) = configure_surface(&window, "3d.device");
+        let mut renderer = Renderer3d::new(&device, config.format);
+        renderer.upload_walls(&device, walls);
+        renderer.set_light([6.0, 12.0, 4.0], 0.6);
+        Self { surface, device, queue, config, renderer, window }
+    }
+
+    fn resize(&mut self, w: u32, h: u32) {
+        if w == 0 || h == 0 {
+            return;
+        }
+        self.config.width = w;
+        self.config.height = h;
+        self.surface.configure(&self.device, &self.config);
+    }
+
+    fn render(&mut self, camera: &Camera) {
+        let frame = match self.surface.get_current_texture() {
+            Ok(f) => f,
+            Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
+                self.surface.configure(&self.device, &self.config);
+                return;
+            }
+            Err(e) => {
+                eprintln!("native3d Surface-Fehler: {e:?}");
+                return;
+            }
+        };
+        let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
+        self.renderer.render(
+            &self.device,
+            &self.queue,
+            &view,
+            camera,
+            (self.config.width, self.config.height),
+        );
+        frame.present();
+    }
+}
+
+#[cfg(feature = "native3d")]
+const WALLS_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/native3d_walls.json");
+
+#[cfg(feature = "native3d")]
+fn load_walls() -> Vec<WallInput> {
+    match std::fs::read_to_string(WALLS_PATH) {
+        Ok(text) => match serde_json::from_str::<Vec<WallInput>>(&text) {
+            Ok(walls) => walls,
+            Err(e) => {
+                eprintln!("native3d: Waende-Parse-Fehler ({WALLS_PATH}): {e} — nutze Demo-Waende");
+                demo_walls()
+            }
+        },
+        Err(e) => {
+            eprintln!("native3d: Waende nicht ladbar ({WALLS_PATH}): {e} — nutze Demo-Waende");
+            demo_walls()
+        }
+    }
+}
+
+/// Demo-Szene (verbatim aus `render3d::bin::spike3d`): rechteckiger Raum + Innenwand.
+#[cfg(feature = "native3d")]
+fn demo_walls() -> Vec<WallInput> {
+    let t = 0.2;
+    let ht = 2.6;
+    let grey = [0.82, 0.80, 0.76];
+    let mk = |a: [f32; 2], b: [f32; 2]| WallInput {
+        start: a,
+        end: b,
+        thickness: t,
+        height: ht,
+        base_elevation: 0.0,
+        color: grey,
+    };
+    vec![
+        mk([0.0, 0.0], [6.0, 0.0]),
+        mk([6.0, 0.0], [6.0, 4.0]),
+        mk([6.0, 4.0], [0.0, 4.0]),
+        mk([0.0, 4.0], [0.0, 0.0]),
+        mk([3.0, 0.0], [3.0, 2.5]),
+    ]
+}
+
+/// Blickziel (world) + sinnvoller Start-Abstand, sodass alle Waende ins Bild
+/// passen. world: `x=model.x`, `z=model.y`, `y=Hoehe` (render3d-Konvention).
+#[cfg(feature = "native3d")]
+fn frame_walls(walls: &[WallInput]) -> ([f32; 3], f32) {
+    if walls.is_empty() {
+        return ([3.0, 1.3, 2.0], 11.0);
+    }
+    let mut min = [f32::INFINITY; 3];
+    let mut max = [f32::NEG_INFINITY; 3];
+    let mut acc = |x: f32, y: f32, z: f32| {
+        min[0] = min[0].min(x);
+        min[1] = min[1].min(y);
+        min[2] = min[2].min(z);
+        max[0] = max[0].max(x);
+        max[1] = max[1].max(y);
+        max[2] = max[2].max(z);
+    };
+    for w in walls {
+        let base = w.base_elevation;
+        let top = w.base_elevation + w.height;
+        for p in [w.start, w.end] {
+            acc(p[0], base, p[1]);
+            acc(p[0], top, p[1]);
+        }
+    }
+    if !(min[0].is_finite() && max[0] >= min[0]) {
+        return ([3.0, 1.3, 2.0], 11.0);
+    }
+    let center = [
+        (min[0] + max[0]) * 0.5,
+        (min[1] + max[1]) * 0.5,
+        (min[2] + max[2]) * 0.5,
+    ];
+    let ext = [
+        (max[0] - min[0]) * 0.5,
+        (max[1] - min[1]) * 0.5,
+        (max[2] - min[2]) * 0.5,
+    ];
+    let radius = (ext[0] * ext[0] + ext[1] * ext[1] + ext[2] * ext[2]).sqrt();
+    let dist = (radius * 2.2).max(3.0);
+    (center, dist)
+}
+
+/// Orbit-Zustand: Yaw/Pitch (Radiant) + Abstand um ein festes Ziel.
+#[cfg(feature = "native3d")]
+struct Orbit {
+    yaw: f32,
+    pitch: f32,
+    dist: f32,
+    target: [f32; 3],
+}
+
+#[cfg(feature = "native3d")]
+impl Orbit {
+    fn framed(walls: &[WallInput]) -> Self {
+        let (target, dist) = frame_walls(walls);
+        Self { yaw: std::f32::consts::FRAC_PI_4, pitch: 0.5, dist, target }
+    }
+
+    fn camera(&self) -> Camera {
+        Camera {
+            eye: orbit_eye(self.target, self.yaw, self.pitch, self.dist),
+            target: self.target,
+            up: [0.0, 1.0, 0.0],
+            projection: Projection::Perspective,
+            ..Camera::default()
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Gemeinsame Surface-Konfiguration
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Baut Surface + Device + Queue + SurfaceConfiguration fuer ein winit-Fenster.
+/// Waehlt ein sRGB-Format, sonst das erste angebotene.
+#[cfg(any(feature = "native2d", feature = "native3d"))]
+fn configure_surface(
+    window: &Arc<Window>,
+    device_label: &str,
+) -> (
+    wgpu::Surface<'static>,
+    wgpu::Device,
+    wgpu::Queue,
+    wgpu::SurfaceConfiguration,
+) {
+    let size = window.inner_size();
+    let instance = wgpu::Instance::default();
+    let surface = instance.create_surface(window.clone()).expect("Surface erstellen");
+    let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+        power_preference: wgpu::PowerPreference::HighPerformance,
+        force_fallback_adapter: false,
+        compatible_surface: Some(&surface),
+    }))
+    .expect("kein passender GPU-Adapter");
+    let (device, queue) = pollster::block_on(adapter.request_device(
+        &wgpu::DeviceDescriptor {
+            label: Some(device_label),
+            required_features: wgpu::Features::empty(),
+            required_limits: wgpu::Limits::default(),
+            memory_hints: wgpu::MemoryHints::Performance,
+        },
+        None,
+    ))
+    .expect("Device anfordern");
+
+    let caps = surface.get_capabilities(&adapter);
+    let format = caps
+        .formats
+        .iter()
+        .copied()
+        .find(|f| f.is_srgb())
+        .unwrap_or(caps.formats[0]);
+    let config = wgpu::SurfaceConfiguration {
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+        format,
+        width: size.width.max(1),
+        height: size.height.max(1),
+        present_mode: caps.present_modes[0],
+        alpha_mode: caps.alpha_modes[0],
+        view_formats: vec![],
+        desired_maximum_frame_latency: 2,
+    };
+    surface.configure(&device, &config);
+    (surface, device, queue, config)
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// App: EINE Event-Loop, beide Fenster, Routing per WindowId
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[derive(Default)]
+struct App {
+    #[cfg(feature = "native2d")]
+    s2d: Option<GpuState2d>,
+    #[cfg(feature = "native2d")]
+    view_box: Option<ViewBox>,
+    #[cfg(feature = "native2d")]
+    id2d: Option<WindowId>,
+    #[cfg(feature = "native2d")]
+    drag2d: bool,
+    #[cfg(feature = "native2d")]
+    cur2d: (f64, f64),
+
+    #[cfg(feature = "native3d")]
+    s3d: Option<GpuState3d>,
+    #[cfg(feature = "native3d")]
+    orbit: Option<Orbit>,
+    #[cfg(feature = "native3d")]
+    id3d: Option<WindowId>,
+    #[cfg(feature = "native3d")]
+    drag3d: bool,
+    #[cfg(feature = "native3d")]
+    cur3d: (f64, f64),
+}
+
+impl App {
+    /// Beendet die Event-Loop, sobald KEIN natives Fenster mehr offen ist.
+    fn maybe_exit(&self, event_loop: &ActiveEventLoop) {
+        let mut any_open = false;
+        #[cfg(feature = "native2d")]
+        {
+            if self.s2d.is_some() {
+                any_open = true;
+            }
+        }
+        #[cfg(feature = "native3d")]
+        {
+            if self.s3d.is_some() {
+                any_open = true;
+            }
+        }
+        if !any_open {
+            event_loop.exit();
+        }
+    }
+
+    #[cfg(feature = "native2d")]
+    fn on_2d(&mut self, event_loop: &ActiveEventLoop, event: WindowEvent) {
+        let Some(state) = self.s2d.as_mut() else {
+            return;
+        };
+        let vb = self.view_box.get_or_insert_with(initial_view_box);
+        match event {
+            WindowEvent::CloseRequested => {
+                self.s2d = None;
+                self.id2d = None;
+                self.maybe_exit(event_loop);
+            }
+            WindowEvent::Resized(size) => {
+                state.resize(size.width, size.height);
+                state.window.request_redraw();
+            }
+            WindowEvent::MouseInput { state: s, button, .. } => {
+                if button == MouseButton::Left {
+                    self.drag2d = s == ElementState::Pressed;
+                }
+            }
+            WindowEvent::CursorMoved { position, .. } => {
+                if self.drag2d {
+                    let (vw, vh) = (state.config.width as f32, state.config.height as f32);
+                    let meet = meet_scale(*vb, vw, vh);
+                    let dx = (position.x - self.cur2d.0) as f32 / meet;
+                    let dy = (position.y - self.cur2d.1) as f32 / meet;
+                    vb.x -= dx;
+                    vb.y -= dy;
+                    state.window.request_redraw();
+                }
+                self.cur2d = (position.x, position.y);
+            }
+            WindowEvent::MouseWheel { delta, .. } => {
+                let step = match delta {
+                    MouseScrollDelta::LineDelta(_, y) => y,
+                    MouseScrollDelta::PixelDelta(p) => (p.y as f32) / 40.0,
+                };
+                let factor = if step > 0.0 { 0.9 } else { 1.0 / 0.9 };
+                let cx = vb.x + vb.w * 0.5;
+                let cy = vb.y + vb.h * 0.5;
+                vb.w *= factor;
+                vb.h *= factor;
+                vb.x = cx - vb.w * 0.5;
+                vb.y = cy - vb.h * 0.5;
+                state.window.request_redraw();
+            }
+            WindowEvent::RedrawRequested => {
+                let vb_copy = *vb;
+                state.render(vb_copy);
+            }
+            _ => {}
+        }
+    }
+
+    #[cfg(feature = "native3d")]
+    fn on_3d(&mut self, event_loop: &ActiveEventLoop, event: WindowEvent) {
+        let Some(state) = self.s3d.as_mut() else {
+            return;
+        };
+        let Some(orbit) = self.orbit.as_mut() else {
+            return;
+        };
+        match event {
+            WindowEvent::CloseRequested => {
+                self.s3d = None;
+                self.id3d = None;
+                self.maybe_exit(event_loop);
+            }
+            WindowEvent::Resized(size) => {
+                state.resize(size.width, size.height);
+                state.window.request_redraw();
+            }
+            WindowEvent::MouseInput { state: s, button, .. } => {
+                if button == MouseButton::Left {
+                    self.drag3d = s == ElementState::Pressed;
+                }
+            }
+            WindowEvent::CursorMoved { position, .. } => {
+                if self.drag3d {
+                    let dx = (position.x - self.cur3d.0) as f32;
+                    let dy = (position.y - self.cur3d.1) as f32;
+                    orbit.yaw -= dx * 0.01;
+                    orbit.pitch += dy * 0.01;
+                    let limit = std::f32::consts::FRAC_PI_2 - 0.01;
+                    orbit.pitch = orbit.pitch.clamp(-limit, limit);
+                    state.window.request_redraw();
+                }
+                self.cur3d = (position.x, position.y);
+            }
+            WindowEvent::MouseWheel { delta, .. } => {
+                let step = match delta {
+                    MouseScrollDelta::LineDelta(_, y) => y,
+                    MouseScrollDelta::PixelDelta(p) => (p.y as f32) / 40.0,
+                };
+                let factor = if step > 0.0 { 0.9 } else { 1.0 / 0.9 };
+                orbit.dist = (orbit.dist * factor).clamp(1.5, 200.0);
+                state.window.request_redraw();
+            }
+            WindowEvent::RedrawRequested => {
+                let cam = orbit.camera();
+                state.render(&cam);
+            }
+            _ => {}
+        }
+    }
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        #[cfg(feature = "native2d")]
+        if self.s2d.is_none() {
+            let attrs = Window::default_attributes()
+                .with_title("cad — nativer 2D-Viewport (wgpu, in Tauri)")
+                .with_inner_size(LogicalSize::new(1000.0, 760.0));
+            let window = Arc::new(event_loop.create_window(attrs).expect("2D-Fenster erstellen"));
+            self.id2d = Some(window.id());
+            let scene = load_scene();
+            self.view_box = Some(scene_view_box(&scene));
+            let state = GpuState2d::new(window, &scene);
+            state.window.request_redraw();
+            self.s2d = Some(state);
+        }
+
+        #[cfg(feature = "native3d")]
+        if self.s3d.is_none() {
+            let attrs = Window::default_attributes()
+                .with_title("cad — nativer 3D-Viewport (wgpu, in Tauri)")
+                .with_inner_size(LogicalSize::new(1000.0, 760.0));
+            let window = Arc::new(event_loop.create_window(attrs).expect("3D-Fenster erstellen"));
+            self.id3d = Some(window.id());
+            let walls = load_walls();
+            self.orbit = Some(Orbit::framed(&walls));
+            let state = GpuState3d::new(window, &walls);
+            state.window.request_redraw();
+            self.s3d = Some(state);
+        }
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
+        #[cfg(feature = "native2d")]
+        if self.id2d == Some(id) {
+            self.on_2d(event_loop, event);
+            return;
+        }
+        #[cfg(feature = "native3d")]
+        if self.id3d == Some(id) {
+            self.on_3d(event_loop, event);
+            return;
+        }
+        let _ = (event_loop, event);
+    }
+}
+
+/// Baut die winit-Event-Loop so, dass sie auf DIESEM (Nicht-Haupt-)Thread laufen
+/// darf. Auf Linux/Wayland via `EventLoopBuilderExtWayland::with_any_thread`, auf
+/// X11 das Pendant. Ohne diese Freigabe panict winit (Event-Loop nur Hauptthread).
+fn build_event_loop() -> EventLoop<()> {
+    use winit::event_loop::EventLoopBuilder;
+    let mut builder = EventLoopBuilder::default();
+
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        use winit::platform::wayland::EventLoopBuilderExtWayland;
+        EventLoopBuilderExtWayland::with_any_thread(&mut builder, true);
+    }
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        use winit::platform::x11::EventLoopBuilderExtX11;
+        EventLoopBuilderExtX11::with_any_thread(&mut builder, true);
+    }
+
+    builder.build().expect("Event-Loop erstellen")
+}
+
+/// Blockierender Lauf der nativen Event-Loop (fuer einen dedizierten Thread).
+fn run_blocking() {
+    let event_loop = build_event_loop();
+    event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
+    let mut app = App::default();
+    let _ = event_loop.run_app(&mut app);
+}
+
+/// Startet die nativen Fenster (2D und/oder 3D, je nach Feature) auf EINEM eigenen
+/// Thread und kehrt sofort zurueck — die Tauri-/GTK-Hauptschleife bleibt frei.
+pub fn spawn() {
+    std::thread::Builder::new()
+        .name("cad-native".into())
+        .spawn(run_blocking)
+        .expect("native-Thread starten");
+}

src-tauri/src/native2d.rs

@@ -1,259 +0,0 @@
-// M2-Spike: der native wgpu-2D-Renderer, gestartet AUS DEM Tauri-Prozess heraus.
-//
-// Ziel: beweisen, dass die native GPU-Flaeche (render2d) im echten Tauri-Prozess
-// laeuft — NICHT in der WebKitGTK-Webview (dem bekannten Perf-Flaschenhals) und
-// NICHT in einem separaten Chromium-Workaround-Fenster.
-//
-// Architektur (Ansatz B, siehe docs/welle-c-hlr-spike/m2-approach.md):
-//   - Der Tauri-Hauptthread haelt weiterhin die GTK-Hauptschleife + die
-//     Webview-Fenster (HTML-Chrome).
-//   - Dieses Modul oeffnet ein EIGENES natives winit-Fenster mit eigener
-//     wgpu-Surface auf einem HINTERGRUND-Thread. winit spricht auf Linux direkt
-//     Wayland/X11 (KEIN GTK) — dadurch ist die Fenster-/Surface-Ebene voellig
-//     getrennt von WebKitGTK. Kein geteilter Wayland-Surface => keine
-//     Surface-Contention/Flicker wie beim Unterlegen einer Roh-Surface unter die
-//     Webview.
-//   - winit erlaubt eine Event-Loop auf einem Nicht-Haupt-Thread via
-//     `EventLoopBuilderExtWayland/X11::with_any_thread(true)`.
-//
-// Der Renderer selbst wird NICHT reimplementiert: wir verwenden
-// `render2d::gpu::Renderer` + `render2d::demo_scene()` — exakt der Code, der im
-// standalone `spike`-Bin bereits als fluessig verifiziert wurde.
-//
-// Bewusst hinter dem Cargo-Feature `native2d` — der normale Tauri-Build zieht
-// weder winit noch wgpu und bleibt unveraendert.
-
-use std::sync::Arc;
-
-use render2d::gpu::Renderer;
-use render2d::types::ViewBox;
-use render2d::{demo_scene, initial_view_box, meet_scale};
-
-use winit::application::ApplicationHandler;
-use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop};
-use winit::window::{Window, WindowId};
-
-/// GPU-Zustand des nativen Fensters (Surface + Device + Renderer). 1:1 wie im
-/// standalone Spike — die Surface haengt an DIESEM winit-Fenster, nicht an der
-/// Webview.
-struct GpuState {
-    surface: wgpu::Surface<'static>,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
-    config: wgpu::SurfaceConfiguration,
-    renderer: Renderer,
-    window: Arc<Window>,
-}
-
-impl GpuState {
-    fn new(window: Arc<Window>) -> Self {
-        let size = window.inner_size();
-        let instance = wgpu::Instance::default();
-        let surface = instance
-            .create_surface(window.clone())
-            .expect("Surface erstellen");
-        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
-            power_preference: wgpu::PowerPreference::HighPerformance,
-            force_fallback_adapter: false,
-            compatible_surface: Some(&surface),
-        }))
-        .expect("kein passender GPU-Adapter");
-        let (device, queue) = pollster::block_on(adapter.request_device(
-            &wgpu::DeviceDescriptor {
-                label: Some("2d.device"),
-                required_features: wgpu::Features::empty(),
-                required_limits: wgpu::Limits::default(),
-                memory_hints: wgpu::MemoryHints::Performance,
-            },
-            None,
-        ))
-        .expect("Device anfordern");
-
-        let caps = surface.get_capabilities(&adapter);
-        let format = caps
-            .formats
-            .iter()
-            .copied()
-            .find(|f| f.is_srgb())
-            .unwrap_or(caps.formats[0]);
-        let config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format,
-            width: size.width.max(1),
-            height: size.height.max(1),
-            present_mode: caps.present_modes[0],
-            alpha_mode: caps.alpha_modes[0],
-            view_formats: vec![],
-            desired_maximum_frame_latency: 2,
-        };
-        surface.configure(&device, &config);
-
-        let mut renderer = Renderer::new(&device, format);
-        renderer.upload_scene(&device, &demo_scene());
-
-        Self {
-            surface,
-            device,
-            queue,
-            config,
-            renderer,
-            window,
-        }
-    }
-
-    fn resize(&mut self, w: u32, h: u32) {
-        if w == 0 || h == 0 {
-            return;
-        }
-        self.config.width = w;
-        self.config.height = h;
-        self.surface.configure(&self.device, &self.config);
-    }
-
-    fn render(&mut self, view_box: ViewBox) {
-        let frame = match self.surface.get_current_texture() {
-            Ok(f) => f,
-            Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
-                self.surface.configure(&self.device, &self.config);
-                return;
-            }
-            Err(e) => {
-                eprintln!("Surface-Fehler: {e:?}");
-                return;
-            }
-        };
-        let view = frame
-            .texture
-            .create_view(&wgpu::TextureViewDescriptor::default());
-        self.renderer.render(
-            &self.device,
-            &self.queue,
-            &view,
-            view_box,
-            (self.config.width, self.config.height),
-        );
-        frame.present();
-    }
-}
-
-#[derive(Default)]
-struct App {
-    state: Option<GpuState>,
-    view_box: Option<ViewBox>,
-    dragging: bool,
-    last_cursor: (f64, f64),
-}
-
-impl ApplicationHandler for App {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        if self.state.is_some() {
-            return;
-        }
-        let attrs = Window::default_attributes().with_title("cad — nativer 2D-Viewport (wgpu, in Tauri)");
-        let window = Arc::new(event_loop.create_window(attrs).expect("Fenster erstellen"));
-        self.view_box.get_or_insert_with(initial_view_box);
-        self.state = Some(GpuState::new(window));
-    }
-
-    fn window_event(
-        &mut self,
-        event_loop: &ActiveEventLoop,
-        _id: WindowId,
-        event: WindowEvent,
-    ) {
-        let Some(state) = self.state.as_mut() else {
-            return;
-        };
-        let vb = self.view_box.get_or_insert_with(initial_view_box);
-        match event {
-            // Nur DIESES Fenster schliessen — die Tauri-Webview laeuft weiter.
-            WindowEvent::CloseRequested => event_loop.exit(),
-            WindowEvent::Resized(size) => {
-                state.resize(size.width, size.height);
-                state.window.request_redraw();
-            }
-            WindowEvent::MouseInput { state: s, button, .. } => {
-                if button == MouseButton::Left {
-                    self.dragging = s == ElementState::Pressed;
-                }
-            }
-            WindowEvent::CursorMoved { position, .. } => {
-                if self.dragging {
-                    let (vw, vh) = (state.config.width as f32, state.config.height as f32);
-                    let meet = meet_scale(*vb, vw, vh);
-                    let dx = (position.x - self.last_cursor.0) as f32 / meet;
-                    let dy = (position.y - self.last_cursor.1) as f32 / meet;
-                    vb.x -= dx;
-                    vb.y -= dy;
-                    state.window.request_redraw();
-                }
-                self.last_cursor = (position.x, position.y);
-            }
-            WindowEvent::MouseWheel { delta, .. } => {
-                let step = match delta {
-                    MouseScrollDelta::LineDelta(_, y) => y,
-                    MouseScrollDelta::PixelDelta(p) => (p.y as f32) / 40.0,
-                };
-                let factor = if step > 0.0 { 0.9 } else { 1.0 / 0.9 };
-                let cx = vb.x + vb.w * 0.5;
-                let cy = vb.y + vb.h * 0.5;
-                vb.w *= factor;
-                vb.h *= factor;
-                vb.x = cx - vb.w * 0.5;
-                vb.y = cy - vb.h * 0.5;
-                state.window.request_redraw();
-            }
-            WindowEvent::RedrawRequested => {
-                let vb_copy = *vb;
-                state.render(vb_copy);
-            }
-            _ => {}
-        }
-    }
-}
-
-/// Baut die winit-Event-Loop so, dass sie auf DIESEM (Nicht-Haupt-)Thread laufen
-/// darf. Auf Linux/Wayland ist das `EventLoopBuilderExtWayland::with_any_thread`,
-/// auf X11 das X11-Pendant. Ohne diese Freigabe panict winit, weil es die
-/// Event-Loop standardmaessig nur auf dem Hauptthread zulaesst (den haelt hier
-/// aber die GTK-/Tauri-Schleife).
-fn build_event_loop() -> EventLoop<()> {
-    use winit::event_loop::EventLoopBuilder;
-    let mut builder = EventLoopBuilder::default();
-
-    #[cfg(all(unix, not(target_os = "macos")))]
-    {
-        // Wayland zuerst versuchen; faellt winit intern auf X11 zurueck, greift
-        // die X11-Freigabe. Beide Extension-Traits setzen dasselbe any-thread-Flag.
-        use winit::platform::wayland::EventLoopBuilderExtWayland;
-        EventLoopBuilderExtWayland::with_any_thread(&mut builder, true);
-    }
-    #[cfg(all(unix, not(target_os = "macos")))]
-    {
-        use winit::platform::x11::EventLoopBuilderExtX11;
-        EventLoopBuilderExtX11::with_any_thread(&mut builder, true);
-    }
-
-    builder.build().expect("Event-Loop erstellen")
-}
-
-/// Blockierender Lauf der nativen Event-Loop. Gedacht fuer einen dedizierten
-/// Thread (siehe `spawn`), NICHT fuer den Tauri-Hauptthread.
-fn run_blocking() {
-    let event_loop = build_event_loop();
-    event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
-    let mut app = App::default();
-    // `run_app` blockiert bis das native Fenster geschlossen wird.
-    let _ = event_loop.run_app(&mut app);
-}
-
-/// Startet das native 2D-Fenster auf einem eigenen Thread und kehrt sofort
-/// zurueck. So bleibt die Tauri-/GTK-Hauptschleife frei. Aufruf typischerweise
-/// aus dem Tauri-`setup`-Hook.
-pub fn spawn() {
-    std::thread::Builder::new()
-        .name("cad-native2d".into())
-        .spawn(run_blocking)
-        .expect("native2d-Thread starten");
-}

src/plan/glPlan/glPlanCompile.ts

@@ -174,8 +174,10 @@ export function compilePrimitivesToGpu(
     else lineBatches.push({ startIndex: lineIdx.length - count, indexCount: count, color, strokeMm });
   };
 
-  /** Maximaler Miter-Längenfaktor; darüber wird geklemmt (kein Spike an spitzen Ecken). */
+  /** Maximaler Miter-Längenfaktor; darüber wird geklemmt (kein Spike an spitzen Ecken).
-  const MITER_LIMIT = 4;
+   *  8 entspricht `stroke-miterlimit: 8` im SVG-Pfad (styles.css) und dem nativen
+   *  render2d (tessellate.rs) — so sehen spitze Ecken in allen drei Pfaden gleich aus. */
+  const MITER_LIMIT = 8;
 
   /**
    * Zeichnet einen zusammenhängenden Linienzug (Bildschirm-Raum) als EINEN

src/plan/toRenderScene.ts

@@ -0,0 +1,226 @@
+// Flacht einen {@link Plan} (die eine Wahrheit aus generatePlan) auf das
+// GPU-nahe Szenenformat des nativen render2d-Renderers ab: Füllpolygone,
+// Umrisse und Linien. Hatch und Text bleiben (wie im Rust-Renderer, siehe
+// render2d/src/types.rs) vorerst außen vor — sie sind Overlay/späteres M3.
+//
+// Das erzeugte Objekt matcht 1:1 die serde-Structs render2d::types::Scene
+// { fills:[{pts,color}], outlines:[{pts,color,widthMm}], lines:[{a,b,color,widthMm}] }
+// mit Point = [x,y] (Meter) und Rgba = [r,g,b,a] (0..1).
+
+import type { Plan, Primitive } from "./generatePlan";
+
+type LinePrim = Extract<Primitive, { kind: "line" }>;
+
+export type RPoint = [number, number];
+export type RRgba = [number, number, number, number];
+
+export interface RFill {
+  pts: RPoint[];
+  color: RRgba;
+}
+export interface ROutline {
+  pts: RPoint[];
+  color: RRgba;
+  widthMm: number;
+}
+export interface RPolyline {
+  pts: RPoint[];
+  color: RRgba;
+  widthMm: number;
+}
+export interface RLine {
+  a: RPoint;
+  b: RPoint;
+  color: RRgba;
+  widthMm: number;
+}
+export interface RScene {
+  fills: RFill[];
+  outlines: ROutline[];
+  polylines: RPolyline[];
+  lines: RLine[];
+}
+
+const DEFAULT_LINE = "#1a1a1a";
+
+/** Wenige benannte Farben, die in Klassen/Defaults vorkommen können. */
+const NAMED: Record<string, string> = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  none: "none",
+  transparent: "none",
+};
+
+/** Hex/Named-Farbe → [r,g,b,a] in 0..1, oder null bei "none"/leer. */
+function toRgba(input: string | undefined, alpha = 1): RRgba | null {
+  if (!input) return null;
+  let h = input.trim().toLowerCase();
+  if (h === "none" || h === "transparent") return null;
+  if (h[0] !== "#") {
+    const mapped = NAMED[h];
+    if (!mapped) return [0, 0, 0, alpha];
+    if (mapped === "none") return null;
+    h = mapped;
+  }
+  h = h.slice(1);
+  // Kurzformen auf Langform expandieren (#rgb → #rrggbb, #rgba → #rrggbbaa).
+  if (h.length === 3 || h.length === 4) h = h.split("").map((c) => c + c).join("");
+  if (h.length !== 6 && h.length !== 8) return [0, 0, 0, alpha];
+  const r = parseInt(h.slice(0, 2), 16) / 255;
+  const g = parseInt(h.slice(2, 4), 16) / 255;
+  const b = parseInt(h.slice(4, 6), 16) / 255;
+  // 8-stelliges Hex trägt den Alpha-Kanal selbst; sonst der Parameter.
+  const a = h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : alpha;
+  if (![r, g, b, a].every((v) => Number.isFinite(v))) return [0, 0, 0, alpha];
+  return [r, g, b, a];
+}
+
+/** Kreisbogen in Liniensegmente zerlegen (kürzerer Sweep, ~24 Segmente). */
+function tessellateArc(
+  center: { x: number; y: number },
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+  r: number,
+): RPoint[] {
+  const a0 = Math.atan2(from.y - center.y, from.x - center.x);
+  let a1 = Math.atan2(to.y - center.y, to.x - center.x);
+  // Kürzeren Bogen wählen (generatePlan liefert keine largeArc-Info mit).
+  let delta = a1 - a0;
+  while (delta > Math.PI) delta -= 2 * Math.PI;
+  while (delta < -Math.PI) delta += 2 * Math.PI;
+  a1 = a0 + delta;
+  const segs = Math.max(2, Math.ceil((Math.abs(delta) / (Math.PI * 2)) * 48));
+  const pts: RPoint[] = [];
+  for (let i = 0; i <= segs; i++) {
+    const t = a0 + (delta * i) / segs;
+    pts.push([center.x + Math.cos(t) * r, center.y + Math.sin(t) * r]);
+  }
+  return pts;
+}
+
+/** Zwei Modell-Punkte (Meter) als gleich behandeln (Verkettungs-Toleranz). */
+function samePt(a: RPoint, b: RPoint): boolean {
+  return Math.abs(a[0] - b[0]) < 1e-6 && Math.abs(a[1] - b[1]) < 1e-6;
+}
+
+/** Gleicher Linienstil (für das Verketten aufeinanderfolgender 2D-Zeichenlinien). */
+function sameLineStyle(a: LinePrim, b: LinePrim): boolean {
+  return (
+    a.cls === b.cls &&
+    a.weightMm === b.weightMm &&
+    (a.color ?? "") === (b.color ?? "") &&
+    JSON.stringify(a.dash ?? null) === JSON.stringify(b.dash ?? null)
+  );
+}
+
+/**
+ * Zerlegt einen Polygon-Ring in zusammenhängende Läufe SICHTBARER Kanten (die
+ * `noStroke`-Kanten werden ausgelassen). Jeder Lauf beginnt an einer sichtbaren
+ * Kante, deren Vorgänger unterdrückt ist. Portiert aus PlanView.visibleEdgeRuns —
+ * so bekommen die inneren Ecken eine Gehrung statt Stumpfkappen.
+ */
+function visibleEdgeRuns(pts: RPoint[], noStroke: number[]): RPoint[][] {
+  const n = pts.length;
+  const skip = new Set(noStroke.map((i) => ((i % n) + n) % n));
+  if (skip.size >= n || n < 2) return [];
+  const visible = (i: number) => !skip.has(((i % n) + n) % n);
+  const runs: RPoint[][] = [];
+  for (let s = 0; s < n; s++) {
+    if (!visible(s) || visible(s - 1 + n)) continue; // kein Lauf-Anfang
+    const run: RPoint[] = [pts[s]];
+    let j = s;
+    while (visible(j) && j - s < n) {
+      run.push(pts[(j + 1) % n]);
+      j++;
+    }
+    runs.push(run);
+  }
+  return runs;
+}
+
+/**
+ * Wandelt einen Plan in eine native render2d-Szene um. Zusammenhängende Umriss-
+ * und Zeichnungskanten werden zu OFFENEN Polylinien verkettet (gehrte Ecken);
+ * nur genuin einzelne Segmente (Türblätter, Referenzlinien) bleiben `lines`.
+ */
+export function planToRenderScene(plan: Plan): RScene {
+  const fills: RFill[] = [];
+  const outlines: ROutline[] = [];
+  const polylines: RPolyline[] = [];
+  const lines: RLine[] = [];
+
+  // Laufender, verketteter 2D-Zeichnungs-Zug (gleiche drawingId + Stil, End-an-Start).
+  let curPts: RPoint[] | null = null;
+  let curSrc: LinePrim | null = null;
+  const flushRun = () => {
+    if (curPts && curSrc && curPts.length >= 2) {
+      const col = toRgba(curSrc.color ?? DEFAULT_LINE, 1) ?? [0.1, 0.1, 0.1, 1];
+      const closed = curPts.length > 2 && samePt(curPts[0], curPts[curPts.length - 1]);
+      if (closed) {
+        outlines.push({ pts: curPts.slice(0, -1), color: col, widthMm: curSrc.weightMm });
+      } else {
+        polylines.push({ pts: curPts, color: col, widthMm: curSrc.weightMm });
+      }
+    }
+    curPts = null;
+    curSrc = null;
+  };
+
+  for (const p of plan.primitives) {
+    if (p.kind === "polygon") {
+      flushRun();
+      const pts: RPoint[] = p.pts.map((v) => [v.x, v.y]);
+      if (pts.length < 2) continue;
+
+      // Füllung
+      const fillCol = toRgba(p.fill, 1);
+      if (fillCol && pts.length >= 3) fills.push({ pts, color: fillCol });
+
+      // Umriss
+      const strokeCol = toRgba(p.stroke, 1);
+      if (strokeCol && p.strokeWidthMm > 0) {
+        const suppressed = p.noStrokeEdges ?? [];
+        if (suppressed.length === 0) {
+          // Ganzer Ring → geschlossener, gehrter Umriss.
+          outlines.push({ pts, color: strokeCol, widthMm: p.strokeWidthMm });
+        } else {
+          // Nur die sichtbaren Kanten, als zusammenhängende (offene) Läufe.
+          for (const run of visibleEdgeRuns(pts, suppressed)) {
+            polylines.push({ pts: run, color: strokeCol, widthMm: p.strokeWidthMm });
+          }
+        }
+      }
+    } else if (p.kind === "line") {
+      if (p.drawingId) {
+        // Aufeinanderfolgende 2D-Zeichenlinien gleicher drawingId/Stil verketten.
+        const a: RPoint = [p.a.x, p.a.y];
+        const b: RPoint = [p.b.x, p.b.y];
+        if (curPts && curSrc && sameLineStyle(curSrc, p) && samePt(curPts[curPts.length - 1], a)) {
+          curPts.push(b);
+        } else {
+          flushRun();
+          curPts = [a, b];
+          curSrc = p;
+        }
+      } else {
+        // Genuin einzelnes Segment (Türblatt, Referenzlinie, Symbol) → Stumpfkappen ok.
+        flushRun();
+        const col = toRgba(p.color ?? DEFAULT_LINE, 1) ?? [0.1, 0.1, 0.1, 1];
+        lines.push({ a: [p.a.x, p.a.y], b: [p.b.x, p.b.y], color: col, widthMm: p.weightMm });
+      }
+    } else if (p.kind === "arc") {
+      flushRun();
+      const col = toRgba(DEFAULT_LINE, 1) ?? [0.1, 0.1, 0.1, 1];
+      // Bogen als EINE zusammenhängende Polylinie (gehrte Sehnen-Ecken).
+      const poly = tessellateArc(p.center, p.from, p.to, p.r);
+      if (poly.length >= 2) polylines.push({ pts: poly, color: col, widthMm: p.weightMm });
+    } else {
+      // "text" wird bewusst übersprungen (render2d rendert keinen Text).
+      flushRun();
+    }
+  }
+  flushRun();
+
+  return { fills, outlines, polylines, lines };
+}

src/plan/toWalls3d.ts

@@ -0,0 +1,50 @@
+// Leitet aus den Wänden eines Projekts die serialisierbaren WallInput-Records
+// für den nativen render3d-Renderer ab. Matcht 1:1 render3d::types::WallInput
+// { start:[x,y], end:[x,y], thickness, height, baseElevation, color:[r,g,b] }
+// mit Modell-Metern und Y-up-Extrusion (Rust-Seite: plan liegt in XZ, +Y hoch).
+//
+// Alle Geschosse werden einbezogen und über wallVerticalExtent korrekt
+// gestapelt (EG baseElevation 0, OG 2.6 …), sodass das 3D-Fenster das ganze
+// Gebäude zeigt.
+
+import type { Project } from "../model/types";
+import { getWallType, wallTypeThickness } from "../model/types";
+import { wallVerticalExtent } from "../model/wall";
+
+export type RVec2 = [number, number];
+export type RRgb = [number, number, number];
+
+export interface RWall {
+  start: RVec2;
+  end: RVec2;
+  thickness: number;
+  height: number;
+  baseElevation: number;
+  color: RRgb;
+}
+
+/** Warmer, neutraler Wand-Grundton (wie render3d default). */
+const WALL_RGB: RRgb = [0.82, 0.8, 0.76];
+
+export function projectToWalls3d(project: Project): RWall[] {
+  const out: RWall[] = [];
+  for (const w of project.walls) {
+    let thickness = 0.2;
+    try {
+      thickness = wallTypeThickness(getWallType(project, w));
+    } catch {
+      thickness = 0.2;
+    }
+    const { zBottom, zTop } = wallVerticalExtent(project, w);
+    const height = Math.max(0.01, zTop - zBottom);
+    out.push({
+      start: [w.start.x, w.start.y],
+      end: [w.end.x, w.end.y],
+      thickness,
+      height,
+      baseElevation: zBottom,
+      color: WALL_RGB,
+    });
+  }
+  return out;
+}