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:
@@ -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");
|
||||
}
|
||||
Reference in New Issue
Block a user