Function bloom_init_window

native/linux/src/lib.rs:493–618

(width: f64, height: f64, title_ptr: *const u8, fullscreen: f64)

#[no_mangle]
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")]
    {
        // Headless mode: BLOOM_HEADLESS=1 keeps the X11 window + Vulkan
        // surface alive (wgpu requires a real surface) but never maps
        // the window so it's invisible and never steals focus. Lets an
        // agent spin up the renderer in a batch loop without disturbing
        // the user's desktop.
        let headless = std::env::var("BLOOM_HEADLESS")
            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
            .unwrap_or(false);
        // BLOOM_NO_FULLSCREEN=1 hard-disables fullscreen capability for
        // benchmark harnesses where a 4K-display fullscreen path would
        // silently quadruple render cost.
        let no_fullscreen = std::env::var("BLOOM_NO_FULLSCREEN")
            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
            .unwrap_or(false);
        x11_impl::set_no_fullscreen(no_fullscreen);

        let (phys_w, phys_h) = x11_impl::create_window(width, height, title, headless);

        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
            backends: wgpu::Backends::VULKAN | wgpu::Backends::GL,
            ..wgpu::InstanceDescriptor::new_without_display_handle()
        });

        let surface = unsafe {
            let raw_window = raw_window_handle::RawWindowHandle::Xlib(
                raw_window_handle::XlibWindowHandle::new(x11_impl::window())
            );
            let raw_display = raw_window_handle::RawDisplayHandle::Xlib(
                raw_window_handle::XlibDisplayHandle::new(
                    std::ptr::NonNull::new(x11_impl::display() as *mut _),
                    0,
                )
            );
            instance.create_surface_unsafe(wgpu::SurfaceTargetUnsafe::RawHandle {
                raw_display_handle: Some(raw_display),
                raw_window_handle: raw_window,
            }).expect("Failed to create surface")
        };

        let adapter = pollster_block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
            compatible_surface: Some(&surface),
            ..Default::default()
        })).expect("No adapter found");

        // Ticket 007b: HW ray-query via VK_KHR_ray_query on RT-capable
        // desktop Linux GPUs. Older integrated GPUs will fall back to
        // the SW path through this gate.
        let supported = adapter.features();
        let force_sw_gi = std::env::var("BLOOM_FORCE_SW_GI")
            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
            .unwrap_or(false);
        let rt_mask = wgpu::Features::EXPERIMENTAL_RAY_QUERY;
        let mut required_features = wgpu::Features::empty();