Add native2d feature: wgpu 2D viewport window inside Tauri process
Spawns a GTK-free winit window with its own wgpu surface from Tauri's setup hook on a background thread, sidestepping the WebKitGTK surface contention on Wayland. Reuses render2d's renderer via a shared demo module. Opt-in behind the native2d cargo feature; default build unaffected.
This commit is contained in:
Generated
+1787
-93
File diff suppressed because it is too large
Load Diff
@@ -1,5 +1,10 @@
|
||||
[workspace]
|
||||
members = [".", "geometry"]
|
||||
# render2d/render3d sind eigenstaendige Crates (jeweils eigener [workspace]), damit
|
||||
# sie headless ohne Tauri-Toolchain baubar/testbar bleiben. Sie liegen zwar im
|
||||
# src-tauri-Baum, gehoeren aber NICHT zum cad-tauri-Workspace — hier ausschliessen,
|
||||
# damit `cad-tauri` sie dennoch per Pfad als (optionale) Abhaengigkeit nutzen kann.
|
||||
exclude = ["render2d", "render3d"]
|
||||
|
||||
[package]
|
||||
name = "cad-tauri"
|
||||
@@ -11,6 +16,14 @@ edition = "2021"
|
||||
name = "cad_tauri_lib"
|
||||
crate-type = ["staticlib", "cdylib", "rlib"]
|
||||
|
||||
[features]
|
||||
# Standard: reine Tauri-App (Webview + invoke). KEIN wgpu/winit.
|
||||
default = []
|
||||
# M2-Spike: nativer wgpu-2D-Viewport im Tauri-Prozess (eigenes winit-Fenster).
|
||||
# Zieht render2d(+window) sowie winit/wgpu/pollster. Bewusst OPT-IN, damit der
|
||||
# normale Build unveraendert schlank bleibt.
|
||||
native2d = ["dep:render2d", "dep:winit", "dep:wgpu", "dep:pollster"]
|
||||
|
||||
[build-dependencies]
|
||||
tauri-build = { version = "2", features = [] }
|
||||
|
||||
@@ -19,3 +32,12 @@ tauri = { version = "2", features = [] }
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
geometry = { path = "geometry" }
|
||||
|
||||
# --- M2-Spike (nur mit Feature "native2d") -----------------------------------
|
||||
# render2d ist eine eigenstaendige Crate (eigener leerer [workspace]); wir binden
|
||||
# sie hier per Pfad ein und aktivieren ihr GPU-Fenster-Feature "window".
|
||||
render2d = { path = "render2d", features = ["window"], optional = true }
|
||||
# Versionen an render2d gekoppelt (identische raw-window-handle 0.6-Kette).
|
||||
winit = { version = "0.30", optional = true }
|
||||
wgpu = { version = "22", optional = true }
|
||||
pollster = { version = "0.3", optional = true }
|
||||
|
||||
@@ -6,9 +6,14 @@ description = "Nativer wgpu-2D-Renderer fuer den CAD-Grundriss (Tessellierung +
|
||||
|
||||
# Bewusst NICHT Teil des src-tauri-Workspaces: die Tessellierungs-Bibliothek soll
|
||||
# unabhaengig von Tauri baubar/testbar bleiben (headless, ohne Webview-Toolchain).
|
||||
# Der leere [workspace]-Block schliesst die Crate aus einem uebergeordneten
|
||||
# Workspace aus, sodass `cargo test`/`cargo build` hier eigenstaendig laufen.
|
||||
[workspace]
|
||||
# Ausschluss laeuft ueber `exclude = ["render2d"]` im uebergeordneten
|
||||
# src-tauri/Cargo.toml. Standalone (`cd render2d && cargo test/build`) bildet die
|
||||
# Crate automatisch ihren eigenen Ein-Paket-Workspace (eigene Cargo.lock).
|
||||
#
|
||||
# KEIN eigener `[workspace]`-Block hier: sobald `cad-tauri` render2d per Pfad als
|
||||
# (optionale) Abhaengigkeit einbindet (Feature `native2d`), wuerde ein zweiter
|
||||
# Workspace-Root INNERHALB des src-tauri-Baums Cargo mit "multiple workspace
|
||||
# roots" abbrechen. Der Parent-`exclude` haelt die Crate trotzdem eigenstaendig.
|
||||
|
||||
[features]
|
||||
# Standard: nur die reine Tessellierung + Szene + Ortho-Matrix + WGSL-Quellen.
|
||||
|
||||
@@ -13,78 +13,14 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use render2d::gpu::Renderer;
|
||||
use render2d::types::{FillPolygon, Line, Outline, Scene, ViewBox};
|
||||
use render2d::PX_PER_M;
|
||||
use render2d::types::ViewBox;
|
||||
use render2d::{demo_scene, initial_view_box};
|
||||
|
||||
use winit::application::ApplicationHandler;
|
||||
use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
|
||||
use winit::event_loop::{ActiveEventLoop, EventLoop};
|
||||
use winit::window::{Window, WindowId};
|
||||
|
||||
/// Demo-Szene in Modell-Metern: ein L-foermiger Wand-Poche (konkav!), ein Raum
|
||||
/// und ein paar Striche — genug, um Fuellung, Umriss und Papier-mm-Linien zu sehen.
|
||||
fn demo_scene() -> Scene {
|
||||
let wall_grey: [f32; 4] = [0.55, 0.55, 0.55, 1.0];
|
||||
let room_blue: [f32; 4] = [0.20, 0.45, 0.85, 0.18];
|
||||
let ink: [f32; 4] = [0.10, 0.10, 0.10, 1.0];
|
||||
|
||||
// Konkaves L (Wandflaeche).
|
||||
let l = vec![
|
||||
[0.0, 0.0],
|
||||
[4.0, 0.0],
|
||||
[4.0, 2.0],
|
||||
[2.0, 2.0],
|
||||
[2.0, 4.0],
|
||||
[0.0, 4.0],
|
||||
];
|
||||
// Ein transluzenter Raum daneben.
|
||||
let room = vec![[5.0, 0.0], [9.0, 0.0], [9.0, 4.0], [5.0, 4.0]];
|
||||
|
||||
Scene {
|
||||
fills: vec![
|
||||
FillPolygon {
|
||||
pts: l.clone(),
|
||||
color: wall_grey,
|
||||
},
|
||||
FillPolygon {
|
||||
pts: room.clone(),
|
||||
color: room_blue,
|
||||
},
|
||||
],
|
||||
outlines: vec![
|
||||
Outline {
|
||||
pts: l,
|
||||
color: ink,
|
||||
width_mm: 0.35,
|
||||
},
|
||||
Outline {
|
||||
pts: room,
|
||||
color: ink,
|
||||
width_mm: 0.18,
|
||||
},
|
||||
],
|
||||
lines: vec![Line {
|
||||
a: [0.0, -1.0],
|
||||
b: [9.0, -1.0],
|
||||
color: ink,
|
||||
width_mm: 0.25,
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
/// viewBox so, dass die Szene mittig einpasst (Bildschirm-Raum = Meter*PX_PER_M).
|
||||
fn initial_view_box() -> ViewBox {
|
||||
// Szene ~ x[0..9], y[-1..4] in Meter -> Bildschirm x[0..810], y[-360..90].
|
||||
// Etwas Rand drumherum.
|
||||
let pad = 90.0;
|
||||
ViewBox::new(
|
||||
-pad,
|
||||
-4.0 * PX_PER_M - pad,
|
||||
9.0 * PX_PER_M + 2.0 * pad,
|
||||
5.0 * PX_PER_M + 2.0 * pad,
|
||||
)
|
||||
}
|
||||
|
||||
struct GpuState {
|
||||
surface: wgpu::Surface<'static>,
|
||||
device: wgpu::Device,
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
// Geteilte Demo-Szene fuer die Fenster-Spikes (standalone winit-Bin UND der
|
||||
// In-Tauri-Spike). EINE Quelle der Wahrheit, damit beide exakt dasselbe zeichnen
|
||||
// und der Renderer/die Szene NICHT dupliziert wird.
|
||||
//
|
||||
// serde-only + GPU-frei: baut im Standard-Feature mit (kein `render`/`window`
|
||||
// noetig), damit die Szene auch headless testbar bleibt.
|
||||
|
||||
use crate::tessellate::PX_PER_M;
|
||||
use crate::types::{FillPolygon, Line, Outline, Scene, ViewBox};
|
||||
|
||||
/// Demo-Szene in Modell-Metern: ein L-foermiger Wand-Poche (konkav!), ein Raum
|
||||
/// und ein paar Striche — genug, um Fuellung, Umriss und Papier-mm-Linien zu sehen.
|
||||
pub fn demo_scene() -> Scene {
|
||||
let wall_grey: [f32; 4] = [0.55, 0.55, 0.55, 1.0];
|
||||
let room_blue: [f32; 4] = [0.20, 0.45, 0.85, 0.18];
|
||||
let ink: [f32; 4] = [0.10, 0.10, 0.10, 1.0];
|
||||
|
||||
// Konkaves L (Wandflaeche).
|
||||
let l = vec![
|
||||
[0.0, 0.0],
|
||||
[4.0, 0.0],
|
||||
[4.0, 2.0],
|
||||
[2.0, 2.0],
|
||||
[2.0, 4.0],
|
||||
[0.0, 4.0],
|
||||
];
|
||||
// Ein transluzenter Raum daneben.
|
||||
let room = vec![[5.0, 0.0], [9.0, 0.0], [9.0, 4.0], [5.0, 4.0]];
|
||||
|
||||
Scene {
|
||||
fills: vec![
|
||||
FillPolygon {
|
||||
pts: l.clone(),
|
||||
color: wall_grey,
|
||||
},
|
||||
FillPolygon {
|
||||
pts: room.clone(),
|
||||
color: room_blue,
|
||||
},
|
||||
],
|
||||
outlines: vec![
|
||||
Outline {
|
||||
pts: l,
|
||||
color: ink,
|
||||
width_mm: 0.35,
|
||||
},
|
||||
Outline {
|
||||
pts: room,
|
||||
color: ink,
|
||||
width_mm: 0.18,
|
||||
},
|
||||
],
|
||||
lines: vec![Line {
|
||||
a: [0.0, -1.0],
|
||||
b: [9.0, -1.0],
|
||||
color: ink,
|
||||
width_mm: 0.25,
|
||||
}],
|
||||
}
|
||||
}
|
||||
|
||||
/// viewBox so, dass die Szene mittig einpasst (Bildschirm-Raum = Meter*PX_PER_M).
|
||||
pub fn initial_view_box() -> ViewBox {
|
||||
// Szene ~ x[0..9], y[-1..4] in Meter -> Bildschirm x[0..810], y[-360..90].
|
||||
// Etwas Rand drumherum.
|
||||
let pad = 90.0;
|
||||
ViewBox::new(
|
||||
-pad,
|
||||
-4.0 * PX_PER_M - pad,
|
||||
9.0 * PX_PER_M + 2.0 * pad,
|
||||
5.0 * PX_PER_M + 2.0 * pad,
|
||||
)
|
||||
}
|
||||
@@ -12,6 +12,7 @@
|
||||
// Standard-Build (`cargo test`/`cargo build` ohne Features) enthaelt nur die
|
||||
// GPU-freien Schichten und ist damit unabhaengig von einer Display-Session.
|
||||
|
||||
pub mod demo;
|
||||
pub mod ortho;
|
||||
pub mod shaders;
|
||||
pub mod tessellate;
|
||||
@@ -20,6 +21,7 @@ pub mod types;
|
||||
#[cfg(feature = "render")]
|
||||
pub mod gpu;
|
||||
|
||||
pub use demo::{demo_scene, initial_view_box};
|
||||
pub use ortho::{compute_ortho_matrix, meet_scale, mm_to_device_px, Mat4};
|
||||
pub use tessellate::{compile_scene, triangulate, GpuGeometry, PX_PER_M};
|
||||
pub use types::{FillPolygon, Line, Outline, Point, Rgba, Scene, ViewBox};
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
// Tauri-v2-Einstieg. Die eigentliche Geometrie liegt im serde-only Crate
|
||||
// `geometry`; hier nur die Befehls-Bruecke und der App-Start.
|
||||
|
||||
// M2-Spike: nativer wgpu-2D-Viewport im Tauri-Prozess (nur mit Feature `native2d`).
|
||||
#[cfg(feature = "native2d")]
|
||||
mod native2d;
|
||||
|
||||
/// Berechnet die Wand-Gehrungen im Rust-Kern und liefert sie ans Frontend.
|
||||
#[tauri::command]
|
||||
async fn compute_joins(
|
||||
@@ -12,6 +16,13 @@ async fn compute_joins(
|
||||
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
||||
pub fn run() {
|
||||
tauri::Builder::default()
|
||||
.setup(|_app| {
|
||||
// Nur mit Feature `native2d`: das native GPU-Fenster auf einem eigenen
|
||||
// Thread hochfahren, damit der Tauri-/GTK-Hauptthread frei bleibt.
|
||||
#[cfg(feature = "native2d")]
|
||||
native2d::spawn();
|
||||
Ok(())
|
||||
})
|
||||
.invoke_handler(tauri::generate_handler![compute_joins])
|
||||
.run(tauri::generate_context!())
|
||||
.expect("error while running tauri application");
|
||||
|
||||
@@ -0,0 +1,259 @@
|
||||
// M2-Spike: der native wgpu-2D-Renderer, gestartet AUS DEM Tauri-Prozess heraus.
|
||||
//
|
||||
// Ziel: beweisen, dass die native GPU-Flaeche (render2d) im echten Tauri-Prozess
|
||||
// laeuft — NICHT in der WebKitGTK-Webview (dem bekannten Perf-Flaschenhals) und
|
||||
// NICHT in einem separaten Chromium-Workaround-Fenster.
|
||||
//
|
||||
// Architektur (Ansatz B, siehe docs/welle-c-hlr-spike/m2-approach.md):
|
||||
// - Der Tauri-Hauptthread haelt weiterhin die GTK-Hauptschleife + die
|
||||
// Webview-Fenster (HTML-Chrome).
|
||||
// - Dieses Modul oeffnet ein EIGENES natives winit-Fenster mit eigener
|
||||
// wgpu-Surface auf einem HINTERGRUND-Thread. winit spricht auf Linux direkt
|
||||
// Wayland/X11 (KEIN GTK) — dadurch ist die Fenster-/Surface-Ebene voellig
|
||||
// getrennt von WebKitGTK. Kein geteilter Wayland-Surface => keine
|
||||
// Surface-Contention/Flicker wie beim Unterlegen einer Roh-Surface unter die
|
||||
// Webview.
|
||||
// - winit erlaubt eine Event-Loop auf einem Nicht-Haupt-Thread via
|
||||
// `EventLoopBuilderExtWayland/X11::with_any_thread(true)`.
|
||||
//
|
||||
// Der Renderer selbst wird NICHT reimplementiert: wir verwenden
|
||||
// `render2d::gpu::Renderer` + `render2d::demo_scene()` — exakt der Code, der im
|
||||
// standalone `spike`-Bin bereits als fluessig verifiziert wurde.
|
||||
//
|
||||
// Bewusst hinter dem Cargo-Feature `native2d` — der normale Tauri-Build zieht
|
||||
// weder winit noch wgpu und bleibt unveraendert.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use render2d::gpu::Renderer;
|
||||
use render2d::types::ViewBox;
|
||||
use render2d::{demo_scene, initial_view_box, meet_scale};
|
||||
|
||||
use winit::application::ApplicationHandler;
|
||||
use winit::event::{ElementState, MouseButton, MouseScrollDelta, WindowEvent};
|
||||
use winit::event_loop::{ActiveEventLoop, EventLoop};
|
||||
use winit::window::{Window, WindowId};
|
||||
|
||||
/// GPU-Zustand des nativen Fensters (Surface + Device + Renderer). 1:1 wie im
|
||||
/// standalone Spike — die Surface haengt an DIESEM winit-Fenster, nicht an der
|
||||
/// Webview.
|
||||
struct GpuState {
|
||||
surface: wgpu::Surface<'static>,
|
||||
device: wgpu::Device,
|
||||
queue: wgpu::Queue,
|
||||
config: wgpu::SurfaceConfiguration,
|
||||
renderer: Renderer,
|
||||
window: Arc<Window>,
|
||||
}
|
||||
|
||||
impl GpuState {
|
||||
fn new(window: Arc<Window>) -> Self {
|
||||
let size = window.inner_size();
|
||||
let instance = wgpu::Instance::default();
|
||||
let surface = instance
|
||||
.create_surface(window.clone())
|
||||
.expect("Surface erstellen");
|
||||
let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
|
||||
power_preference: wgpu::PowerPreference::HighPerformance,
|
||||
force_fallback_adapter: false,
|
||||
compatible_surface: Some(&surface),
|
||||
}))
|
||||
.expect("kein passender GPU-Adapter");
|
||||
let (device, queue) = pollster::block_on(adapter.request_device(
|
||||
&wgpu::DeviceDescriptor {
|
||||
label: Some("2d.device"),
|
||||
required_features: wgpu::Features::empty(),
|
||||
required_limits: wgpu::Limits::default(),
|
||||
memory_hints: wgpu::MemoryHints::Performance,
|
||||
},
|
||||
None,
|
||||
))
|
||||
.expect("Device anfordern");
|
||||
|
||||
let caps = surface.get_capabilities(&adapter);
|
||||
let format = caps
|
||||
.formats
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|f| f.is_srgb())
|
||||
.unwrap_or(caps.formats[0]);
|
||||
let config = wgpu::SurfaceConfiguration {
|
||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||||
format,
|
||||
width: size.width.max(1),
|
||||
height: size.height.max(1),
|
||||
present_mode: caps.present_modes[0],
|
||||
alpha_mode: caps.alpha_modes[0],
|
||||
view_formats: vec![],
|
||||
desired_maximum_frame_latency: 2,
|
||||
};
|
||||
surface.configure(&device, &config);
|
||||
|
||||
let mut renderer = Renderer::new(&device, format);
|
||||
renderer.upload_scene(&device, &demo_scene());
|
||||
|
||||
Self {
|
||||
surface,
|
||||
device,
|
||||
queue,
|
||||
config,
|
||||
renderer,
|
||||
window,
|
||||
}
|
||||
}
|
||||
|
||||
fn resize(&mut self, w: u32, h: u32) {
|
||||
if w == 0 || h == 0 {
|
||||
return;
|
||||
}
|
||||
self.config.width = w;
|
||||
self.config.height = h;
|
||||
self.surface.configure(&self.device, &self.config);
|
||||
}
|
||||
|
||||
fn render(&mut self, view_box: ViewBox) {
|
||||
let frame = match self.surface.get_current_texture() {
|
||||
Ok(f) => f,
|
||||
Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
|
||||
self.surface.configure(&self.device, &self.config);
|
||||
return;
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("Surface-Fehler: {e:?}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let view = frame
|
||||
.texture
|
||||
.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
self.renderer.render(
|
||||
&self.device,
|
||||
&self.queue,
|
||||
&view,
|
||||
view_box,
|
||||
(self.config.width, self.config.height),
|
||||
);
|
||||
frame.present();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct App {
|
||||
state: Option<GpuState>,
|
||||
view_box: Option<ViewBox>,
|
||||
dragging: bool,
|
||||
last_cursor: (f64, f64),
|
||||
}
|
||||
|
||||
impl ApplicationHandler for App {
|
||||
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
||||
if self.state.is_some() {
|
||||
return;
|
||||
}
|
||||
let attrs = Window::default_attributes().with_title("cad — nativer 2D-Viewport (wgpu, in Tauri)");
|
||||
let window = Arc::new(event_loop.create_window(attrs).expect("Fenster erstellen"));
|
||||
self.view_box.get_or_insert_with(initial_view_box);
|
||||
self.state = Some(GpuState::new(window));
|
||||
}
|
||||
|
||||
fn window_event(
|
||||
&mut self,
|
||||
event_loop: &ActiveEventLoop,
|
||||
_id: WindowId,
|
||||
event: WindowEvent,
|
||||
) {
|
||||
let Some(state) = self.state.as_mut() else {
|
||||
return;
|
||||
};
|
||||
let vb = self.view_box.get_or_insert_with(initial_view_box);
|
||||
match event {
|
||||
// Nur DIESES Fenster schliessen — die Tauri-Webview laeuft weiter.
|
||||
WindowEvent::CloseRequested => event_loop.exit(),
|
||||
WindowEvent::Resized(size) => {
|
||||
state.resize(size.width, size.height);
|
||||
state.window.request_redraw();
|
||||
}
|
||||
WindowEvent::MouseInput { state: s, button, .. } => {
|
||||
if button == MouseButton::Left {
|
||||
self.dragging = s == ElementState::Pressed;
|
||||
}
|
||||
}
|
||||
WindowEvent::CursorMoved { position, .. } => {
|
||||
if self.dragging {
|
||||
let (vw, vh) = (state.config.width as f32, state.config.height as f32);
|
||||
let meet = meet_scale(*vb, vw, vh);
|
||||
let dx = (position.x - self.last_cursor.0) as f32 / meet;
|
||||
let dy = (position.y - self.last_cursor.1) as f32 / meet;
|
||||
vb.x -= dx;
|
||||
vb.y -= dy;
|
||||
state.window.request_redraw();
|
||||
}
|
||||
self.last_cursor = (position.x, position.y);
|
||||
}
|
||||
WindowEvent::MouseWheel { delta, .. } => {
|
||||
let step = match delta {
|
||||
MouseScrollDelta::LineDelta(_, y) => y,
|
||||
MouseScrollDelta::PixelDelta(p) => (p.y as f32) / 40.0,
|
||||
};
|
||||
let factor = if step > 0.0 { 0.9 } else { 1.0 / 0.9 };
|
||||
let cx = vb.x + vb.w * 0.5;
|
||||
let cy = vb.y + vb.h * 0.5;
|
||||
vb.w *= factor;
|
||||
vb.h *= factor;
|
||||
vb.x = cx - vb.w * 0.5;
|
||||
vb.y = cy - vb.h * 0.5;
|
||||
state.window.request_redraw();
|
||||
}
|
||||
WindowEvent::RedrawRequested => {
|
||||
let vb_copy = *vb;
|
||||
state.render(vb_copy);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Baut die winit-Event-Loop so, dass sie auf DIESEM (Nicht-Haupt-)Thread laufen
|
||||
/// darf. Auf Linux/Wayland ist das `EventLoopBuilderExtWayland::with_any_thread`,
|
||||
/// auf X11 das X11-Pendant. Ohne diese Freigabe panict winit, weil es die
|
||||
/// Event-Loop standardmaessig nur auf dem Hauptthread zulaesst (den haelt hier
|
||||
/// aber die GTK-/Tauri-Schleife).
|
||||
fn build_event_loop() -> EventLoop<()> {
|
||||
use winit::event_loop::EventLoopBuilder;
|
||||
let mut builder = EventLoopBuilder::default();
|
||||
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
// Wayland zuerst versuchen; faellt winit intern auf X11 zurueck, greift
|
||||
// die X11-Freigabe. Beide Extension-Traits setzen dasselbe any-thread-Flag.
|
||||
use winit::platform::wayland::EventLoopBuilderExtWayland;
|
||||
EventLoopBuilderExtWayland::with_any_thread(&mut builder, true);
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
use winit::platform::x11::EventLoopBuilderExtX11;
|
||||
EventLoopBuilderExtX11::with_any_thread(&mut builder, true);
|
||||
}
|
||||
|
||||
builder.build().expect("Event-Loop erstellen")
|
||||
}
|
||||
|
||||
/// Blockierender Lauf der nativen Event-Loop. Gedacht fuer einen dedizierten
|
||||
/// Thread (siehe `spawn`), NICHT fuer den Tauri-Hauptthread.
|
||||
fn run_blocking() {
|
||||
let event_loop = build_event_loop();
|
||||
event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
|
||||
let mut app = App::default();
|
||||
// `run_app` blockiert bis das native Fenster geschlossen wird.
|
||||
let _ = event_loop.run_app(&mut app);
|
||||
}
|
||||
|
||||
/// Startet das native 2D-Fenster auf einem eigenen Thread und kehrt sofort
|
||||
/// zurueck. So bleibt die Tauri-/GTK-Hauptschleife frei. Aufruf typischerweise
|
||||
/// aus dem Tauri-`setup`-Hook.
|
||||
pub fn spawn() {
|
||||
std::thread::Builder::new()
|
||||
.name("cad-native2d".into())
|
||||
.spawn(run_blocking)
|
||||
.expect("native2d-Thread starten");
|
||||
}
|
||||
Reference in New Issue
Block a user