window_wayland.c File Reference

#include "linux_internal.h"
#include "core/sbgl_platform.h"
#include "core/sbl_arena.h"
#include <string.h>
#include <time.h>
#include <poll.h>

Include dependency graph for window_wayland.c:

Go to the source code of this file.

Macros
#define	_POSIX_C_SOURCE   199309L

Functions
static void	wm_base_ping (void *data, struct xdg_wm_base *wm_base, uint32_t serial)
static void	registry_handle_global (void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version)
static void	toplevel_handle_configure (void *data, struct xdg_toplevel *t, int32_t w, int32_t h, struct wl_array *s)
static void	toplevel_handle_close (void *data, struct xdg_toplevel *t)
static void	xdg_surface_handle_configure (void *data, struct xdg_surface *surf, uint32_t serial)
static void	locked_pointer_locked (void *data, struct zwp_locked_pointer_v1 *locked_pointer)
static void	locked_pointer_unlocked (void *data, struct zwp_locked_pointer_v1 *locked_pointer)
sbgl_platform_Result	sbgl_os_CreateWindow (struct SblArena *arena, sbgl_InputState *input, int width, int height, const char *title, sbgl_Window **outWindow)
	Creates a native OS window.
void	sbgl_os_PollEvents (sbgl_Window *window)
	Dispatches OS events (messages/protocol requests).
bool	sbgl_os_WindowShouldClose (sbgl_Window *window)
	Checks the window's close flag.
void	sbgl_os_GetWindowSize (sbgl_Window *window, int *w, int *h)
	Retrieves the current client area size.
bool	sbgl_os_WasWindowResized (sbgl_Window *window)
	Checks if the window has been resized since the last check.
bool	sbgl_os_IsWindowFocused (sbgl_Window *window)
	Checks if the window currently has input focus.
void	sbgl_os_SetCursorVisible (sbgl_Window *window, bool visible)
	Sets the visibility of the OS cursor for the given window.
void	sbgl_os_SetCursorLocked (sbgl_Window *window, bool locked)
	Locks or unlocks the cursor within the window bounds.
uint64_t	sbgl_os_GetPerfCount (sbgl_Window *window)
	Gets the high-resolution performance counter.
uint64_t	sbgl_os_GetPerfFreq (sbgl_Window *window)
	Gets the performance counter frequency.
void *	sbgl_os_GetNativeWindowHandle (sbgl_Window *window)
	Retrieves the raw window handle for Vulkan surface creation.
void *	sbgl_os_GetNativeDisplayHandle (sbgl_Window *window)
	Retrieves the native display handle (Linux specific).
void	sbgl_os_DestroyWindow (sbgl_Window *window)
	Destroys a native window.

Variables
static const struct xdg_wm_base_listener	wm_base_listener = { .ping = wm_base_ping }
static const struct wl_registry_listener	registry_listener = { .global = registry_handle_global }
static const struct xdg_toplevel_listener	toplevel_listener = { .configure = toplevel_handle_configure, .close = toplevel_handle_close }
static const struct xdg_surface_listener	xdg_surface_listener = { .configure = xdg_surface_handle_configure }
static const struct zwp_locked_pointer_v1_listener	locked_pointer_listener = { .locked = locked_pointer_locked, .unlocked = locked_pointer_unlocked }
const struct zwp_relative_pointer_v1_listener	relative_pointer_listener

Macro Definition Documentation

_POSIX_C_SOURCE

#define _POSIX_C_SOURCE   199309L

Definition at line 1 of file window_wayland.c.

Function Documentation

locked_pointer_locked()

static void locked_pointer_locked ( void * data, struct zwp_locked_pointer_v1 * locked_pointer )

static

Definition at line 63 of file window_wayland.c.

{ (void)data; (void)locked_pointer; }

locked_pointer_unlocked()

static void locked_pointer_unlocked ( void * data, struct zwp_locked_pointer_v1 * locked_pointer )

static

Definition at line 64 of file window_wayland.c.

{ (void)data; (void)locked_pointer; }

registry_handle_global()

static void registry_handle_global ( void * data, struct wl_registry * registry, uint32_t name, const char * interface, uint32_t version )

static

Definition at line 18 of file window_wayland.c.

                                                                                                                                     {
    (void)version;
    sbgl_Window* window = (sbgl_Window*)data;
    if (strcmp(interface, wl_compositor_interface.name) == 0) {
        window->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 1);
    } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
        window->wm_base = wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
        xdg_wm_base_add_listener(window->wm_base, &wm_base_listener, NULL);
    } else if (strcmp(interface, wl_seat_interface.name) == 0) {
        linux_init_input(registry, name, 1, window);
    } else if (strcmp(interface, zwp_pointer_constraints_v1_interface.name) == 0) {
        window->pointer_constraints = wl_registry_bind(registry, name, &zwp_pointer_constraints_v1_interface, 1);
    } else if (strcmp(interface, zwp_relative_pointer_manager_v1_interface.name) == 0) {
        window->relative_pointer_manager = wl_registry_bind(registry, name, &zwp_relative_pointer_manager_v1_interface, 1);
    }
}

sbgl_os_CreateWindow()

sbgl_platform_Result sbgl_os_CreateWindow	(	struct SblArena *	arena,
		sbgl_InputState *	input,
		int	width,
		int	height,
		const char *	title,
		sbgl_Window **	outWindow )

Creates a native OS window.

Parameters

arena	Arena to allocate the window state from.
input	Pointer to input state.
width	Initial width.
height	Initial height.
title	Window title.
outWindow	Pointer to store the created window.

Returns

Platform result code.

Definition at line 68 of file window_wayland.c.

                                                                                                                                                             {
    if (!outWindow) {
        return SBGL_PLATFORM_ERROR_INIT_FAILED;
    }
    *outWindow = NULL;
 
    if (!arena) {
        return SBGL_PLATFORM_ERROR_INIT_FAILED;
    }
 
    sbgl_Window* window = SBL_ARENA_PUSH_STRUCT_ZERO(arena, sbgl_Window);
    if (!window) return SBGL_PLATFORM_ERROR_INIT_FAILED;
 
    window->width = width; window->height = height;
    window->shouldClose = false;
    window->resized = false;
    window->focused = false;
    window->cursor_visible = true;
    window->input = input;
 
    window->display = wl_display_connect(NULL);
    if (!window->display) return SBGL_PLATFORM_ERROR_NO_DISPLAY;
 
    struct wl_registry* reg = wl_display_get_registry(window->display);
    wl_registry_add_listener(reg, &registry_listener, window);
    wl_display_roundtrip(window->display);
 
    window->surface = wl_compositor_create_surface(window->compositor);
    if (!window->surface) return SBGL_PLATFORM_ERROR_WINDOW_FAILED;
 
    window->xdg_surface = xdg_wm_base_get_xdg_surface(window->wm_base, window->surface);
    if (!window->xdg_surface) return SBGL_PLATFORM_ERROR_WINDOW_FAILED;
 
    xdg_surface_add_listener(window->xdg_surface, &xdg_surface_listener, window);
    window->xdg_toplevel = xdg_surface_get_toplevel(window->xdg_surface);
    if (!window->xdg_toplevel) return SBGL_PLATFORM_ERROR_WINDOW_FAILED;
 
    xdg_toplevel_add_listener(window->xdg_toplevel, &toplevel_listener, window);
    xdg_toplevel_set_title(window->xdg_toplevel, title);
 
    if (window->seat) {
        struct wl_keyboard* k = wl_seat_get_keyboard(window->seat);
        if (k) wl_keyboard_add_listener(k, &keyboard_listener, window);
        struct wl_pointer* p = wl_seat_get_pointer(window->seat);
        if (p) wl_pointer_add_listener(p, &pointer_listener, window);
    }
 
    wl_surface_commit(window->surface);
    wl_display_roundtrip(window->display);
 
    *outWindow = window;
    return SBGL_PLATFORM_SUCCESS;
}

sbgl_os_DestroyWindow()

void sbgl_os_DestroyWindow

(

sbgl_Window *

window

)

Destroys a native window.

Parameters

window

The window to destroy.

Definition at line 205 of file window_wayland.c.

                                                { 
    if (!window) return;
    if (window->relative_pointer) zwp_relative_pointer_v1_destroy(window->relative_pointer);
    if (window->locked_pointer) zwp_locked_pointer_v1_destroy(window->locked_pointer);
    if (window->relative_pointer_manager) zwp_relative_pointer_manager_v1_destroy(window->relative_pointer_manager);
    if (window->pointer_constraints) zwp_pointer_constraints_v1_destroy(window->pointer_constraints);
    xdg_toplevel_destroy(window->xdg_toplevel); 
    xdg_surface_destroy(window->xdg_surface); 
    wl_surface_destroy(window->surface); 
    wl_display_disconnect(window->display);
}

sbgl_os_GetNativeDisplayHandle()

void * sbgl_os_GetNativeDisplayHandle

(

sbgl_Window *

window

)

Retrieves the native display handle (Linux specific).

Parameters

window

The window handle.

Returns

Display* or wl_display*.

Definition at line 204 of file window_wayland.c.

{ return (void*)window->display; }

sbgl_os_GetNativeWindowHandle()

void * sbgl_os_GetNativeWindowHandle

(

sbgl_Window *

window

)

Retrieves the raw window handle for Vulkan surface creation.

Parameters

window

The window handle.

Returns

Native handle (e.g., HWND or wl_surface*).

Definition at line 203 of file window_wayland.c.

{ return (void*)window->surface; }

sbgl_os_GetPerfCount()

uint64_t sbgl_os_GetPerfCount

(

sbgl_Window *

window

)

Gets the high-resolution performance counter.

Parameters

window

The window handle.

Returns

Absolute ticks.

Definition at line 201 of file window_wayland.c.

{ (void)window; struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (uint64_t)ts.tv_sec * 1000000000ULL + ts.tv_nsec; }

sbgl_os_GetPerfFreq()

uint64_t sbgl_os_GetPerfFreq

(

sbgl_Window *

window

)

Gets the performance counter frequency.

Parameters

window

The window handle.

Returns

Ticks per second.

Definition at line 202 of file window_wayland.c.

{ (void)window; return 1000000000ULL; }

sbgl_os_GetWindowSize()

void sbgl_os_GetWindowSize	(	sbgl_Window *	window,
		int *	w,
		int *	h )

Retrieves the current client area size.

Parameters

window	The window handle.
w	Pointer to store width.
h	Pointer to store height.

Definition at line 150 of file window_wayland.c.

{ *w = window->width; *h = window->height; }

sbgl_os_IsWindowFocused()

bool sbgl_os_IsWindowFocused

(

sbgl_Window *

window

)

Checks if the window currently has input focus.

Parameters

window

The native window handle.

Returns

True if focused.

Definition at line 158 of file window_wayland.c.

{ return window->focused; }

sbgl_os_PollEvents()

void sbgl_os_PollEvents

(

sbgl_Window *

window

)

Dispatches OS events (messages/protocol requests).

Parameters

window

The window to process events for.

Definition at line 122 of file window_wayland.c.

                                             {
    if (!window) return;
    
    // Clear deltas if relative pointer is active to allow accumulation in listeners
    if (window->relative_pointer && window->input) {
        window->input->mouseDeltaX = 0;
        window->input->mouseDeltaY = 0;
    }
 
    /* The system ensures that pending events are dispatched and new events are read 
       from the display in a non-blocking manner to prevent main loop stalls. */
    while (wl_display_prepare_read(window->display) != 0) {
        wl_display_dispatch_pending(window->display);
    }
    wl_display_flush(window->display);
 
    struct pollfd pfd = { .fd = wl_display_get_fd(window->display), .events = POLLIN };
    if (poll(&pfd, 1, 0) > 0) {
        wl_display_read_events(window->display);
    } else {
        wl_display_cancel_read(window->display);
    }
 
    wl_display_dispatch_pending(window->display);
    linux_internal_update_input_states(window);
}

sbgl_os_SetCursorLocked()

void sbgl_os_SetCursorLocked	(	sbgl_Window *	window,
		bool	locked )

Locks or unlocks the cursor within the window bounds.

When locked, the cursor is typically constrained to the window center to support relative motion for 3D navigation.

Parameters

window	The native window handle.
locked	True to capture the cursor, false to release it.

Definition at line 175 of file window_wayland.c.

                                                               {
    if (!window || !window->seat || !window->pointer_constraints) return;
    struct wl_pointer* pointer = wl_seat_get_pointer(window->seat);
    if (!pointer) return;
 
    if (locked && !window->locked_pointer) {
        window->locked_pointer = zwp_pointer_constraints_v1_lock_pointer(
            window->pointer_constraints, window->surface, pointer, NULL,
            ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_PERSISTENT);
        zwp_locked_pointer_v1_add_listener(window->locked_pointer, &locked_pointer_listener, window);
 
        if (window->relative_pointer_manager) {
            window->relative_pointer = zwp_relative_pointer_manager_v1_get_relative_pointer(
                window->relative_pointer_manager, pointer);
            zwp_relative_pointer_v1_add_listener(window->relative_pointer, &relative_pointer_listener, window);
        }
    } else if (!locked && window->locked_pointer) {
        zwp_locked_pointer_v1_destroy(window->locked_pointer);
        window->locked_pointer = NULL;
        if (window->relative_pointer) {
            zwp_relative_pointer_v1_destroy(window->relative_pointer);
            window->relative_pointer = NULL;
        }
    }
}

sbgl_os_SetCursorVisible()

void sbgl_os_SetCursorVisible	(	sbgl_Window *	window,
		bool	visible )

Sets the visibility of the OS cursor for the given window.

Provides a platform-agnostic way to show or hide the mouse pointer.

Parameters

window	The native window handle.
visible	True to show the cursor, false to hide it.

Definition at line 160 of file window_wayland.c.

                                                                 {
    if (!window) return;
    window->cursor_visible = visible;
    
    if (!visible && window->seat) {
        struct wl_pointer* pointer = wl_seat_get_pointer(window->seat);
        if (pointer) {
            // Setting the cursor surface to NULL hides the cursor for this surface.
            wl_pointer_set_cursor(pointer, window->pointer_serial, NULL, 0, 0);
        }
    }
}

sbgl_os_WasWindowResized()

bool sbgl_os_WasWindowResized

(

sbgl_Window *

window

)

Checks if the window has been resized since the last check.

Resets the internal resize flag to false upon returning.

Parameters

window

The window handle.

Returns

True if a resize event occurred.

Definition at line 152 of file window_wayland.c.

                                                   {
    bool r = window->resized;
    window->resized = false;
    return r;
}

sbgl_os_WindowShouldClose()

bool sbgl_os_WindowShouldClose

(

sbgl_Window *

window

)

Checks the window's close flag.

Parameters

window

The window to check.

Returns

True if closing.

Definition at line 149 of file window_wayland.c.

{ return window->shouldClose; }

toplevel_handle_close()

static void toplevel_handle_close ( void * data, struct xdg_toplevel * t )

static

Definition at line 48 of file window_wayland.c.

                                                                      {
    /* (void) cast safely suppresses unused parameter warnings for mandatory signatures */
    (void)t;
    ((sbgl_Window*)data)->shouldClose = true;
}

toplevel_handle_configure()

static void toplevel_handle_configure ( void * data, struct xdg_toplevel * t, int32_t w, int32_t h, struct wl_array * s )

static

Definition at line 37 of file window_wayland.c.

                                                                                                                    {
    /* (void) cast safely suppresses unused parameter warnings for mandatory signatures */
    (void)t;
    (void)s;
    sbgl_Window* win = (sbgl_Window*)data;
    if (w > 0 && h > 0 && (w != win->width || h != win->height)) {
        win->width = w;
        win->height = h;
        win->resized = true;
    }
}

wm_base_ping()

static void wm_base_ping ( void * data, struct xdg_wm_base * wm_base, uint32_t serial )

static

Definition at line 11 of file window_wayland.c.

                                                                                   {
    (void)data;
    xdg_wm_base_pong(wm_base, serial);
}

xdg_surface_handle_configure()

static void xdg_surface_handle_configure ( void * data, struct xdg_surface * surf, uint32_t serial )

static

Definition at line 55 of file window_wayland.c.

                                                                                                {
    /* (void) cast safely suppresses unused parameter warnings for mandatory signatures */
    (void)data;
    xdg_surface_ack_configure(surf, serial);
}

Variable Documentation

locked_pointer_listener

const struct zwp_locked_pointer_v1_listener locked_pointer_listener = { .locked = locked_pointer_locked, .unlocked = locked_pointer_unlocked }

static

Definition at line 65 of file window_wayland.c.

{ .locked = locked_pointer_locked, .unlocked = locked_pointer_unlocked };

registry_listener

const struct wl_registry_listener registry_listener = { .global = registry_handle_global }

static

Definition at line 34 of file window_wayland.c.

{ .global = registry_handle_global };

relative_pointer_listener

const struct zwp_relative_pointer_v1_listener relative_pointer_listener

extern

Definition at line 118 of file input_wayland.c.

                                                                          {
    .relative_motion = relative_motion
};

toplevel_listener

const struct xdg_toplevel_listener toplevel_listener = { .configure = toplevel_handle_configure, .close = toplevel_handle_close }

static

Definition at line 53 of file window_wayland.c.

{ .configure = toplevel_handle_configure, .close = toplevel_handle_close };

wm_base_listener

const struct xdg_wm_base_listener wm_base_listener = { .ping = wm_base_ping }

static

Definition at line 15 of file window_wayland.c.

{ .ping = wm_base_ping };

xdg_surface_listener

const struct xdg_surface_listener xdg_surface_listener = { .configure = xdg_surface_handle_configure }

static

Definition at line 60 of file window_wayland.c.

{ .configure = xdg_surface_handle_configure };