agentmux_launcher/

splash.rs

// Copyright 2025-2026, AgentMux Corp.
// SPDX-License-Identifier: Apache-2.0

//! Native pre-splash for Windows: a borderless layered popup showing
//! the AgentMux brain logo (pulsing) on a solid dark background while
//! CefInitialize runs (200–600 ms cold start).
//!
//! `spawn_splash(dir_hash)` is called right after the single-instance
//! pipe is claimed — before srv spawn, before CEF init (~10 ms into
//! the launcher process). The returned event name is passed to the
//! CEF host as `AGENTMUX_SPLASH_EVENT`; the host signals it from
//! `on_load_end` to trigger a smooth fade-out.
//!
//! ## Layout & animation
//!
//! ```
//! ┌─ SPLASH_SIZE × SPLASH_SIZE ─┐
//! │ solid BG_COLOR              │
//! │   ┌─ BRAIN_W × BRAIN_H ─┐   │
//! │   │ brain glyph        │   │   ← pulsing alpha 160..220
//! │   │ (transparent png)  │   │
//! │   └────────────────────┘   │
//! │                            │
//! └────────────────────────────┘
//! ```
//!
//! The background is fully opaque and never changes. ONLY the brain
//! glyph's alpha pulses (sine wave, 1.1 Hz). Painted via
//! `UpdateLayeredWindow` + a pre-multiplied 32-bpp DIB section, so
//! per-pixel transparency works correctly (the previous
//! `SetLayeredWindowAttributes(LWA_ALPHA)` pulsed the whole window
//! together, which made the background appear to breathe too — see
//! `docs/retros/2026-05-13-splash-icon-and-pulse-target.md`).

#![cfg(target_os = "windows")]

use std::thread;
use windows_sys::Win32::Foundation::*;
use windows_sys::Win32::Graphics::Gdi::*;
use windows_sys::Win32::System::LibraryLoader::GetModuleHandleW;
use windows_sys::Win32::System::Threading::*;
use windows_sys::Win32::UI::WindowsAndMessaging::*;

// Brain bitmap dimensions, generated by build.rs from the actual
// `resources/brain.png` so swapping the asset can't desync the
// renderer. Provides `BRAIN_W` / `BRAIN_H` as `i32` consts.
include!(concat!(env!("OUT_DIR"), "/brain_dims.rs"));

// Splash window is the brain bitmap plus a 12px BG border on each side.
const SPLASH_PADDING: i32 = 12;
const SPLASH_SIZE: i32 = BRAIN_W + SPLASH_PADDING * 2;
const BRAIN_X: i32 = SPLASH_PADDING;
const BRAIN_Y: i32 = SPLASH_PADDING;

// Background color (B, G, R) — dark app background. Stored as
// channels rather than a packed COLORREF because the compositor
// reads them per-pixel.
const BG_B: u8 = 0x1F;
const BG_G: u8 = 0x1A;
const BG_R: u8 = 0x1A;

// Brain pixels — pre-multiplied BGRA bytes generated by build.rs from
// `resources/brain.png`. Length = BRAIN_W * BRAIN_H * 4.
static BRAIN_BGRA: &[u8] =
    include_bytes!(concat!(env!("OUT_DIR"), "/brain_bgra.bin"));

// HANDLE is a raw pointer; wrap it to cross the thread boundary safely.
// Use `.take()` (not `.0`) inside move closures: Rust 2021 precise
// capture would otherwise capture the field `*mut c_void` directly,
// bypassing the `Send` impl.
struct SendHandle(HANDLE);
unsafe impl Send for SendHandle {}
impl SendHandle {
    fn take(self) -> HANDLE { self.0 }
}

/// Spawn the pre-splash thread and return the named Win32 event name
/// to pass to the CEF host as `AGENTMUX_SPLASH_EVENT`.
/// Returns `None` if OS calls fail (non-fatal — launcher continues).
pub fn spawn_splash(dir_hash: &str) -> Option<String> {
    let event_name = format!("AgentMuxSplash-{}", dir_hash);
    let nul_name: Vec<u16> = format!("{}\0", event_name)
        .encode_utf16()
        .collect();

    let ev = unsafe {
        CreateEventW(
            std::ptr::null(), // default security
            1,                // manual-reset
            0,                // not signaled
            nul_name.as_ptr(),
        )
    };
    if ev.is_null() {
        crate::log("splash: CreateEventW failed — skipping splash");
        return None;
    }

    let handle = SendHandle(ev);
    thread::spawn(move || unsafe { run_splash(handle.take()) });
    Some(event_name)
}

unsafe fn run_splash(dismiss_ev: HANDLE) {
    let class: Vec<u16> = "AgentMuxSplash\0".encode_utf16().collect();
    let hinst = GetModuleHandleW(std::ptr::null());

    let wc = WNDCLASSEXW {
        cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
        style: 0,
        lpfnWndProc: Some(DefWindowProcW),
        cbClsExtra: 0,
        cbWndExtra: 0,
        hInstance: hinst,
        hIcon: std::ptr::null_mut(),
        hCursor: std::ptr::null_mut(),
        hbrBackground: std::ptr::null_mut(),
        lpszMenuName: std::ptr::null(),
        lpszClassName: class.as_ptr(),
        hIconSm: std::ptr::null_mut(),
    };
    // Silently tolerate ERROR_CLASS_ALREADY_EXISTS in dev hot-reload.
    RegisterClassExW(&wc);

    let sw = GetSystemMetrics(SM_CXSCREEN);
    let sh = GetSystemMetrics(SM_CYSCREEN);
    let x = (sw - SPLASH_SIZE) / 2;
    let y = (sh - SPLASH_SIZE) / 2;

    let hwnd = CreateWindowExW(
        WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
        class.as_ptr(),
        std::ptr::null(),     // no title
        WS_POPUP,
        x, y, SPLASH_SIZE, SPLASH_SIZE,
        std::ptr::null_mut(), // no parent
        std::ptr::null_mut(), // no menu
        hinst,
        std::ptr::null(),     // no CREATESTRUCT data
    );
    if hwnd.is_null() {
        CloseHandle(dismiss_ev);
        return;
    }

    // Build the 32-bpp top-down DIB section we composite into each
    // frame. UpdateLayeredWindow takes the DIB's HBITMAP via a memory
    // DC, so we need a paired CompatibleDC + DIB section that lives
    // for the splash's whole lifetime.
    let screen_dc = GetDC(std::ptr::null_mut());
    let mem_dc = CreateCompatibleDC(screen_dc);
    let mut bmi: BITMAPINFO = std::mem::zeroed();
    bmi.bmiHeader.biSize = std::mem::size_of::<BITMAPINFOHEADER>() as u32;
    bmi.bmiHeader.biWidth = SPLASH_SIZE;
    // Negative height = top-down rows (matches our pixel layout).
    bmi.bmiHeader.biHeight = -SPLASH_SIZE;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB as u32;

    let mut dib_pixels_raw: *mut core::ffi::c_void = std::ptr::null_mut();
    let dib = CreateDIBSection(
        mem_dc,
        &bmi,
        DIB_RGB_COLORS,
        &mut dib_pixels_raw,
        std::ptr::null_mut(),
        0,
    );
    if dib.is_null() || dib_pixels_raw.is_null() {
        ReleaseDC(std::ptr::null_mut(), screen_dc);
        DeleteDC(mem_dc);
        DestroyWindow(hwnd);
        CloseHandle(dismiss_ev);
        return;
    }
    let old_obj = SelectObject(mem_dc, dib as _);

    let dib_pixels = std::slice::from_raw_parts_mut(
        dib_pixels_raw as *mut u8,
        (SPLASH_SIZE * SPLASH_SIZE * 4) as usize,
    );

    ShowWindow(hwnd, SW_SHOWNOACTIVATE);

    let start = std::time::Instant::now();

    // Animation: brain alpha 0→220 over the first 200 ms, then sine
    // pulse 160..220 at 1.1 Hz. Background stays opaque throughout.
    loop {
        // Non-blocking dismiss check — fires when on_load_end signals.
        if WaitForSingleObject(dismiss_ev, 0) == WAIT_OBJECT_0 {
            fade_out(hwnd, mem_dc, dib_pixels);
            break;
        }

        let t = start.elapsed().as_secs_f32();
        let brain_alpha: u8 = if t < 0.2 {
            (t / 0.2 * 220.0) as u8
        } else {
            let pulse = (((t - 0.2) * std::f32::consts::TAU * 1.1).sin() + 1.0) * 0.5;
            (160.0 + pulse * 60.0) as u8
        };

        composite(dib_pixels, brain_alpha);
        push_layered(hwnd, mem_dc, 255);

        std::thread::sleep(std::time::Duration::from_millis(16)); // ~60 fps
    }

    SelectObject(mem_dc, old_obj);
    DeleteObject(dib as _);
    DeleteDC(mem_dc);
    ReleaseDC(std::ptr::null_mut(), screen_dc);
    DestroyWindow(hwnd);
    CloseHandle(dismiss_ev);
}

/// Compose one frame into the DIB: solid BG fill, then the brain
/// blended on top at `brain_alpha`.
///
/// Brain bytes are pre-multiplied BGRA (alpha already baked into
/// RGB by build.rs). Modulating by `brain_alpha / 255` keeps them
/// pre-multiplied for `UpdateLayeredWindow`'s AC_SRC_ALPHA blend.
fn composite(dib: &mut [u8], brain_alpha: u8) {
    // Fast path: fill with opaque BG. Loop unrolled by the compiler.
    for px in dib.chunks_exact_mut(4) {
        px[0] = BG_B;
        px[1] = BG_G;
        px[2] = BG_R;
        px[3] = 0xFF;
    }

    // Composite the brain in the centered region. For each brain
    // pixel: scale by brain_alpha/255 (still pre-multiplied), then
    // standard premultiplied OVER onto the BG.
    let ba = brain_alpha as u16;
    for y in 0..BRAIN_H {
        let dib_row = ((BRAIN_Y + y) * SPLASH_SIZE * 4) as usize;
        let src_row = (y * BRAIN_W * 4) as usize;
        for x in 0..BRAIN_W {
            let di = dib_row + ((BRAIN_X + x) * 4) as usize;
            let si = src_row + (x * 4) as usize;
            let sb = BRAIN_BGRA[si] as u16;
            let sg = BRAIN_BGRA[si + 1] as u16;
            let sr = BRAIN_BGRA[si + 2] as u16;
            let sa = BRAIN_BGRA[si + 3] as u16;
            if sa == 0 {
                continue;
            }
            // Modulate pre-multiplied source by brain_alpha.
            let mb = (sb * ba + 127) / 255;
            let mg = (sg * ba + 127) / 255;
            let mr = (sr * ba + 127) / 255;
            let ma = (sa * ba + 127) / 255;
            // OVER: out = src + dst * (1 - src.a). dst.a stays 255.
            let inv = 255u16 - ma;
            let bb = (dib[di] as u16) * inv / 255 + mb;
            let bg = (dib[di + 1] as u16) * inv / 255 + mg;
            let br = (dib[di + 2] as u16) * inv / 255 + mr;
            dib[di] = bb.min(255) as u8;
            dib[di + 1] = bg.min(255) as u8;
            dib[di + 2] = br.min(255) as u8;
            // dib[di+3] left at 255 — window stays opaque.
        }
    }
}

unsafe fn push_layered(hwnd: HWND, mem_dc: HDC, source_alpha: u8) {
    let mut sz = SIZE {
        cx: SPLASH_SIZE,
        cy: SPLASH_SIZE,
    };
    let mut src_pt = POINT { x: 0, y: 0 };
    let blend = BLENDFUNCTION {
        BlendOp: AC_SRC_OVER as u8,
        BlendFlags: 0,
        SourceConstantAlpha: source_alpha,
        AlphaFormat: AC_SRC_ALPHA as u8,
    };
    UpdateLayeredWindow(
        hwnd,
        std::ptr::null_mut(),
        std::ptr::null(),
        &mut sz,
        mem_dc,
        &mut src_pt,
        0,
        &blend,
        ULW_ALPHA,
    );
}

/// Fade the splash window to transparent over ~160 ms then return.
/// Composite stays the same; only the layered-window constant alpha
/// ramps down, so the whole splash fades uniformly.
unsafe fn fade_out(hwnd: HWND, mem_dc: HDC, _dib: &mut [u8]) {
    let mut alpha: i32 = 255;
    while alpha > 0 {
        alpha -= 25;
        if alpha < 0 {
            alpha = 0;
        }
        push_layered(hwnd, mem_dc, alpha as u8);
        std::thread::sleep(std::time::Duration::from_millis(16));
    }
}