From bda256d3a45f15b28b70c0064094125a40926c11 Mon Sep 17 00:00:00 2001 From: Karim Date: Thu, 2 Jul 2026 08:51:59 +0200 Subject: [PATCH] Native wgpu-Viewports (2D+3D) im Tauri-Prozess: echtes Modell + gehrte Ecken MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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 | 3 +- scripts/dump-native-scene.mjs | 20 + scripts/dumpNativeScene.ts | 36 ++ src-tauri/Cargo.lock | 15 + src-tauri/Cargo.toml | 8 + src-tauri/render2d/src/demo.rs | 1 + src-tauri/render2d/src/tessellate.rs | 18 +- src-tauri/render2d/src/types.rs | 20 +- src-tauri/render3d/Cargo.toml | 13 +- src-tauri/src/lib.rs | 13 +- src-tauri/src/native.rs | 633 +++++++++++++++++++++++++++ src-tauri/src/native2d.rs | 259 ----------- src/plan/glPlan/glPlanCompile.ts | 6 +- src/plan/toRenderScene.ts | 226 ++++++++++ src/plan/toWalls3d.ts | 50 +++ 15 files changed, 1045 insertions(+), 276 deletions(-) create mode 100644 scripts/dump-native-scene.mjs create mode 100644 scripts/dumpNativeScene.ts create mode 100644 src-tauri/src/native.rs delete mode 100644 src-tauri/src/native2d.rs create mode 100644 src/plan/toRenderScene.ts create mode 100644 src/plan/toWalls3d.ts diff --git a/package.json b/package.json index e1b9349..5227dd0 100644 --- a/package.json +++ b/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", diff --git a/scripts/dump-native-scene.mjs b/scripts/dump-native-scene.mjs new file mode 100644 index 0000000..b821a66 --- /dev/null +++ b/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); diff --git a/scripts/dumpNativeScene.ts b/scripts/dumpNativeScene.ts new file mode 100644 index 0000000..f6172b7 --- /dev/null +++ b/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}`); diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock index d6554b0..0ee2f64 100644 --- a/src-tauri/Cargo.lock +++ b/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" diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml index c31f9b4..a117b59 100644 --- a/src-tauri/Cargo.toml +++ b/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 } diff --git a/src-tauri/render2d/src/demo.rs b/src-tauri/render2d/src/demo.rs index e1a7bdf..6095750 100644 --- a/src-tauri/render2d/src/demo.rs +++ b/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], diff --git a/src-tauri/render2d/src/tessellate.rs b/src-tauri/render2d/src/tessellate.rs index 4c0812a..9e3a5d1 100644 --- a/src-tauri/render2d/src/tessellate.rs +++ b/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() { diff --git a/src-tauri/render2d/src/types.rs b/src-tauri/render2d/src/types.rs index 942640d..9ddef11 100644 --- a/src-tauri/render2d/src/types.rs +++ b/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, + /// 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, #[serde(default)] + pub polylines: Vec, + #[serde(default)] pub lines: Vec, } diff --git a/src-tauri/render3d/Cargo.toml b/src-tauri/render3d/Cargo.toml index b4fad04..9d3262f 100644 --- a/src-tauri/render3d/Cargo.toml +++ b/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 -# [workspace]-Block schliesst die Crate aus einem uebergeordneten Workspace aus, -# sodass `cargo test`/`cargo build` hier eigenstaendig laufen (Muster: render2d). -[workspace] +# von Tauri baubar/testbar bleiben (headless, ohne Webview-Toolchain). Ausschluss +# laeuft ueber `exclude = ["render3d"]` im uebergeordneten src-tauri/Cargo.toml. +# Standalone (`cd render3d && cargo test/build`) bildet die Crate automatisch ihren +# 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. diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 3ad5a9e..ed83c3f 100644 --- a/src-tauri/src/lib.rs +++ b/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`). -#[cfg(feature = "native2d")] -mod native2d; +// M2: native wgpu-Viewports (2D und/oder 3D) im Tauri-Prozess. EIN Modul, EINE +// winit-Event-Loop fuer beide Fenster (winit erlaubt nur eine Loop pro Prozess). +#[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")] - native2d::spawn(); + #[cfg(any(feature = "native2d", feature = "native3d"))] + native::spawn(); Ok(()) }) .invoke_handler(tauri::generate_handler![compute_joins]) diff --git a/src-tauri/src/native.rs b/src-tauri/src/native.rs new file mode 100644 index 0000000..79abbaa --- /dev/null +++ b/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, +} + +#[cfg(feature = "native2d")] +impl GpuState2d { + fn new(window: Arc, 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::(&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, +} + +#[cfg(feature = "native3d")] +impl GpuState3d { + fn new(window: Arc, 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 { + match std::fs::read_to_string(WALLS_PATH) { + Ok(text) => match serde_json::from_str::>(&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 { + 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, + 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, + #[cfg(feature = "native2d")] + view_box: Option, + #[cfg(feature = "native2d")] + id2d: Option, + #[cfg(feature = "native2d")] + drag2d: bool, + #[cfg(feature = "native2d")] + cur2d: (f64, f64), + + #[cfg(feature = "native3d")] + s3d: Option, + #[cfg(feature = "native3d")] + orbit: Option, + #[cfg(feature = "native3d")] + id3d: Option, + #[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"); +} diff --git a/src-tauri/src/native2d.rs b/src-tauri/src/native2d.rs deleted file mode 100644 index 809e278..0000000 --- a/src-tauri/src/native2d.rs +++ /dev/null @@ -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, -} - -impl GpuState { - fn new(window: Arc) -> 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, - view_box: Option, - 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"); -} diff --git a/src/plan/glPlan/glPlanCompile.ts b/src/plan/glPlan/glPlanCompile.ts index 822d04e..d574a34 100644 --- a/src/plan/glPlan/glPlanCompile.ts +++ b/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). */ - const MITER_LIMIT = 4; + /** Maximaler Miter-Längenfaktor; darüber wird geklemmt (kein Spike an spitzen Ecken). + * 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 diff --git a/src/plan/toRenderScene.ts b/src/plan/toRenderScene.ts new file mode 100644 index 0000000..a3bdd14 --- /dev/null +++ b/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; + +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 = { + 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 }; +} diff --git a/src/plan/toWalls3d.ts b/src/plan/toWalls3d.ts new file mode 100644 index 0000000..8cbd361 --- /dev/null +++ b/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; +}