grafting 0.2.0

Native texture interop helpers for importing offscreen producer frames into host-owned wgpu textures
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

mod adapter;
mod surfman_frame_context;

#[cfg(any(target_os = "linux", target_os = "android"))]
mod linux;

#[cfg(target_vendor = "apple")]
mod metal;

#[cfg(target_os = "windows")]
mod windows;

#[cfg(target_os = "windows")]
mod windows_dx12_shared;

pub use adapter::select_adapter_matching_surfman_luid;

use std::cell::Cell;
use std::rc::Rc;

use dpi::PhysicalSize;

use crate::{
    FrameProducer, GlFramebufferSource, GlFramebufferSourceImpl, HostWgpuContext, ImportOptions,
    ImportedTexture, InteropBackend, InteropError, NativeFrame, NativeFrameKind,
    ProducerCapabilities, SyncMechanism, UnsupportedReason,
};

pub use surfman_frame_context::SurfmanFrameContext;

pub struct SurfmanFrameProducer {
    context: Rc<SurfmanFrameContext>,
    size: Rc<Cell<PhysicalSize<u32>>>,
    generation: Cell<u64>,
    #[cfg(target_os = "windows")]
    angle_dx12_shared: Rc<windows_dx12_shared::AngleDx12SharedCache>,
}

#[cfg_attr(target_os = "windows", allow(dead_code))]
struct SurfmanGlFrameSource {
    context: Rc<SurfmanFrameContext>,
    size: PhysicalSize<u32>,
    generation: u64,
    #[cfg(target_os = "windows")]
    angle_dx12_shared: Rc<windows_dx12_shared::AngleDx12SharedCache>,
}

impl SurfmanFrameProducer {
    pub fn new(context: Rc<SurfmanFrameContext>, initial_size: PhysicalSize<u32>) -> Self {
        Self {
            context,
            size: Rc::new(Cell::new(initial_size)),
            generation: Cell::new(0),
            #[cfg(target_os = "windows")]
            angle_dx12_shared: Rc::new(windows_dx12_shared::AngleDx12SharedCache::new()),
        }
    }

    pub fn context(&self) -> Rc<SurfmanFrameContext> {
        self.context.clone()
    }

    pub fn size(&self) -> PhysicalSize<u32> {
        self.size.get()
    }

    pub fn set_size(&self, size: PhysicalSize<u32>) {
        self.size.set(size);
    }
}

impl FrameProducer for SurfmanFrameProducer {
    fn capabilities(&self) -> ProducerCapabilities {
        ProducerCapabilities {
            supported_frames: vec![NativeFrameKind::GlFramebufferSource],
        }
    }

    fn acquire_frame(&mut self) -> Result<NativeFrame, InteropError> {
        let next_generation = self.generation.get() + 1;
        self.generation.set(next_generation);

        Ok(NativeFrame::GlFramebufferSource(GlFramebufferSource::new(
            self.size.get(),
            next_generation,
            SyncMechanism::None,
            Rc::new(SurfmanGlFrameSource {
                context: self.context.clone(),
                size: self.size.get(),
                generation: next_generation,
                #[cfg(target_os = "windows")]
                angle_dx12_shared: self.angle_dx12_shared.clone(),
            }),
        )))
    }
}

impl GlFramebufferSourceImpl for SurfmanGlFrameSource {
    fn import_into(
        &self,
        _frame: &GlFramebufferSource,
        host: &HostWgpuContext,
        _options: &ImportOptions,
    ) -> Result<ImportedTexture, InteropError> {
        match host.backend {
            #[cfg(any(target_os = "linux", target_os = "android"))]
            InteropBackend::Vulkan => linux::import_current_frame(self, _frame, host, _options),

            #[cfg(target_os = "windows")]
            InteropBackend::Vulkan => windows::import_current_frame(self, _frame, host, _options),

            #[cfg(target_vendor = "apple")]
            InteropBackend::Metal => metal::import_current_frame(self, _frame, host, _options),

            #[cfg(target_os = "windows")]
            InteropBackend::Dx12 => {
                windows::import_current_frame_dx12(self, _frame, host, _options)
            }

            #[cfg(not(target_os = "windows"))]
            InteropBackend::Dx12 => Err(InteropError::Unsupported(
                UnsupportedReason::PlatformNotImplemented,
            )),
            InteropBackend::Unknown => Err(InteropError::Unsupported(
                UnsupportedReason::HostBackendUnavailable,
            )),
            _ => Err(InteropError::Unsupported(
                UnsupportedReason::HostBackendMismatch,
            )),
        }
    }
}