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.
This commit is contained in:
+2
-1
@@ -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",
|
||||
|
||||
@@ -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);
|
||||
@@ -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}`);
|
||||
Generated
+15
@@ -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"
|
||||
|
||||
@@ -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 }
|
||||
|
||||
@@ -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],
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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>,
|
||||
}
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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])
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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 };
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
Reference in New Issue
Block a user