xgl 0.2.2

Unified minimalist OpenGL 3.3 & WebGL abstractions.
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

// Copyright (C) 2025 Daniel Mueller <deso@posteo.net>
// SPDX-License-Identifier: (Apache-2.0 OR MIT)

use std::num::NonZeroU32;

use glutin::config::Config;
use glutin::config::ConfigTemplateBuilder;
use glutin::context::ContextApi;
use glutin::context::ContextAttributesBuilder;
use glutin::context::GlProfile;
use glutin::context::NotCurrentGlContext as _;
use glutin::context::PossiblyCurrentContext;
use glutin::context::Version;
use glutin::display::Display;
use glutin::display::DisplayApiPreference;
use glutin::display::GlDisplay as _;
use glutin::surface::Surface;
use glutin::surface::SurfaceAttributesBuilder;
use glutin::surface::WindowSurface;

use winit::event_loop::EventLoop;
use winit::platform::x11::register_xlib_error_hook;
use winit::platform::x11::EventLoopBuilderExtX11 as _;
use winit::raw_window_handle::HasDisplayHandle as _;
use winit::raw_window_handle::HasWindowHandle as _;
use winit::raw_window_handle::RawDisplayHandle;
use winit::window::Window as WinitWindow;

use crate::sys;


/// An OpenGL context.
#[derive(Debug)]
struct Context {
  /// The OpenGL surface that is used for rendering.
  _surface: Surface<WindowSurface>,
  /// The OpenGL context used for double buffering.
  _context: PossiblyCurrentContext,
}

impl Context {
  /// Create proper [`Display`] object and an associated [`Config`] from
  /// a system display handle.
  fn create_display_and_config(display_handle: RawDisplayHandle) -> (Display, Config) {
    let preference = DisplayApiPreference::Glx(Box::new(register_xlib_error_hook));
    // SAFETY: `display_handle` is a valid platform display and valid
    //         for the entire program.
    let display =
      unsafe { Display::new(display_handle, preference) }.expect("failed to create display object");
    let template = ConfigTemplateBuilder::new().build();
    let display_clone = display.clone();
    // SAFETY: Unclear.
    let mut configs = unsafe { display_clone.find_configs(template) }
      .expect("failed to find OpenGL configurations");
    let config = configs
      .next()
      .expect("failed to find any OpenGL configuration");

    (display, config)
  }

  /// Create a new OpenGL context on the given window.
  fn new(display: &Display, config: &Config, window: &WinitWindow) -> Self {
    let window_handle = window
      .window_handle()
      .expect("failed to retrieve window handle");
    let raw_window_handle = window_handle.into();
    let size = window.inner_size();
    let phys_w = NonZeroU32::new(size.width).expect("window has no width");
    let phys_h = NonZeroU32::new(size.height).expect("window has no height");

    let (major, minor, _suffix) = sys::version();
    let context_attributes = ContextAttributesBuilder::new()
      .with_context_api(ContextApi::OpenGl(Some(Version::new(major, minor))))
      .with_profile(GlProfile::Core)
      .build(Some(raw_window_handle));
    let attrs =
      SurfaceAttributesBuilder::<WindowSurface>::default().build(raw_window_handle, phys_w, phys_h);
    // SAFETY: Unclear.
    let surface = unsafe { display.create_window_surface(config, &attrs) }
      .expect("failed to create window surface");
    // SAFETY: Unclear.
    let context = unsafe { display.create_context(config, &context_attributes) }
      .expect("failed to create context")
      .make_current(&surface)
      .expect("failed to make context current");

    Self {
      _surface: surface,
      _context: context,
    }
  }
}


/// A window with a proper graphics context.
#[derive(Debug)]
struct Window {
  /// The underlying `winit` window.
  _window: WinitWindow,
  /// The OpenGL context associated with the window.
  _context: Context,
}

impl Window {
  /// Create a new window.
  #[expect(deprecated)]
  fn new(event_loop: &EventLoop<()>) -> Self {
    let display_handle = event_loop.display_handle().unwrap();
    let (display, config) = Context::create_display_and_config(display_handle.into());
    let mut attributes = WinitWindow::default_attributes();
    attributes.visible = false;
    let window = event_loop
      .create_window(attributes)
      .expect("failed to create window");
    let context = Context::new(&display, &config, &window);

    Self {
      _window: window,
      _context: context,
    }
  }
}


/// A test helper to run a function with an OpenGL window (and context)
/// present.
///
/// # Notes
/// You most likely want to use this function in a separate process,
/// because of the effectively global OpenGL state.
pub(crate) fn with_opengl_context<F>(f: F)
where
  F: FnOnce(),
{
  let event_loop = EventLoop::builder().with_any_thread(true).build().unwrap();
  let _window = Window::new(&event_loop);

  f()
}