dear-imgui-wgpu 0.21.0

WGPU renderer backend for dear-imgui-rs (native + WebAssembly)
Documentation 
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
71
72
73
74
75
76
77

use dear_imgui_rs::{NativeWindowInstanceId, NativeWindowTarget, platform_io::Viewport};

use super::multi_viewport_runtime::WgpuViewportError;

pub(super) use dear_imgui_winit::WinitWindowRenderLease as NativeWindowLease;
pub(super) use dear_imgui_winit::multi_viewport::WinitViewportRendererAdapter as PlatformOwner;

/// Creates a surface retaining the exact validated native window allocation.
pub(super) fn create_surface(
    instance: &wgpu::Instance,
    platform: &PlatformOwner,
    viewport: &Viewport,
    expected: Option<NativeWindowInstanceId>,
) -> Result<(wgpu::Surface<'static>, [u32; 2], NativeWindowTarget), WgpuViewportError> {
    let snapshot = match expected {
        Some(instance) => platform.window_snapshot_for_instance(instance)?,
        None => platform.window_snapshot_for_viewport(viewport.id())?,
    }
    .ok_or(WgpuViewportError::SurfaceOperationFailed {
        operation: "resolve the registered Winit viewport window",
    })?;
    let lease = native_window_lease(platform, snapshot.target.instance_id)?.ok_or(
        WgpuViewportError::SurfaceOperationFailed {
            operation: "lease the registered Winit viewport window",
        },
    )?;
    let window = lease.window_arc();
    let size = snapshot.physical_client_size;
    let surface =
        instance
            .create_surface(window)
            .map_err(|_| WgpuViewportError::SurfaceOperationFailed {
                operation: "create Winit viewport surface",
            })?;
    Ok((surface, [size.width, size.height], snapshot.target))
}

pub(super) fn framebuffer_size(
    platform: &PlatformOwner,
    instance: NativeWindowInstanceId,
) -> Result<[u32; 2], WgpuViewportError> {
    let snapshot = platform.window_snapshot_for_instance(instance)?.ok_or(
        WgpuViewportError::SurfaceOperationFailed {
            operation: "resolve the registered Winit viewport framebuffer",
        },
    )?;
    let size = snapshot.physical_client_size;
    Ok([size.width, size.height])
}

/// Captures metadata through the exact platform owner, without returning a native lease.
pub(super) fn target_for_viewport(
    platform: &PlatformOwner,
    viewport: dear_imgui_rs::Id,
) -> Result<Option<NativeWindowTarget>, WgpuViewportError> {
    Ok(platform
        .window_snapshot_for_viewport(viewport)?
        .map(|snapshot| snapshot.target))
}

pub(super) fn target_for_instance(
    platform: &PlatformOwner,
    instance: NativeWindowInstanceId,
) -> Result<Option<NativeWindowTarget>, WgpuViewportError> {
    Ok(platform
        .window_snapshot_for_instance(instance)?
        .map(|snapshot| snapshot.target))
}

pub(super) fn native_window_lease(
    platform: &PlatformOwner,
    instance: NativeWindowInstanceId,
) -> Result<Option<NativeWindowLease>, WgpuViewportError> {
    platform
        .acquire_native_window_lease(instance)
        .map_err(Into::into)
}