✅ Back to a functional state, and initial winit setup added.

+8 -8

devenv.lock

··· 3 3 "devenv": { 4 4 "locked": { 5 5 "dir": "src/modules", 6 - "lastModified": 1746423062, 6 + "lastModified": 1752456450, 7 7 "owner": "cachix", 8 8 "repo": "devenv", 9 - "rev": "aba5cf8412827fdb637fceb2c305d10fcea907c6", 9 + "rev": "e2a9d0dd4cf87a1801c6d9e0d7a57bdd6de26ace", 10 10 "type": "github" 11 11 }, 12 12 "original": { ··· 19 19 "flake-compat": { 20 20 "flake": false, 21 21 "locked": { 22 - "lastModified": 1733328505, 22 + "lastModified": 1747046372, 23 23 "owner": "edolstra", 24 24 "repo": "flake-compat", 25 - "rev": "ff81ac966bb2cae68946d5ed5fc4994f96d0ffec", 25 + "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885", 26 26 "type": "github" 27 27 }, 28 28 "original": { ··· 40 40 ] 41 41 }, 42 42 "locked": { 43 - "lastModified": 1742649964, 43 + "lastModified": 1750779888, 44 44 "owner": "cachix", 45 45 "repo": "git-hooks.nix", 46 - "rev": "dcf5072734cb576d2b0c59b2ac44f5050b5eac82", 46 + "rev": "16ec914f6fb6f599ce988427d9d94efddf25fe6d", 47 47 "type": "github" 48 48 }, 49 49 "original": { ··· 74 74 }, 75 75 "nixpkgs": { 76 76 "locked": { 77 - "lastModified": 1747327360, 77 + "lastModified": 1751984180, 78 78 "owner": "NixOS", 79 79 "repo": "nixpkgs", 80 - "rev": "e06158e58f3adee28b139e9c2bcfcc41f8625b46", 80 + "rev": "9807714d6944a957c2e036f84b0ff8caf9930bc0", 81 81 "type": "github" 82 82 }, 83 83 "original": {

+20 -1

devenv.nix

··· 1 1 { pkgs, ... }: 2 2 3 + let 4 + 5 + libPath = 6 + with pkgs; 7 + lib.makeLibraryPath [ 8 + wayland 9 + udev 10 + seatd 11 + libinput 12 + pixman 13 + libxkbcommon 14 + libgbm 15 + libGL 16 + ]; 17 + 18 + in 3 19 { 4 20 packages = with pkgs; [ 21 + wayland 5 22 udev 6 23 seatd 7 - 8 24 libinput 9 25 pixman 10 26 libxkbcommon 11 27 libgbm 28 + libGL 12 29 ]; 30 + 31 + env.LD_LIBRARY_PATH = libPath; 13 32 14 33 enterShell = '' 15 34 git --version

+2 -2

src/handlers/compositor_handler.rs

··· 1 1 use crate::state::yon_client_data::YonClientData; 2 - use crate::state::yon_state::YonState; 2 + use crate::state::yon_state::{Backend, YonState}; 3 3 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface; 4 4 use smithay::reexports::wayland_server::{Client, Resource}; 5 5 use smithay::wayland::compositor::{CompositorClientState, CompositorHandler, CompositorState}; 6 6 7 - impl CompositorHandler for YonState { 7 + impl<BackendData: Backend + 'static> CompositorHandler for YonState<BackendData> { 8 8 fn compositor_state(&mut self) -> &mut CompositorState { 9 9 &mut self.compositor_state 10 10 }

+2 -2

src/handlers/output_handler.rs

··· 1 - use crate::state::yon_state::YonState; 1 + use crate::state::yon_state::{Backend, YonState}; 2 2 use smithay::output::Output; 3 3 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput; 4 4 use smithay::wayland::output::OutputHandler; 5 5 6 - impl OutputHandler for YonState { 6 + impl<BackendData: Backend + 'static> OutputHandler for YonState<BackendData> { 7 7 fn output_bound(&mut self, output: Output, _wl_output: WlOutput) { 8 8 log::info!("A client has bound to an output {:?}", output.name()); 9 9 }

+3 -3

src/handlers/seat_handler.rs

··· 1 - use crate::state::yon_state::YonState; 1 + use crate::state::yon_state::{Backend, YonState}; 2 2 use smithay::input::{SeatHandler, SeatState}; 3 3 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface; 4 - 4 + #[allow(dead_code)] 5 5 pub struct YonSeatData {} 6 6 7 - impl SeatHandler for YonState { 7 + impl<BackendData: Backend + 'static> SeatHandler for YonState<BackendData> { 8 8 type KeyboardFocus = WlSurface; 9 9 type PointerFocus = WlSurface; 10 10 type TouchFocus = WlSurface;

+2 -2

src/handlers/xdg_shell_handler.rs

··· 1 - use crate::state::yon_state::YonState; 1 + use crate::state::yon_state::{Backend, YonState}; 2 2 use smithay::desktop::Window; 3 3 use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat; 4 4 use smithay::utils::{Logical, Point, Serial}; ··· 6 6 PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState, 7 7 }; 8 8 9 - impl XdgShellHandler for YonState { 9 + impl<BackendData: Backend + 'static> XdgShellHandler for YonState<BackendData> { 10 10 fn xdg_shell_state(&mut self) -> &mut XdgShellState { 11 11 &mut self.xdg_shell_state 12 12 }

+2 -1

src/main.rs

··· 2 2 mod runners; 3 3 mod state; 4 4 5 + use env_logger::{Builder, Env}; 5 6 use log::info; 6 7 use runners::winit_runner; 7 8 8 9 fn main() { 9 - env_logger::init(); 10 + Builder::from_env(Env::default().default_filter_or("info")).init(); 10 11 info!("Starting compositor..."); 11 12 12 13 winit_runner::run();

+67 -45

src/runners/winit_runner.rs

··· 1 1 use crate::state::yon_client_data::YonClientData; 2 - use crate::state::yon_state::YonState; 2 + use crate::state::yon_state::{Backend, YonState}; 3 + use log::info; 4 + use smithay::backend::renderer::gles::GlesRenderer; 5 + use smithay::backend::winit::{self, WinitGraphicsBackend}; 3 6 use smithay::output; 4 7 use smithay::output::{Output, PhysicalProperties, Subpixel}; 5 8 use smithay::reexports::calloop::generic::Generic; 6 9 use smithay::reexports::calloop::{EventLoop, Interest, LoopHandle, Mode, PostAction}; 7 10 use smithay::reexports::wayland_server::Display; 8 11 use smithay::wayland::socket::ListeningSocketSource; 9 - use std::cell::RefCell; 10 12 use std::os::unix::net::UnixStream; 11 - use std::rc::Rc; 12 13 use std::sync::Arc; 13 14 use std::sync::atomic::Ordering; 14 15 use std::time::Duration; 15 16 17 + pub struct WinitSate { 18 + renderer: WinitGraphicsBackend<GlesRenderer>, 19 + } 20 + impl Backend for WinitSate {} 21 + 16 22 pub fn run() { 17 - let mut event_loop: EventLoop<YonState> = EventLoop::try_new().unwrap_or_else(|err| { 18 - log::error!("Failed to initialize event loop because: {}", err); 23 + // Creating the wayland display object 24 + let display: Display<YonState<WinitSate>> = Display::new().unwrap_or_else(|err| { 25 + log::error!("Failed to initialize display because: {err:?}"); 19 26 panic!() 20 27 }); 21 28 22 - let display: Display<YonState> = Display::new().unwrap_or_else(|err| { 23 - log::error!("Failed to initialize display because: {:?}", err); 24 - panic!() 25 - }); 29 + // Starting the wayland event loop 30 + let mut event_loop: EventLoop<YonState<WinitSate>> = 31 + EventLoop::try_new().unwrap_or_else(|err| { 32 + log::error!("Failed to initialize event loop because: {err}"); 33 + panic!() 34 + }); 26 35 27 - let mut display_handle = display.handle().clone(); 28 - let yon_state = Rc::new(RefCell::new(YonState::new(display_handle.clone()))); 29 - let event_loop_handle: LoopHandle<YonState> = event_loop.handle(); 36 + // Initializing the winit renderer and loop 37 + let (backend, mut winit_loop) = match winit::init::<GlesRenderer>() { 38 + Ok(value) => value, 39 + Err(err) => { 40 + panic!("\n{err:?}\n") 41 + } 42 + }; 43 + 44 + let data = WinitSate { renderer: backend }; 45 + 46 + // Initializing the YonState 47 + let mut yon_state = YonState::<WinitSate>::new(display.handle(), data); 30 48 49 + let mut display_handle = display.handle(); 50 + let event_loop_handle: LoopHandle<YonState<WinitSate>> = event_loop.handle(); 51 + 52 + // Setting up an output 31 53 let output = Output::new( 32 54 "yon-output".to_string(), 33 55 PhysicalProperties { ··· 38 60 }, 39 61 ); 40 62 41 - // let mode = output::Mode { 42 - // size: yon_state 43 - // .borrow() 44 - // .render_state 45 - // .backend 46 - // .as_ref() 47 - // .unwrap() 48 - // .window_size(), 49 - // refresh: 60_000, 50 - // }; 63 + let mode = output::Mode { 64 + size: yon_state.backend_state.renderer.window_size(), 65 + refresh: 60_000, 66 + }; 51 67 52 - // output.create_global::<YonState>(&display_handle); 53 - // output.change_current_state(Some(mode), None, None, Some((0, 0).into())); 54 - // output.set_preferred(mode); 68 + output.create_global::<YonState<WinitSate>>(&display_handle); 69 + output.change_current_state(Some(mode), None, None, Some((0, 0).into())); 70 + output.set_preferred(mode); 55 71 72 + // source for dispatching clients 56 73 let display_source = Generic::new(display, Interest::READ, Mode::Level); 74 + 75 + // source for inserting new clients 57 76 let wayland_socket_source = 58 77 ListeningSocketSource::with_name("yon-test").unwrap_or_else(|err| { 59 - log::error!("Failed to initialize socket because: {:?}", err); 78 + log::error!("Failed to initialize socket because: {err:?}"); 60 79 panic!() 61 80 }); 62 81 82 + // Add wayland socket source for inserting new clients 63 83 event_loop_handle 64 84 .insert_source( 65 85 wayland_socket_source, 66 - |_client_stream: UnixStream, _, _yon_state: &mut YonState| { 86 + |_client_stream: UnixStream, _, _yon_state: &mut YonState<WinitSate>| { 67 87 if let Err(err) = _yon_state 68 88 .display_handle 69 89 .insert_client(_client_stream, Arc::new(YonClientData::new())) 70 90 { 71 - log::error!("Failed to insert client. Reason: {:?}", err); 91 + log::error!("Failed to insert client. Reason: {err:?}"); 72 92 } 73 93 }, 74 94 ) 75 95 .unwrap_or_else(|err| { 76 - log::error!( 77 - "Failed to insert wayland_socket_source into event loop because: {:?}", 78 - err 79 - ); 96 + log::error!("Failed to insert wayland_socket_source into event loop because: {err:?}"); 80 97 panic!() 81 98 }); 82 99 100 + // Add the smithay display as source for dispatching new clients 83 101 event_loop_handle 84 102 .insert_source( 85 103 display_source, 86 - |_, display, _yon_state: &mut YonState| unsafe { 87 - if let Err(err) = display.get_mut().dispatch_clients(_yon_state) { 88 - log::error!("Failed to dispatch client because: {:?}", err); 104 + |_, _display, _yon_state: &mut YonState<WinitSate>| unsafe { 105 + if let Err(err) = _display.get_mut().dispatch_clients(_yon_state) { 106 + log::error!("Failed to dispatch clients because: {err:?}"); 89 107 } 90 108 Ok(PostAction::Continue) 91 109 }, 92 110 ) 93 111 .unwrap_or_else(|err| { 94 - log::error!( 95 - "Failed to insert display_source into event loop because: {:?}", 96 - err 97 - ); 112 + log::error!("Failed to insert display_source into event loop because: {err:?}"); 98 113 panic!() 99 114 }); 100 115 101 - while yon_state.borrow_mut().running.load(Ordering::SeqCst) { 102 - if let Err(err) = 103 - event_loop.dispatch(Some(Duration::from_millis(1)), &mut yon_state.borrow_mut()) 104 - { 105 - log::error!("Failed to dispatch event because: {:?}", err); 116 + // Main compositor loop 117 + while yon_state.running.load(Ordering::SeqCst) { 118 + winit_loop.dispatch_new_events(|winit_event| match winit_event { 119 + winit::WinitEvent::Resized { size, scale_factor } => info!("Resizing winit"), 120 + winit::WinitEvent::Focus(_) => info!("Focusing winit"), 121 + winit::WinitEvent::Input(input_event) => info!("Inputing winit"), 122 + winit::WinitEvent::CloseRequested => info!("Close requesting winit"), 123 + winit::WinitEvent::Redraw => info!("Redrawing winit"), 124 + }); 125 + 126 + if let Err(err) = event_loop.dispatch(Some(Duration::from_millis(1)), &mut yon_state) { 127 + log::error!("Failed to dispatch event because: {err:?}"); 106 128 break; 107 129 } 108 130 109 131 if let Err(err) = display_handle.flush_clients() { 110 - log::error!("Failed to flush clients because: {:?}", err); 132 + log::error!("Failed to flush clients because: {err:?}"); 111 133 } 112 134 } 113 135 }

+2 -6

src/state/yon_client_data.rs

··· 15 15 16 16 impl ClientData for YonClientData { 17 17 fn initialized(&self, _client_id: ClientId) { 18 - log::info!("Initializing YonClient: {:?}", _client_id); 18 + log::info!("Initializing YonClient: {_client_id:?}"); 19 19 } 20 20 21 21 fn disconnected(&self, _client_id: ClientId, _reason: DisconnectReason) { 22 - log::info!( 23 - "YonClient: {:?} disconnected. Because: {:?}", 24 - _client_id, 25 - _reason 26 - ); 22 + log::info!("YonClient: {_client_id:?} disconnected. Because: {_reason:?}"); 27 23 } 28 24 }

+22 -22

src/state/yon_state.rs

··· 11 11 }; 12 12 use std::sync::atomic::AtomicBool; 13 13 14 - delegate_compositor!(YonState); 15 - delegate_xdg_shell!(YonState); 16 - delegate_seat!(YonState); 17 - delegate_output!(YonState); 18 - pub struct YonState { 14 + delegate_compositor!(@<BackendData: Backend + 'static> YonState<BackendData>); 15 + delegate_xdg_shell!(@<BackendData: Backend + 'static> YonState<BackendData>); 16 + delegate_seat!(@<BackendData: Backend + 'static> YonState<BackendData>); 17 + delegate_output!(@<BackendData: Backend + 'static> YonState<BackendData>); 18 + #[allow(dead_code)] 19 + pub struct YonState<BackendData: Backend + 'static> { 19 20 pub running: AtomicBool, 20 21 pub display_handle: DisplayHandle, 21 22 pub compositor_state: CompositorState, 22 23 pub xdg_shell_state: XdgShellState, 23 24 24 - pub seat_state: SeatState<YonState>, 25 - pub seat: Seat<YonState>, 26 - pub keyboard_handle: Option<KeyboardHandle<YonState>>, 27 - pub pointer_handle: PointerHandle<YonState>, 25 + pub seat_state: SeatState<YonState<BackendData>>, 26 + pub seat: Seat<YonState<BackendData>>, 27 + pub keyboard_handle: Option<KeyboardHandle<YonState<BackendData>>>, 28 + pub pointer_handle: PointerHandle<YonState<BackendData>>, 28 29 29 30 pub output_manager_state: OutputManagerState, 30 31 31 32 pub compositor_space: Space<Window>, 32 - // pub render_state: RenderState, 33 + pub backend_state: BackendData, 33 34 } 34 35 35 - impl YonState { 36 - pub fn new(display_handle: DisplayHandle) -> Self { 36 + pub trait Backend {} 37 + 38 + impl<BackendData: Backend + 'static> YonState<BackendData> { 39 + pub fn new(display_handle: DisplayHandle, backend_state: BackendData) -> Self { 37 40 let running: AtomicBool = AtomicBool::new(true); 38 - let compositor_state = CompositorState::new::<YonState>(&display_handle); 39 - let xdg_shell_state = XdgShellState::new::<YonState>(&display_handle); 41 + let compositor_state = CompositorState::new::<YonState<BackendData>>(&display_handle); 42 + let xdg_shell_state = XdgShellState::new::<YonState<BackendData>>(&display_handle); 40 43 let mut seat_state = SeatState::new(); 41 44 let mut seat = seat_state.new_wl_seat(&display_handle, "yon-seat"); 42 45 let output_manager_state = OutputManagerState::new(); 43 46 44 - let keyboard_handle: Option<KeyboardHandle<YonState>> = 47 + let keyboard_handle: Option<KeyboardHandle<YonState<BackendData>>> = 45 48 match seat.add_keyboard(Default::default(), 200, 25) { 46 49 Ok(kb_handle) => Some(kb_handle), 47 50 Err(err) => { 48 - log::error!("Failed to add keyboard because : {:?}", err); 51 + log::error!("Failed to add keyboard because : {err:?}"); 49 52 None 50 53 } 51 54 }; 52 - let pointer_handle: PointerHandle<YonState> = seat.add_pointer(); 53 - 55 + let pointer_handle: PointerHandle<YonState<BackendData>> = seat.add_pointer(); 56 + 54 57 let compositor_space: Space<Window> = Space::default(); 55 - // let render_state = RenderState::new(); 56 - 57 - 58 58 59 59 Self { 60 60 running, ··· 67 67 pointer_handle, 68 68 output_manager_state, 69 69 compositor_space, 70 - // render_state, 70 + backend_state, 71 71 } 72 72 } 73 73 }

Configure Feed

Configure Feed