feat: add optional fullscreen support for desktop platforms

Add fullscreen parameter to initWindow() so apps can launch in fullscreen mode.
Implement toggleFullscreen() on Linux (EWMH) and Windows (borderless fullscreen),
which were previously empty stubs. macOS already worked and now supports initial
fullscreen at launch.

Author: proggeramlug

README.md

@@ -93,6 +93,25 @@ interface Sound { handle: number }
 interface Model { handle: number }
 ```
 
+## Fullscreen
+
+Launch your game in fullscreen by passing `true` as the fourth argument to `initWindow`:
+
+```typescript
+initWindow(800, 450, "My Game", true);   // launches fullscreen
+initWindow(800, 450, "My Game");         // windowed (default)
+```
+
+Toggle fullscreen at runtime:
+
+```typescript
+if (isKeyPressed(Key.F11)) {
+  toggleFullscreen();
+}
+```
+
+Fullscreen is supported on macOS (native AppKit fullscreen), Windows (borderless fullscreen), and Linux (EWMH/X11). The width and height you pass are used as the windowed dimensions when exiting fullscreen.
+
 ## Skeletal Animation
 
 Bloom supports GPU-accelerated skeletal animation via glTF/GLB models. The pipeline uses 4-bone linear blend skinning with a 128-joint uniform buffer, running entirely on the GPU.

native/android/src/lib.rs

@@ -86,7 +86,7 @@ fn pollster_block_on<F: std::future::Future>(future: F) -> F::Output {
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8, _fullscreen: f64) {
     let _title = str_from_header(title_ptr);
 
     unsafe {

native/ios/src/lib.rs

@@ -509,7 +509,7 @@ fn pollster_block_on<F: std::future::Future>(future: F) -> F::Output {
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(_width: f64, _height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(_width: f64, _height: f64, title_ptr: *const u8, _fullscreen: f64) {
     let _title = str_from_header(title_ptr);
 
     // Register ObjC classes for the scene delegate (window/view creation)

native/linux/src/lib.rs

@@ -65,6 +65,51 @@ mod x11_impl {
 
     static mut DISPLAY: *mut x11::xlib::Display = std::ptr::null_mut();
     static mut X11_WINDOW: x11::xlib::Window = 0;
+    static mut IS_FULLSCREEN: bool = false;
+
+    pub fn set_fullscreen(fullscreen: bool) {
+        unsafe {
+            if DISPLAY.is_null() || X11_WINDOW == 0 { return; }
+
+            let wm_state = x11::xlib::XInternAtom(
+                DISPLAY,
+                b"_NET_WM_STATE\0".as_ptr() as *const _,
+                0,
+            );
+            let wm_fullscreen = x11::xlib::XInternAtom(
+                DISPLAY,
+                b"_NET_WM_STATE_FULLSCREEN\0".as_ptr() as *const _,
+                0,
+            );
+
+            let action = if fullscreen { 1 } else { 0 }; // _NET_WM_STATE_ADD / _REMOVE
+
+            let mut event: x11::xlib::XClientMessageEvent = std::mem::zeroed();
+            event.type_ = x11::xlib::ClientMessage;
+            event.window = X11_WINDOW;
+            event.message_type = wm_state;
+            event.format = 32;
+            event.data.set_long(0, action);
+            event.data.set_long(1, wm_fullscreen as i64);
+            event.data.set_long(2, 0);
+            event.data.set_long(3, 1); // source: normal application
+
+            let root = x11::xlib::XDefaultRootWindow(DISPLAY);
+            x11::xlib::XSendEvent(
+                DISPLAY,
+                root,
+                0,
+                x11::xlib::SubstructureRedirectMask | x11::xlib::SubstructureNotifyMask,
+                &mut event as *mut x11::xlib::XClientMessageEvent as *mut x11::xlib::XEvent,
+            );
+            x11::xlib::XFlush(DISPLAY);
+            IS_FULLSCREEN = fullscreen;
+        }
+    }
+
+    pub fn toggle_fullscreen() {
+        unsafe { set_fullscreen(!IS_FULLSCREEN); }
+    }
 
     pub fn create_window(width: f64, height: f64, title: &str) {
         unsafe {
@@ -171,7 +216,7 @@ mod x11_impl {
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8, fullscreen: f64) {
     let title = str_from_header(title_ptr);
 
     #[cfg(target_os = "linux")]
@@ -224,6 +269,10 @@ pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u
 
         let renderer = Renderer::new(device, queue, surface, surface_config);
         unsafe { let _ = ENGINE.set(EngineState::new(renderer)); }
+
+        if fullscreen != 0.0 {
+            x11_impl::set_fullscreen(true);
+        }
     }
 
     #[cfg(not(target_os = "linux"))]
@@ -857,7 +906,10 @@ pub extern "C" fn bloom_set_directional_light(dx: f64, dy: f64, dz: f64, r: f64,
 // --- Utility FFI ---
 
 #[no_mangle]
-pub extern "C" fn bloom_toggle_fullscreen() {}
+pub extern "C" fn bloom_toggle_fullscreen() {
+    #[cfg(target_os = "linux")]
+    x11_impl::toggle_fullscreen();
+}
 #[no_mangle]
 pub extern "C" fn bloom_set_window_title(title_ptr: *const u8) { let _ = str_from_header(title_ptr); }
 #[no_mangle]

native/macos/src/lib.rs

@@ -235,7 +235,7 @@ unsafe extern "C" fn audio_render_callback(
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8, fullscreen: f64) {
     let title = str_from_header(title_ptr);
     let mtm = MainThreadMarker::from(unsafe { MainThreadMarker::new_unchecked() });
 
@@ -331,6 +331,10 @@ pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u
 
     // Register Bloom's GPU screenshot capture with perry-geisterhand (if linked)
     bloom_register_geisterhand_screenshot();
+
+    if fullscreen != 0.0 {
+        bloom_toggle_fullscreen();
+    }
 }
 
 #[no_mangle]

native/tvos/src/lib.rs

@@ -1267,7 +1267,7 @@ fn setup_game_controllers() {
 // ============================================================
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(_width: f64, _height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(_width: f64, _height: f64, title_ptr: *const u8, _fullscreen: f64) {
     let _title = str_from_header(title_ptr);
 
     // Register ObjC classes for the scene delegate (window/view creation)

native/windows/src/lib.rs

@@ -56,6 +56,53 @@ mod win32 {
     use raw_window_handle::{RawWindowHandle, Win32WindowHandle, RawDisplayHandle, WindowsDisplayHandle};
 
     static mut HWND_GLOBAL: Option<HWND> = None;
+    static mut IS_FULLSCREEN: bool = false;
+    static mut WINDOWED_STYLE: u32 = 0;
+    static mut WINDOWED_RECT: RECT = RECT { left: 0, top: 0, right: 0, bottom: 0 };
+
+    pub fn set_fullscreen(fullscreen: bool) {
+        unsafe {
+            let Some(hwnd) = HWND_GLOBAL else { return };
+
+            if fullscreen && !IS_FULLSCREEN {
+                // Save current style and window rect for restore
+                WINDOWED_STYLE = GetWindowLongW(hwnd, GWL_STYLE) as u32;
+                let _ = GetWindowRect(hwnd, &mut WINDOWED_RECT);
+
+                // Get monitor dimensions
+                let monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
+                let mut mi: MONITORINFO = std::mem::zeroed();
+                mi.cbSize = std::mem::size_of::<MONITORINFO>() as u32;
+                let _ = GetMonitorInfoW(monitor, &mut mi);
+
+                // Set borderless fullscreen
+                SetWindowLongW(hwnd, GWL_STYLE, (WS_POPUP | WS_VISIBLE).0 as i32);
+                let _ = SetWindowPos(
+                    hwnd, HWND_TOP,
+                    mi.rcMonitor.left, mi.rcMonitor.top,
+                    mi.rcMonitor.right - mi.rcMonitor.left,
+                    mi.rcMonitor.bottom - mi.rcMonitor.top,
+                    SWP_FRAMECHANGED | SWP_NOOWNERZORDER,
+                );
+                IS_FULLSCREEN = true;
+            } else if !fullscreen && IS_FULLSCREEN {
+                // Restore windowed mode
+                SetWindowLongW(hwnd, GWL_STYLE, WINDOWED_STYLE as i32);
+                let _ = SetWindowPos(
+                    hwnd, None,
+                    WINDOWED_RECT.left, WINDOWED_RECT.top,
+                    WINDOWED_RECT.right - WINDOWED_RECT.left,
+                    WINDOWED_RECT.bottom - WINDOWED_RECT.top,
+                    SWP_FRAMECHANGED | SWP_NOOWNERZORDER | SWP_NOZORDER,
+                );
+                IS_FULLSCREEN = false;
+            }
+        }
+    }
+
+    pub fn toggle_fullscreen() {
+        unsafe { set_fullscreen(!IS_FULLSCREEN); }
+    }
 
     unsafe extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
         match msg {
@@ -179,7 +226,7 @@ mod win32 {
 }
 
 #[no_mangle]
-pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8) {
+pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u8, fullscreen: f64) {
     let title = str_from_header(title_ptr);
 
     #[cfg(windows)]
@@ -231,6 +278,10 @@ pub extern "C" fn bloom_init_window(width: f64, height: f64, title_ptr: *const u
 
         let renderer = Renderer::new(device, queue, surface, surface_config);
         unsafe { let _ = ENGINE.set(EngineState::new(renderer)); }
+
+        if fullscreen != 0.0 {
+            win32::set_fullscreen(true);
+        }
     }
 
     #[cfg(not(windows))]
@@ -959,7 +1010,10 @@ pub extern "C" fn bloom_set_directional_light(dx: f64, dy: f64, dz: f64, r: f64,
 // --- Utility FFI ---
 
 #[no_mangle]
-pub extern "C" fn bloom_toggle_fullscreen() {}
+pub extern "C" fn bloom_toggle_fullscreen() {
+    #[cfg(windows)]
+    win32::toggle_fullscreen();
+}
 #[no_mangle]
 pub extern "C" fn bloom_set_window_title(title_ptr: *const u8) { let _ = str_from_header(title_ptr); }
 #[no_mangle]

package.json

@@ -21,7 +21,7 @@
     "nativeLibrary": {
       "module": "bloom",
       "functions": [
-        { "name": "bloom_init_window",              "params": ["f64", "f64", "i64"],                                     "returns": "void" },
+        { "name": "bloom_init_window",              "params": ["f64", "f64", "i64", "f64"],                              "returns": "void" },
         { "name": "bloom_close_window",             "params": [],                                                        "returns": "void" },
         { "name": "bloom_window_should_close",      "params": [],                                                        "returns": "f64"  },
         { "name": "bloom_begin_drawing",            "params": [],                                                        "returns": "void" },

src/core/index.ts

@@ -6,7 +6,7 @@ export { ColorConstants as Color } from './colors';
 export { Key, MouseButton } from './keys';
 
 // FFI declarations
-declare function bloom_init_window(width: number, height: number, title: number): void;
+declare function bloom_init_window(width: number, height: number, title: number, fullscreen: number): void;
 declare function bloom_close_window(): void;
 declare function bloom_window_should_close(): number;
 declare function bloom_begin_drawing(): void;
@@ -69,8 +69,8 @@ declare function bloom_read_file(path: number): number;
 
 // Window management
 
-export function initWindow(width: number, height: number, title: string): void {
-  bloom_init_window(width, height, title as any);
+export function initWindow(width: number, height: number, title: string, fullscreen: boolean = false): void {
+  bloom_init_window(width, height, title as any, fullscreen ? 1.0 : 0.0);
 }
 
 export function closeWindow(): void {