swsurface 0.1.4

Software-rendered surface for winit
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

//! Wayland/X11 backend
use either::Either;
use std::ops::{Deref, DerefMut};
use winit::{platform::unix::*, window::Window};

use super::{align::Align, Config, ContextBuilder, Format, ImageInfo};

mod wayland;
mod x11;

#[derive(Debug)]
pub enum ContextImpl {
    Wayland(wayland::ContextImpl),
    X11,
}

impl ContextImpl {
    pub const TAKES_READY_CB: bool = true;

    pub fn new<T: 'static>(builder: ContextBuilder<'_, T>) -> Self {
        unsafe {
            match builder.event_loop.wayland_display() {
                Some(wl_dpy) => ContextImpl::Wayland(wayland::ContextImpl::new(wl_dpy, builder)),
                None => ContextImpl::X11,
            }
        }
    }
}

#[derive(Debug)]
pub enum SurfaceImpl {
    Wayland(wayland::SurfaceImpl),
    X11(x11::SurfaceImpl),
}

impl SurfaceImpl {
    pub(crate) unsafe fn new(window: &Window, context: &ContextImpl, config: &Config) -> Self {
        let scanline_align = Align::new(config.scanline_align).unwrap();

        match (
            window.wayland_display(),
            window.wayland_surface(),
            window.xlib_display(),
            window.xlib_window(),
        ) {
            (Some(wl_dpy), Some(wl_srf), _, _) => match context {
                ContextImpl::Wayland(context) => SurfaceImpl::Wayland(wayland::SurfaceImpl::new(
                    wl_dpy,
                    wl_srf,
                    window.id(),
                    context,
                    config,
                    scanline_align,
                )),
                ContextImpl::X11 => panic!("backend mismatch"),
            },
            (None, None, Some(x_dpy), Some(x_wnd)) => match context {
                ContextImpl::Wayland(_) => panic!("backend mismatch"),
                ContextImpl::X11 => SurfaceImpl::X11(x11::SurfaceImpl::new(
                    x_dpy,
                    x_wnd,
                    window.id(),
                    config,
                    scanline_align,
                )),
            },
            _ => unreachable!(),
        }
    }

    pub fn update_surface(&self, extent: [u32; 2], format: Format) {
        match self {
            SurfaceImpl::Wayland(imp) => imp.update_surface(extent, format),
            SurfaceImpl::X11(imp) => imp.update_surface(extent, format),
        }
    }

    pub fn supported_formats(&self) -> impl Iterator<Item = Format> + '_ {
        match self {
            SurfaceImpl::Wayland(imp) => Either::Left(imp.supported_formats()),
            SurfaceImpl::X11(imp) => Either::Right(imp.supported_formats()),
        }
    }

    pub fn image_info(&self) -> ImageInfo {
        match self {
            SurfaceImpl::Wayland(imp) => imp.image_info(),
            SurfaceImpl::X11(imp) => imp.image_info(),
        }
    }

    pub fn num_images(&self) -> usize {
        match self {
            SurfaceImpl::Wayland(imp) => imp.num_images(),
            SurfaceImpl::X11(imp) => imp.num_images(),
        }
    }

    pub fn does_preserve_image(&self) -> bool {
        match self {
            SurfaceImpl::Wayland(imp) => imp.does_preserve_image(),
            SurfaceImpl::X11(imp) => imp.does_preserve_image(),
        }
    }

    pub fn poll_next_image(&self) -> Option<usize> {
        match self {
            SurfaceImpl::Wayland(imp) => imp.poll_next_image(),
            SurfaceImpl::X11(imp) => imp.poll_next_image(),
        }
    }

    pub fn lock_image(&self, i: usize) -> impl Deref<Target = [u8]> + DerefMut + '_ {
        match self {
            SurfaceImpl::Wayland(imp) => Either::Left(imp.lock_image(i)),
            SurfaceImpl::X11(imp) => Either::Right(imp.lock_image(i)),
        }
    }

    pub fn present_image(&self, i: usize) {
        match self {
            SurfaceImpl::Wayland(imp) => imp.present_image(i),
            SurfaceImpl::X11(imp) => imp.present_image(i),
        }
    }
}