Add native2d feature: wgpu 2D viewport window inside Tauri process

Spawns a GTK-free winit window with its own wgpu surface from Tauri's
setup hook on a background thread, sidestepping the WebKitGTK surface
contention on Wayland. Reuses render2d's renderer via a shared demo
module. Opt-in behind the native2d cargo feature; default build
unaffected.

docs/welle-c-hlr-spike/m2-approach.md

@@ -0,0 +1,90 @@
+# M2 — nativer wgpu-2D-Renderer im Tauri-Fenster: Ansatzwahl
+
+> Ziel: den bereits fluessig laufenden standalone `render2d`-Renderer aus dem
+> ECHTEN Tauri-Prozess heraus mit nativer GPU-Performance anzeigen — nicht in der
+> WebKitGTK-Webview (Perf-Flaschenhals), nicht in einem Chromium-Workaround.
+> Maschine: Linux, Wayland, AMD.
+
+## Gewaehlter Ansatz: **B — separates natives Fenster (winit) im Tauri-Prozess**
+
+Der Tauri-Hauptthread haelt weiterhin die GTK-Hauptschleife + das Webview-Fenster
+(HTML-Chrome). Aus dem Tauri-`setup`-Hook startet der Prozess auf einem
+Hintergrund-Thread ein **eigenes natives winit-Fenster** mit eigener wgpu-Surface,
+das die `render2d`-Demo-Szene (konkaves L + Raum + Papier-mm-Linien) rendert,
+pan-/zoombar. Renderer/Szene werden NICHT reimplementiert — es ist exakt der Code
+des verifizierten standalone `spike`-Bins (`render2d::gpu::Renderer` +
+`render2d::demo_scene`).
+
+### Warum B (und was gegen A/C spricht)
+
+- **Kein geteilter Wayland-Surface → keine Contention/Flicker.** winit spricht auf
+  Linux DIREKT Wayland/X11 (Crates `wayland-client`/`x11rb`), es benutzt **kein
+  GTK**. Das native Fenster bekommt eine eigene, von WebKitGTK voellig getrennte
+  Wayland-Surface. Genau das umgeht das dokumentierte Problem aus der Vorrecherche
+  (Roh-wgpu-Surface UNTER der Webview im selben Fenster → Flicker/Schwarzbild auf
+  Wayland).
+- **Zwei Fenster-Stacks, aber KEIN Event-Loop-Konflikt.** tao (Tauri) fuehrt eine
+  GTK-Hauptschleife auf dem Hauptthread; winit fuehrt eine eigene Schleife.
+  winit 0.30 erlaubt die Event-Loop explizit auf einem Nicht-Haupt-Thread via
+  `EventLoopBuilderExtWayland::with_any_thread(true)` (X11-Pendant analog). Der
+  native Renderer laeuft daher auf `std::thread` „cad-native2d", der Tauri-/GTK-
+  Hauptthread bleibt frei. Da winit nicht an GTK gebunden ist, kollidieren die
+  beiden Schleifen nicht (getrennte Stacks, getrennte fds).
+
+- **Ansatz A (wgpu-Surface im SELBEN Tauri-Fenster, Unter-/Overlay):** verworfen.
+  taos `raw_window_handle_rwh_06()` liefert auf Wayland den `WaylandWindowHandle`
+  der GTK-`ApplicationWindow` — also DIESELBE Surface, in die WebKitGTK
+  komponiert. Eine zweite wgpu-Surface darauf ist genau die Contention, die die
+  Vorrecherche als flackernd/schwarz auf diesem Setup markiert hat. Hoechstes
+  Wayland-Risiko, fuer den Spike ungeeignet.
+- **Ansatz C (wgpu als Haupt-Surface, HTML nur duennes Overlay):** verworfen fuer
+  den Spike. Sauberste Perf-Story, aber groesster Umbau: die ganze App muesste auf
+  eine winit/tao-getriebene Haupt-Schleife umziehen und die Tauri-Webview zur
+  Nebenrolle degradiert werden. Kein „minimaler realer Spike" mehr. Bleibt die
+  Ziel-Endarchitektur-Option, aber nach B.
+
+## Crates / Versionen (verifiziert aus der Lock-Datei)
+
+| Rolle | Crate | Version |
+|---|---|---|
+| Tauri | `tauri` / `tauri-runtime-wry` | 2.11.5 / 2.11.4 |
+| Fenster (Webview-Seite) | `tao` | 0.35.3 |
+| Webview | `wry` | 0.55.1 |
+| Natives Renderfenster | `winit` | 0.30.13 |
+| GPU | `wgpu` / `wgpu-hal` | 22.1.0 / 22.0.0 |
+| Handle-Bruecke | `raw-window-handle` | **0.6.2 (identisch fuer tao UND wgpu/winit)** |
+| Renderer | `render2d` (Pfad) | 0.1.0, Feature `window` |
+
+Der entscheidende Kompatibilitaets-Glueckstreffer: tao 0.35 und wgpu 22/winit 0.30
+teilen sich `raw-window-handle 0.6.2` — keine rwh-Versionsbruecke noetig. (Fuer
+Ansatz B wird der tao-Handle gar nicht gebraucht, weil das native Fenster eine
+eigene winit-Surface hat; die Versions-Parität ist aber die Voraussetzung fuer ein
+spaeteres A/Compositing, falls je gewuenscht.)
+
+## Wayland-Caveats (fuer den Start auf dieser Maschine)
+
+- **`WEBKIT_DISABLE_DMABUF_RENDERER=1`** bleibt fuer die Webview-Sichtbarkeit auf
+  diesem Wayland/AMD-Setup noetig (Vorrecherche). Betrifft die WebKitGTK-Seite,
+  nicht das wgpu-Fenster.
+- Das native winit-Fenster laeuft ueber Vulkan; GLES/EGL-Fallback wurde standalone
+  ebenfalls funktionierend gesehen. `WGPU_BACKEND=gl` erzwingt bei Vulkan-Zicken
+  den GL-Pfad.
+- `with_any_thread(true)` ist zwingend — ohne die Freigabe panict winit, weil es
+  die Event-Loop sonst nur auf dem Hauptthread zulaesst (den haelt hier GTK).
+
+## Bau-Isolierung
+
+Alles hinter Cargo-Feature **`native2d`** in `cad-tauri` (opt-in). Der normale
+Build (`cargo build`, `npm run tauri:dev`) zieht weder winit noch wgpu und bleibt
+unveraendert. `render2d` bleibt ohne Tauri-/GTK-Abhaengigkeiten headless baubar
+und testbar.
+
+## Naechster Schritt Richtung Vollbild-App (2D-Viewport + HTML-Chrome)
+
+1. Szene aus dem echten Modell speisen: `Plan.primitives` (TS) → serde-`Scene` →
+   ueber einen Tauri-`emit`/Command an den native2d-Thread (statt `demo_scene`).
+2. Pan/Zoom-State zwischen Webview-Chrome und native2d-Fenster synchronisieren
+   (Tauri-Events beidseitig).
+3. Fenster-Kopplung: das native Fenster als Kind/als angedockten Bereich neben der
+   Webview positionieren (Layout), spaeter ggf. Umstieg auf Ansatz C, wenn ein
+   einziges Fenster gefordert ist.

src-tauri/Cargo.toml

@@ -1,5 +1,10 @@
 [workspace]
 members = [".", "geometry"]
+# render2d/render3d sind eigenstaendige Crates (jeweils eigener [workspace]), damit
+# sie headless ohne Tauri-Toolchain baubar/testbar bleiben. Sie liegen zwar im
+# src-tauri-Baum, gehoeren aber NICHT zum cad-tauri-Workspace — hier ausschliessen,
+# damit `cad-tauri` sie dennoch per Pfad als (optionale) Abhaengigkeit nutzen kann.
+exclude = ["render2d", "render3d"]
 
 [package]
 name = "cad-tauri"
@@ -11,6 +16,14 @@ edition = "2021"
 name = "cad_tauri_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
+[features]
+# Standard: reine Tauri-App (Webview + invoke). KEIN wgpu/winit.
+default = []
+# M2-Spike: nativer wgpu-2D-Viewport im Tauri-Prozess (eigenes winit-Fenster).
+# 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"]
+
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
 
@@ -19,3 +32,12 @@ tauri = { version = "2", features = [] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 geometry = { path = "geometry" }
+
+# --- M2-Spike (nur mit Feature "native2d") -----------------------------------
+# 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 }
+# Versionen an render2d gekoppelt (identische raw-window-handle 0.6-Kette).
+winit = { version = "0.30", optional = true }
+wgpu = { version = "22", optional = true }
+pollster = { version = "0.3", optional = true }

src-tauri/render2d/Cargo.toml

@@ -6,9 +6,14 @@ description = "Nativer wgpu-2D-Renderer fuer den CAD-Grundriss (Tessellierung +
 
 # Bewusst NICHT Teil des src-tauri-Workspaces: die Tessellierungs-Bibliothek soll
 # unabhaengig von Tauri baubar/testbar bleiben (headless, ohne Webview-Toolchain).
-# Der leere [workspace]-Block schliesst die Crate aus einem uebergeordneten
+# Ausschluss laeuft ueber `exclude = ["render2d"]` im uebergeordneten
-# Workspace aus, sodass `cargo test`/`cargo build` hier eigenstaendig laufen.
+# src-tauri/Cargo.toml. Standalone (`cd render2d && cargo test/build`) bildet die
-[workspace]
+# Crate automatisch ihren eigenen Ein-Paket-Workspace (eigene Cargo.lock).
+#
+# KEIN eigener `[workspace]`-Block hier: sobald `cad-tauri` render2d per Pfad als
+# (optionale) Abhaengigkeit einbindet (Feature `native2d`), 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 die reine Tessellierung + Szene + Ortho-Matrix + WGSL-Quellen.

src-tauri/render2d/src/bin/spike.rs

@@ -13,78 +13,14 @@
 use std::sync::Arc;
 
 use render2d::gpu::Renderer;
-use render2d::types::{FillPolygon, Line, Outline, Scene, ViewBox};
+use render2d::types::ViewBox;
-use render2d::PX_PER_M;
+use render2d::{demo_scene, initial_view_box};
 
 use winit::application::ApplicationHandler;
 use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::window::{Window, WindowId};
 
-/// Demo-Szene in Modell-Metern: ein L-foermiger Wand-Poche (konkav!), ein Raum
-/// und ein paar Striche — genug, um Fuellung, Umriss und Papier-mm-Linien zu sehen.
-fn demo_scene() -> Scene {
-    let wall_grey: [f32; 4] = [0.55, 0.55, 0.55, 1.0];
-    let room_blue: [f32; 4] = [0.20, 0.45, 0.85, 0.18];
-    let ink: [f32; 4] = [0.10, 0.10, 0.10, 1.0];
-
-    // Konkaves L (Wandflaeche).
-    let l = vec![
-        [0.0, 0.0],
-        [4.0, 0.0],
-        [4.0, 2.0],
-        [2.0, 2.0],
-        [2.0, 4.0],
-        [0.0, 4.0],
-    ];
-    // Ein transluzenter Raum daneben.
-    let room = vec![[5.0, 0.0], [9.0, 0.0], [9.0, 4.0], [5.0, 4.0]];
-
-    Scene {
-        fills: vec![
-            FillPolygon {
-                pts: l.clone(),
-                color: wall_grey,
-            },
-            FillPolygon {
-                pts: room.clone(),
-                color: room_blue,
-            },
-        ],
-        outlines: vec![
-            Outline {
-                pts: l,
-                color: ink,
-                width_mm: 0.35,
-            },
-            Outline {
-                pts: room,
-                color: ink,
-                width_mm: 0.18,
-            },
-        ],
-        lines: vec![Line {
-            a: [0.0, -1.0],
-            b: [9.0, -1.0],
-            color: ink,
-            width_mm: 0.25,
-        }],
-    }
-}
-
-/// viewBox so, dass die Szene mittig einpasst (Bildschirm-Raum = Meter*PX_PER_M).
-fn initial_view_box() -> ViewBox {
-    // Szene ~ x[0..9], y[-1..4] in Meter -> Bildschirm x[0..810], y[-360..90].
-    // Etwas Rand drumherum.
-    let pad = 90.0;
-    ViewBox::new(
-        -pad,
-        -4.0 * PX_PER_M - pad,
-        9.0 * PX_PER_M + 2.0 * pad,
-        5.0 * PX_PER_M + 2.0 * pad,
-    )
-}
-
 struct GpuState {
     surface: wgpu::Surface<'static>,
     device: wgpu::Device,

src-tauri/render2d/src/demo.rs

@@ -0,0 +1,73 @@
+// Geteilte Demo-Szene fuer die Fenster-Spikes (standalone winit-Bin UND der
+// In-Tauri-Spike). EINE Quelle der Wahrheit, damit beide exakt dasselbe zeichnen
+// und der Renderer/die Szene NICHT dupliziert wird.
+//
+// serde-only + GPU-frei: baut im Standard-Feature mit (kein `render`/`window`
+// noetig), damit die Szene auch headless testbar bleibt.
+
+use crate::tessellate::PX_PER_M;
+use crate::types::{FillPolygon, Line, Outline, Scene, ViewBox};
+
+/// Demo-Szene in Modell-Metern: ein L-foermiger Wand-Poche (konkav!), ein Raum
+/// und ein paar Striche — genug, um Fuellung, Umriss und Papier-mm-Linien zu sehen.
+pub fn demo_scene() -> Scene {
+    let wall_grey: [f32; 4] = [0.55, 0.55, 0.55, 1.0];
+    let room_blue: [f32; 4] = [0.20, 0.45, 0.85, 0.18];
+    let ink: [f32; 4] = [0.10, 0.10, 0.10, 1.0];
+
+    // Konkaves L (Wandflaeche).
+    let l = vec![
+        [0.0, 0.0],
+        [4.0, 0.0],
+        [4.0, 2.0],
+        [2.0, 2.0],
+        [2.0, 4.0],
+        [0.0, 4.0],
+    ];
+    // Ein transluzenter Raum daneben.
+    let room = vec![[5.0, 0.0], [9.0, 0.0], [9.0, 4.0], [5.0, 4.0]];
+
+    Scene {
+        fills: vec![
+            FillPolygon {
+                pts: l.clone(),
+                color: wall_grey,
+            },
+            FillPolygon {
+                pts: room.clone(),
+                color: room_blue,
+            },
+        ],
+        outlines: vec![
+            Outline {
+                pts: l,
+                color: ink,
+                width_mm: 0.35,
+            },
+            Outline {
+                pts: room,
+                color: ink,
+                width_mm: 0.18,
+            },
+        ],
+        lines: vec![Line {
+            a: [0.0, -1.0],
+            b: [9.0, -1.0],
+            color: ink,
+            width_mm: 0.25,
+        }],
+    }
+}
+
+/// viewBox so, dass die Szene mittig einpasst (Bildschirm-Raum = Meter*PX_PER_M).
+pub fn initial_view_box() -> ViewBox {
+    // Szene ~ x[0..9], y[-1..4] in Meter -> Bildschirm x[0..810], y[-360..90].
+    // Etwas Rand drumherum.
+    let pad = 90.0;
+    ViewBox::new(
+        -pad,
+        -4.0 * PX_PER_M - pad,
+        9.0 * PX_PER_M + 2.0 * pad,
+        5.0 * PX_PER_M + 2.0 * pad,
+    )
+}

src-tauri/render2d/src/lib.rs

@@ -12,6 +12,7 @@
 // Standard-Build (`cargo test`/`cargo build` ohne Features) enthaelt nur die
 // GPU-freien Schichten und ist damit unabhaengig von einer Display-Session.
 
+pub mod demo;
 pub mod ortho;
 pub mod shaders;
 pub mod tessellate;
@@ -20,6 +21,7 @@ pub mod types;
 #[cfg(feature = "render")]
 pub mod gpu;
 
+pub use demo::{demo_scene, initial_view_box};
 pub use ortho::{compute_ortho_matrix, meet_scale, mm_to_device_px, Mat4};
 pub use tessellate::{compile_scene, triangulate, GpuGeometry, PX_PER_M};
 pub use types::{FillPolygon, Line, Outline, Point, Rgba, Scene, ViewBox};

src-tauri/src/lib.rs

@@ -1,6 +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`).
+#[cfg(feature = "native2d")]
+mod native2d;
+
 /// Berechnet die Wand-Gehrungen im Rust-Kern und liefert sie ans Frontend.
 #[tauri::command]
 async fn compute_joins(
@@ -12,6 +16,13 @@ async fn compute_joins(
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
+        .setup(|_app| {
+            // Nur mit Feature `native2d`: das native GPU-Fenster auf einem eigenen
+            // Thread hochfahren, damit der Tauri-/GTK-Hauptthread frei bleibt.
+            #[cfg(feature = "native2d")]
+            native2d::spawn();
+            Ok(())
+        })
         .invoke_handler(tauri::generate_handler![compute_joins])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/native2d.rs

@@ -0,0 +1,259 @@
+// 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");
+}