exposed-gl 0.0.1-beta

OpenGl context creation for library "exposed".
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

#[cfg(target_os = "windows")]
pub mod win32_gl;
#[cfg(target_os = "windows")]
pub use win32_gl as platform;

#[cfg(target_os = "linux")]
pub mod x11_gl;
#[cfg(target_os = "linux")]
pub use x11_gl as platform;

#[cfg(target_os = "android")]
pub mod gles;
#[cfg(target_os = "android")]
pub use gles as platform;

mod picker;
pub use picker::*;

pub mod tokens;

pub use platform::{free_lib_opengl, get_proc_addr, load_lib_opengl};

use std::io::Error;

use exposed::{
    destroy::Destroy,
    window::{Context, Event, WindowBuilder, WindowHandle},
};

use platform::GlPixelFormat;

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct GlSurface(pub platform::GlSurface);

impl GlSurface {
    pub fn swap_buffers(self) -> Result<(), Error> {
        self.0.swap_buffers()
    }

    pub fn make_current(self, context: GlContext) -> Result<(), Error> {
        self.0.make_current(context.0)
    }

    pub fn set_swap_interval(self, interval: i32) -> Result<(), Error> {
        self.0.set_swap_interval(interval)
    }

    pub fn build_with<E: Event>(
        window_builder: &WindowBuilder, context: Context, min_config: &[u32], picker: &mut impl GlConfigPicker,
    ) -> Result<(GlSurface, WindowHandle), Error> {
        let (surface, window) = platform::GlSurface::build_with::<E, _>(&window_builder.0, context, min_config, picker)?;
        Ok((surface.into(), window.into()))
    }

    pub fn build<E: Event>(window: WindowHandle, config: &[u32], picker: &mut impl GlConfigPicker) -> Result<GlSurface, Error> {
        Ok(platform::GlSurface::build::<E, _>(window.0, config, picker)?.into())
    }

    pub fn create_context(&self, config: &[u32], share_context: GlContext) -> Result<GlContext, Error> {
        Ok(self.0.create_context(config, share_context.0)?.into())
    }
}

impl Destroy for GlSurface {
    fn destroy(&mut self) -> Result<(), std::io::Error> {
        self.0.destroy()
    }
}

#[repr(C)]
#[derive(Debug, Clone, Copy)]
/// Just a wrapper struct around OpenGl context handle.
pub struct GlContext(pub platform::GlContext);

impl GlContext {
    pub const NO_CONTEXT: Self = Self(platform::GlContext::NO_CONTEXT);
}

impl Destroy for GlContext {
    fn destroy(&mut self) -> Result<(), std::io::Error> {
        self.0.destroy()
    }
}

impl From<platform::GlContext> for GlContext {
    fn from(value: platform::GlContext) -> Self {
        Self(value)
    }
}

impl From<platform::GlSurface> for GlSurface {
    fn from(value: platform::GlSurface) -> Self {
        Self(value)
    }
}

pub trait GlConfigPicker {
    fn pick(&mut self, pixel_format: GlPixelFormat) -> Option<usize>;
}