uzor-urx-wgpu 1.5.1

URX WGPU backend — consumes urx-core DrawCommand, dispatches to instanced-WGPU primitive pipelines (Quad SDF + Line capsule + Triangle + Text atlas). Wraps uzor-render-wgpu-instanced (the existing well-tested primitive crate) with the URX scene-consumer API + URX metrics.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use std::fmt;

pub(crate) struct FrameGuard {
    id: u64,
    enabled: bool,
    fallback: Option<uzor::diagnostics::FrameProfileGuard>,
}

impl FrameGuard {
    pub(crate) fn enter() -> Self {
        let fallback = if uzor::diagnostics::current_frame_id().is_none() {
            Some(uzor::diagnostics::FrameProfileGuard::enter())
        } else {
            None
        };
        let id = uzor::diagnostics::current_frame_id()
            .expect("runtime or renderer fallback must establish frame correlation");
        let enabled = uzor::diagnostics::profile_enabled();
        if enabled {
            stage(
                "render_begin",
                format_args!(
                    "thread={:?} correlation_source={}",
                    std::thread::current().id(),
                    if fallback.is_some() { "renderer_fallback" } else { "runtime" },
                ),
            );
        }
        Self { id, enabled, fallback }
    }

    pub(crate) fn id(&self) -> u64 {
        self.id
    }

    pub(crate) fn enabled(&self) -> bool {
        self.enabled
    }
}

impl Drop for FrameGuard {
    fn drop(&mut self) {
        if self.enabled {
            stage("render_scope_end", format_args!(""));
        }
        let _ = self.fallback.take();
    }
}

pub(crate) fn enabled() -> bool {
    uzor::diagnostics::profile_enabled()
}

pub(crate) fn stage(stage: &'static str, details: fmt::Arguments<'_>) {
    uzor::diagnostics::stage("urx_native_wgpu", stage, details);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn renderer_guard_reuses_runtime_frame_correlation() {
        let runtime = uzor::diagnostics::FrameProfileGuard::enter();
        let renderer = FrameGuard::enter();

        assert_eq!(renderer.id(), runtime.id());
        assert!(renderer.fallback.is_none());
    }
}