smithay 0.2.0

Smithay is a library for writing wayland compositors.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! EGL surface related structs

use super::{error::*, ffi, native, EGLContext};
use crate::backend::graphics::SwapBuffersError;
use nix::libc::c_int;
use std::{
    cell::Cell,
    ops::{Deref, DerefMut},
    rc::{Rc, Weak},
};

/// EGL surface of a given EGL context for rendering
pub struct EGLSurface<N: native::NativeSurface> {
    context: Weak<ffi::egl::types::EGLContext>,
    display: Weak<ffi::egl::types::EGLDisplay>,
    native: N,
    surface: Cell<ffi::egl::types::EGLSurface>,
    config_id: ffi::egl::types::EGLConfig,
    surface_attributes: Vec<c_int>,
}

impl<N: native::NativeSurface> Deref for EGLSurface<N> {
    type Target = N;
    fn deref(&self) -> &N {
        &self.native
    }
}

impl<N: native::NativeSurface> DerefMut for EGLSurface<N> {
    fn deref_mut(&mut self) -> &mut N {
        &mut self.native
    }
}

impl<N: native::NativeSurface> EGLSurface<N> {
    pub(crate) fn new<B: native::Backend<Surface = N>, D: native::NativeDisplay<B>>(
        context: &EGLContext<B, D>,
        native: N,
    ) -> Result<EGLSurface<N>> {
        let surface = unsafe {
            ffi::egl::CreateWindowSurface(
                *context.display,
                context.config_id,
                native.ptr(),
                context.surface_attributes.as_ptr(),
            )
        };

        if surface.is_null() {
            bail!(ErrorKind::SurfaceCreationFailed);
        }

        Ok(EGLSurface {
            context: Rc::downgrade(&context.context),
            display: Rc::downgrade(&context.display),
            native,
            surface: Cell::new(surface),
            config_id: context.config_id,
            surface_attributes: context.surface_attributes.clone(),
        })
    }

    /// Swaps buffers at the end of a frame.
    pub fn swap_buffers(&self) -> ::std::result::Result<(), SwapBuffersError> {
        let surface = self.surface.get();

        if !surface.is_null() {
            if let Some(display) = self.display.upgrade() {
                let ret = unsafe { ffi::egl::SwapBuffers((*display) as *const _, surface as *const _) };

                if ret == 0 {
                    match unsafe { ffi::egl::GetError() } as u32 {
                        ffi::egl::CONTEXT_LOST => return Err(SwapBuffersError::ContextLost),
                        err => return Err(SwapBuffersError::Unknown(err)),
                    };
                } else {
                    self.native.swap_buffers()?;
                }
            } else {
                return Err(SwapBuffersError::ContextLost);
            }
        };

        if self.native.needs_recreation() || surface.is_null() {
            if let Some(display) = self.display.upgrade() {
                self.native.recreate();
                self.surface.set(unsafe {
                    ffi::egl::CreateWindowSurface(
                        *display,
                        self.config_id,
                        self.native.ptr(),
                        self.surface_attributes.as_ptr(),
                    )
                });
            }
        }

        Ok(())
    }

    /// Makes the OpenGL context the current context in the current thread.
    ///
    /// # Unsafety
    ///
    /// This function is marked unsafe, because the context cannot be made current
    /// on multiple threads.
    pub unsafe fn make_current(&self) -> ::std::result::Result<(), SwapBuffersError> {
        if let (Some(display), Some(context)) = (self.display.upgrade(), self.context.upgrade()) {
            let ret = ffi::egl::MakeCurrent(
                (*display) as *const _,
                self.surface.get() as *const _,
                self.surface.get() as *const _,
                (*context) as *const _,
            );

            if ret == 0 {
                match ffi::egl::GetError() as u32 {
                    ffi::egl::CONTEXT_LOST => Err(SwapBuffersError::ContextLost),
                    err => panic!("eglMakeCurrent failed (eglGetError returned 0x{:x})", err),
                }
            } else {
                Ok(())
            }
        } else {
            Err(SwapBuffersError::ContextLost)
        }
    }

    /// Returns true if the OpenGL surface is the current one in the thread.
    pub fn is_current(&self) -> bool {
        if self.context.upgrade().is_some() {
            unsafe {
                ffi::egl::GetCurrentSurface(ffi::egl::DRAW as _) == self.surface.get() as *const _
                    && ffi::egl::GetCurrentSurface(ffi::egl::READ as _) == self.surface.get() as *const _
            }
        } else {
            false
        }
    }
}

impl<N: native::NativeSurface> Drop for EGLSurface<N> {
    fn drop(&mut self) {
        if let Some(display) = self.display.upgrade() {
            unsafe {
                ffi::egl::DestroySurface((*display) as *const _, self.surface.get() as *const _);
            }
        }
    }
}