baseview 0.3.5

Low-level windowing system geared towards making audio plugin UIs.
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

use crate::gl::GlConfig;
use crate::platform::gl::{CreationFailedError, FbConfig, FbConfigInner, WindowConfig};
use crate::platform::x11::xcb_window::XcbWindow;
use crate::platform::{PlatformError, X11Connection};
use crate::wrappers::egl::{Egl, EglConfig, EglContext, EglDisplay, EglSurface};
use std::ffi::{c_void, CStr};
use std::rc::Rc;
use x11rb::protocol::xproto::Visualid;

pub struct EglGlContext {
    surface: EglSurface,
    context: EglContext,
}

impl EglGlContext {
    pub(crate) fn create(
        window: &XcbWindow, gl_config: &GlConfig, egl_config: EglConfig, display: EglDisplay,
    ) -> Result<Self, PlatformError> {
        let surface = display.create_surface(egl_config, window.id().get(), gl_config)?;
        let context = display
            .egl()
            .with_opengl(|bound| display.create_context(egl_config, bound, gl_config))??;

        Ok(Self { surface, context })
    }
}

impl EglGlContext {
    pub fn get_fb_config_and_visual(
        connection: &Rc<X11Connection>, gl_config: GlConfig,
    ) -> Result<(FbConfig, WindowConfig), PlatformError> {
        let egl = Egl::open()?;
        let display = egl.create_display(connection)?;

        let config = display.choose_config(&gl_config)?.ok_or(CreationFailedError::EglNoDisplay)?;
        let visual = config.get_visual_id(&display)?;

        let depth = Self::find_visual_depth_for_id(connection, visual)
            .ok_or(CreationFailedError::EglUnknownVisualId(visual))?;

        let window_config = WindowConfig { depth, visual };
        let fb_config = FbConfig { gl_config, fb_config: FbConfigInner::Egl { display, config } };

        Ok((fb_config, window_config))
    }

    fn find_visual_depth_for_id(connection: &X11Connection, visual_id: Visualid) -> Option<u8> {
        connection
            .default_screen()
            .allowed_depths
            .iter()
            .find(|d| d.visuals.iter().any(|v| v.visual_id == visual_id))
            .map(|d| d.depth)
    }

    pub fn make_current(&self) -> Result<(), PlatformError> {
        self.context.make_current(&self.surface)?;

        Ok(())
    }

    pub fn make_not_current(&self) -> Result<(), PlatformError> {
        self.surface.display().egl().with_opengl(|gl| self.context.make_not_current(gl))??;

        Ok(())
    }

    pub fn get_proc_address(&self, symbol: &CStr) -> *const c_void {
        self.surface.display().egl().get_proc_address(symbol)
    }

    pub fn swap_buffers(&self) -> Result<(), PlatformError> {
        self.surface.swap_buffers()?;
        Ok(())
    }
}