#![allow(non_snake_case)]
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering::*};
use std::sync::{Arc, Condvar, Mutex};
use core::cell::Cell;
use crate::event::*;
use crate::keysym;
use crate::scancode_win::to_evdev;
use crate::sys_win::*;
use crate::win_d3d::D3d;
use crate::{Backend_, D3dDriver, Options};
const FS: u64 = 1_000_000_000_000_000;
const RESIZE_TIMER: usize = 1;
const RESIZE_TIMER_MS: u32 = 8;
fn now_ns() -> u64 { (qpc() as u128 * 1_000_000_000u128 / qpf() as u128) as u64 }
struct Surface { memdc: HDC, bmp: HBITMAP, old: HANDLE, pixels: *mut u32, side: u32 }
impl Surface {
fn new(side: u32) -> Option<Surface> {
unsafe {
let mut bmi = BITMAPINFO::default();
bmi.bmiHeader.biSize = core::mem::size_of::<BITMAPINFOHEADER>() as u32;
bmi.bmiHeader.biWidth = side as i32;
bmi.bmiHeader.biHeight = -(side as i32);
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
let mut bits: *mut core::ffi::c_void = core::ptr::null_mut();
let bmp = CreateDIBSection(NULL, &bmi, DIB_RGB_COLORS, &mut bits, NULL, 0);
if bmp.is_null() || bits.is_null() { return None; }
let memdc = CreateCompatibleDC(NULL);
if memdc.is_null() { DeleteObject(bmp); return None; }
let old = SelectObject(memdc, bmp);
Some(Surface { memdc, bmp, old, pixels: bits as *mut u32, side })
}
}
}
impl Drop for Surface {
fn drop(&mut self) {
unsafe {
SelectObject(self.memdc, self.old);
DeleteDC(self.memdc);
DeleteObject(self.bmp);
}
}
}
unsafe impl Send for Surface {}
enum Present {
Gdi,
D3d(D3d),
}
pub struct Shared {
hwnd: AtomicUsize,
surf: Mutex<Option<Surface>>,
ready: Mutex<u8>, ready_cv: Condvar,
period_fs: AtomicU64,
dyn_: Arc<Dyn>,
dirty: AtomicBool,
quit_vblank: AtomicBool,
vblank_ev: AtomicUsize,
generation: AtomicU32,
}
unsafe impl Send for Shared {}
unsafe impl Sync for Shared {}
pub struct App {
sh: Arc<Shared>,
core: Arc<Core>,
side: u32,
generation: u64,
}
impl App {
pub fn get_framebuffer(&mut self) -> Option<(*mut u32, u32, u64)> {
let w = self.core.win_w.load(Relaxed);
let h = self.core.win_h.load(Relaxed);
let want = crate::next_pow2(w.max(h));
let mut g = self.sh.surf.lock().ok()?;
if want != self.side || g.is_none() {
*g = Surface::new(want);
g.as_ref()?;
self.side = want;
self.generation += 1;
self.sh.generation.store(self.generation as u32, Relaxed);
self.core.full_redraw.store(true, Relaxed);
}
let s = g.as_ref()?;
Some((s.pixels, s.side, self.generation << 2))
}
pub fn submit(&mut self) {
let hwnd = self.sh.hwnd.load(Relaxed) as HWND;
if hwnd.is_null() { return; }
self.sh.dirty.store(true, Release);
unsafe { PostMessageW(hwnd, WM_SOFTER_BLIT, 0, 0) };
}
pub fn poke(&self) {
let h = self.sh.hwnd.load(Relaxed) as HWND;
if !h.is_null() { unsafe { PostMessageW(h, WM_SOFTER_POKE, 0, 0); } }
}
}
impl Drop for App {
fn drop(&mut self) {
self.core.quit.store(true, Relaxed);
self.sh.quit_vblank.store(true, Relaxed);
self.poke();
}
}
#[derive(Clone, Copy, PartialEq, Debug)]
enum Vsync { Dwm, Kmt, Timer }
fn choose_vsync(d: &Dyn) -> Vsync {
unsafe {
if let (Some(flush), Some(enabled)) = (d.dwm_flush, d.dwm_enabled) {
let mut on: BOOL = 0;
if enabled(&mut on) >= 0 && on != 0 { let _ = flush; return Vsync::Dwm; }
}
if d.kmt_open.is_some() && d.kmt_wait.is_some() { return Vsync::Kmt; }
Vsync::Timer
}
}
fn vblank_thread(sh: Arc<Shared>, mode: Vsync) {
let d = sh.dyn_.clone();
let ev = sh.vblank_ev.load(Relaxed) as HANDLE;
let mut wait = D3DKMT_WAITFORVERTICALBLANKEVENT::default();
let mut kmt_ok = false;
if mode == Vsync::Kmt {
unsafe {
let dc = GetDC(NULL);
let mut open = D3DKMT_OPENADAPTERFROMHDC { hDc: dc as usize, ..Default::default() };
if let Some(f) = d.kmt_open {
if f(&mut open) >= 0 {
wait.hAdapter = open.hAdapter;
wait.VidPnSourceId = open.VidPnSourceId;
kmt_ok = true;
}
}
ReleaseDC(NULL, dc);
}
}
while !sh.quit_vblank.load(Relaxed) {
let t0 = qpc();
let period_ns = sh.period_fs.load(Relaxed) / 1_000_000;
match mode {
Vsync::Dwm => { if let Some(f) = d.dwm_flush { unsafe { f(); } } }
Vsync::Kmt if kmt_ok => { if let Some(f) = d.kmt_wait { unsafe { f(&wait); } } }
_ => unsafe { Sleep((period_ns / 1_000_000).max(1) as u32) },
}
let dt_ns = ((qpc() - t0) as u128 * 1_000_000_000u128 / qpf() as u128) as u64;
if dt_ns * 4 < period_ns { unsafe { Sleep(((period_ns - dt_ns * 4) / 1_000_000).max(1) as u32) } }
unsafe { SetEvent(ev); }
}
}
fn query_period_fs(d: &Dyn) -> u64 {
unsafe {
if let Some(f) = d.dwm_timing {
let mut t = DWM_TIMING_INFO::default();
if f(NULL, &mut t) >= 0 && t.rateRefresh_num != 0 && t.rateRefresh_den != 0 {
return FS * t.rateRefresh_den as u64 / t.rateRefresh_num as u64;
}
}
let mut dm = DEVMODEW::default();
dm.dmSize = core::mem::size_of::<DEVMODEW>() as u16;
if EnumDisplaySettingsW(core::ptr::null(), ENUM_CURRENT_SETTINGS, &mut dm) != 0 && dm.dmDisplayFrequency > 1 {
let hz = dm.dmDisplayFrequency as u64;
let (num, den) = match hz { 23 | 29 | 47 | 59 | 71 | 89 | 119 | 143 => ((hz + 1) * 1000, 1001), _ => (hz * 1000, 1000) };
return FS * den / num;
}
}
FS / 60
}
thread_local! {
static PUMP: Cell<*const Pump> = const { Cell::new(core::ptr::null()) };
}
struct Pump {
sh: Arc<Shared>,
core: Arc<Core>,
hwnd: Cell<HWND>,
dyn_: Arc<Dyn>,
cursor: HANDLE,
present: core::cell::RefCell<Present>,
wait_handle: Cell<HANDLE>,
cur_driver: Cell<D3dDriver>,
buttons: Cell<u32>,
last_refresh: Cell<u64>,
last_tick_ns: Cell<u64>,
wake_qpc: Cell<i64>,
hop_n: Cell<u32>, hop_sum: Cell<i64>, hop_max: Cell<i64>,
have_refresh: Cell<bool>,
in_size_move: Cell<bool>,
cursor_hidden: Cell<bool>,
fs_applied: Cell<bool>,
saved_rect: Cell<RECT>,
saved_style: Cell<isize>,
saved_ex: Cell<isize>,
icon_big: Cell<usize>,
icon_small: Cell<usize>,
debug: bool,
}
impl Pump {
fn text_for(&self, vk: u32, sc: u32, ext: bool) -> (String, bool) {
unsafe {
let mut state = [0u8; 256];
if GetKeyboardState(state.as_mut_ptr()) == 0 { return (String::new(), false); }
let hkl = GetKeyboardLayout(0);
let mut buf = [0u16; 8];
let n = ToUnicodeEx(vk, sc | if ext { 0x100 } else { 0 }, state.as_ptr(), buf.as_mut_ptr(), buf.len() as i32, 0, hkl);
if n < 0 { return (String::new(), true); } if n == 0 { return (String::new(), false); }
let s: String = char::decode_utf16(buf[..n as usize].iter().copied())
.filter_map(|c| c.ok())
.filter(|c| (*c as u32) >= 0x20 && *c as u32 != 0x7f)
.collect();
(s, false)
}
}
fn sym_for(&self, vk: u32) -> u32 {
let c = unsafe { MapVirtualKeyW(vk, MAPVK_VK_TO_CHAR) };
if c == 0 || c & 0x8000_0000 != 0 { return 0; }
char::from_u32(c & 0x7FFF_FFFF).and_then(keysym::from_char).unwrap_or(0)
}
fn key_down(&self, vk: u32, l: LPARAM) {
if l & 0x4000_0000 != 0 { return; }
let sc = ((l >> 16) & 0xFF) as u32;
let ext = (l >> 24) & 1 != 0;
let code = to_evdev(sc, ext, vk);
let ctrl = self.core.key_down(KEY_LEFTCTRL) || self.core.key_down(KEY_RIGHTCTRL);
let alt = self.core.key_down(KEY_LEFTALT) || self.core.key_down(KEY_RIGHTALT);
let want_text = (ctrl && alt) || (!ctrl && !alt);
let (text, dead) = if want_text { self.text_for(vk, sc, ext) } else { (String::new(), false) };
let sym = self.sym_for(vk);
self.core.set_dead_flag(dead);
self.core.key_press_sym(code, sym, &text, now_ns());
}
fn key_up(&self, vk: u32, l: LPARAM) {
let sc = ((l >> 16) & 0xFF) as u32;
let ext = (l >> 24) & 1 != 0;
self.core.key(to_evdev(sc, ext, vk), false);
}
fn refresh_repeat(&self) {
unsafe {
let mut delay_idx: u32 = 1;
let mut speed_idx: u32 = 31;
SystemParametersInfoW(SPI_GETKEYBOARDDELAY, 0, &mut delay_idx as *mut u32 as *mut _, 0);
SystemParametersInfoW(SPI_GETKEYBOARDSPEED, 0, &mut speed_idx as *mut u32 as *mut _, 0);
let delay_ms = 250 * (delay_idx.min(3) as u64 + 1);
let cps_x10 = 25 + (275 * speed_idx.min(31) as u64) / 31;
let interval_ms = (10_000 / cps_x10).max(1);
self.core.set_repeat(delay_ms, interval_ms);
if self.debug { eprintln!("softer_gui: repeat delay {delay_ms} ms interval {interval_ms} ms"); }
}
}
fn button(&self, code: u32, down: bool) {
let bit = 1u32 << (code & 31);
let mut held = self.buttons.get();
if down { held |= bit } else { held &= !bit }
self.buttons.set(held);
unsafe {
if down { SetCapture(self.hwnd.get()); } else if held == 0 { ReleaseCapture(); }
}
self.core.key(code, down);
}
fn motion(&self, l: LPARAM) {
let x = (l & 0xFFFF) as u16 as i16 as i64;
let y = ((l >> 16) & 0xFFFF) as u16 as i16 as i64;
self.core.pointer_abs(x << 32, y << 32);
}
fn dpi(&self) -> u32 {
unsafe {
if let Some(f) = self.dyn_.dpi_for_window {
let d = f(self.hwnd.get());
if d != 0 { return d; }
}
let dc = GetDC(self.hwnd.get());
if !dc.is_null() {
let d = GetDeviceCaps(dc, LOGPIXELSX);
ReleaseDC(self.hwnd.get(), dc);
if d > 0 { return d as u32; }
}
96
}
}
fn update_scale(&self) {
let fx = self.dpi() * 65536 / 96;
if fx != self.core.scale_fx.swap(fx, Relaxed) { self.core.full_redraw.store(true, Relaxed); }
}
fn update_size(&self) {
let mut r = RECT::default();
unsafe { GetClientRect(self.hwnd.get(), &mut r) };
let (w, h) = ((r.right - r.left).max(0) as u32, (r.bottom - r.top).max(0) as u32);
if w == 0 || h == 0 { return; }
if w != self.core.win_w.load(Relaxed) || h != self.core.win_h.load(Relaxed) {
self.core.win_w.store(w, Relaxed);
self.core.win_h.store(h, Relaxed);
self.core.full_redraw.store(true, Relaxed);
}
}
fn apply_cursor(&self) {
let want = self.core.cursor_hidden.load(Relaxed);
if want != self.cursor_hidden.get() {
self.cursor_hidden.set(want);
unsafe { SetCursor(if want { NULL } else { self.cursor }); }
}
}
fn apply_fullscreen(&self) {
let want = self.core.wants_fullscreen.load(Relaxed);
if want == self.fs_applied.get() { return; }
self.fs_applied.set(want);
let h = self.hwnd.get();
unsafe {
if want {
let mut r = RECT::default();
GetWindowRect(h, &mut r);
self.saved_rect.set(r);
self.saved_style.set(get_window_long(h, GWL_STYLE));
self.saved_ex.set(get_window_long(h, GWL_EXSTYLE));
let mut mi = MONITORINFO { cbSize: core::mem::size_of::<MONITORINFO>() as u32, ..Default::default() };
let mon = MonitorFromWindow(h, MONITOR_DEFAULTTONEAREST);
if GetMonitorInfoW(mon, &mut mi) == 0 { return; }
set_window_long(h, GWL_STYLE, (WS_POPUP | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS) as isize);
set_window_long(h, GWL_EXSTYLE, WS_EX_APPWINDOW as isize);
let m = mi.rcMonitor;
SetWindowPos(h, NULL, m.left, m.top, m.right - m.left, m.bottom - m.top, SWP_NOZORDER | SWP_FRAMECHANGED);
} else {
set_window_long(h, GWL_STYLE, self.saved_style.get());
set_window_long(h, GWL_EXSTYLE, self.saved_ex.get());
let r = self.saved_rect.get();
SetWindowPos(h, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOZORDER | SWP_FRAMECHANGED);
}
}
self.update_size();
}
fn make_icon(img: &crate::icon::OwnedIcon) -> HICON {
unsafe {
let side = img.side as i32;
let mut bmi = BITMAPINFO::default();
bmi.bmiHeader.biSize = core::mem::size_of::<BITMAPINFOHEADER>() as u32;
bmi.bmiHeader.biWidth = side;
bmi.bmiHeader.biHeight = -side; bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
let mut bits: *mut core::ffi::c_void = core::ptr::null_mut();
let color = CreateDIBSection(NULL, &bmi, DIB_RGB_COLORS, &mut bits, NULL, 0);
if color.is_null() || bits.is_null() { return NULL; }
core::ptr::copy_nonoverlapping(img.argb.as_ptr(), bits as *mut u32, img.argb.len());
let mask = CreateBitmap(side, side, 1, 1, core::ptr::null());
let info = ICONINFO { fIcon: 1, xHotspot: 0, yHotspot: 0, hbmMask: mask, hbmColor: color };
let icon = CreateIconIndirect(&info);
DeleteObject(color);
DeleteObject(mask);
icon
}
}
fn apply_icon(&self) {
let Some(set) = self.core.take_icon() else { return };
let h = self.hwnd.get();
unsafe {
let big = set.first().map(Self::make_icon).unwrap_or(NULL);
let small = set.last().map(Self::make_icon).unwrap_or(NULL);
SendMessageW(h, WM_SETICON, ICON_BIG, big as LPARAM);
SendMessageW(h, WM_SETICON, ICON_SMALL, small as LPARAM);
let (ob, os) = (self.icon_big.replace(big as usize), self.icon_small.replace(small as usize));
if ob != 0 { DestroyIcon(ob as HICON); }
if os != 0 { DestroyIcon(os as HICON); }
}
}
fn blit(&self) {
if !self.sh.dirty.load(Acquire) { return; }
let (w, h) = (self.core.win_w.load(Relaxed) as i32, self.core.win_h.load(Relaxed) as i32);
if w <= 0 || h <= 0 { return; }
let Ok(g) = self.sh.surf.try_lock() else {
unsafe { PostMessageW(self.hwnd.get(), WM_SOFTER_BLIT, 0, 0) };
return;
};
let Some(s) = g.as_ref() else { return };
self.sh.dirty.store(false, Release);
let wake = self.wake_qpc.get();
if wake != 0 {
let d = qpc() - wake;
self.wake_qpc.set(0);
if d > 0 {
let us = d * 1_000_000 / qpf();
self.hop_n.set(self.hop_n.get() + 1);
self.hop_sum.set(self.hop_sum.get() + us);
if us > self.hop_max.get() { self.hop_max.set(us); }
if self.debug && self.hop_n.get() % 64 == 0 {
eprintln!("softer_gui: wake->present n={} mean={}us max={}us",
self.hop_n.get(), self.hop_sum.get() / self.hop_n.get() as i64,
self.hop_max.get());
}
}
}
let Ok(mut pres) = self.present.try_borrow_mut() else { return };
match &mut *pres {
Present::D3d(d) => {
if !d.present(s.pixels as *const u32, s.side, w.min(s.side as i32) as u32, h.min(s.side as i32) as u32) {
if self.debug { eprintln!("softer_gui: d3d present failed, falling back to GDI"); }
*pres = Present::Gdi;
self.core.full_redraw.store(true, Relaxed);
}
}
Present::Gdi => unsafe {
let dc = GetDC(self.hwnd.get());
if dc.is_null() { return; }
BitBlt(dc, 0, 0, w.min(s.side as i32), h.min(s.side as i32), s.memdc, 0, 0, SRCCOPY);
GdiFlush();
ReleaseDC(self.hwnd.get(), dc);
}
}
}
fn cycle_presenter(&self) {
let Ok(mut pres) = self.present.try_borrow_mut() else { return };
let next: &[(bool, D3dDriver)] = if cfg!(cosmo) {
&[(false, D3dDriver::Auto), (true, D3dDriver::Warp)]
} else {
&[(false, D3dDriver::Auto), (true, D3dDriver::Hardware), (true, D3dDriver::Warp)]
};
let cur = match &*pres {
Present::Gdi => 0,
Present::D3d(_) => next.iter().position(|(d, drv)| *d && *drv == self.cur_driver.get()).unwrap_or(0),
};
*pres = Present::Gdi;
self.wait_handle.set(self.sh.vblank_ev.load(Relaxed) as HANDLE);
self.cur_driver.set(D3dDriver::Auto);
for step in 1..=next.len() {
let (want_d3d, drv) = next[(cur + step) % next.len()];
if !want_d3d {
if self.debug { eprintln!("softer_gui: presenter -> gdi"); }
break;
}
if let Some(d) = D3d::new(self.hwnd.get(), self.debug, drv) {
self.wait_handle.set(d.waitable);
*pres = Present::D3d(d);
self.cur_driver.set(drv);
if self.debug { eprintln!("softer_gui: presenter -> d3d11 {drv:?}"); }
break;
}
if self.debug { eprintln!("softer_gui: presenter d3d11 {drv:?} unavailable, skipping"); }
}
self.core.full_redraw.store(true, Relaxed);
self.sh.dirty.store(true, Release);
unsafe { PostMessageW(self.hwnd.get(), WM_SOFTER_BLIT, 0, 0) };
}
fn frame_tick(&self, gated: bool) {
let mut frames = 1u64;
let mut counted = false;
let mut d3d_frames: Option<u64> = None;
if let Ok(mut pres) = self.present.try_borrow_mut() {
if let Present::D3d(d) = &mut *pres {
let period_qpc = (self.sh.period_fs.load(Relaxed) as i128 * qpf() as i128 / 1_000_000_000_000_000i128) as i64;
d3d_frames = Some(d.frames_elapsed(period_qpc));
self.core.in_flight.store(d.in_flight, Relaxed);
if gated && d.occluded { return; }
}
}
if let Some(f) = self.dyn_.dwm_timing {
let mut t = DWM_TIMING_INFO::default();
if unsafe { f(NULL, &mut t) } >= 0 && t.cRefresh != 0 {
if t.rateRefresh_num != 0 && t.rateRefresh_den != 0 {
let p = FS * t.rateRefresh_den as u64 / t.rateRefresh_num as u64;
if p != self.sh.period_fs.load(Relaxed) {
self.sh.period_fs.store(p, Relaxed);
self.core.set_period_fs(p);
}
}
if self.have_refresh.get() {
frames = t.cRefresh.saturating_sub(self.last_refresh.get());
counted = true;
}
self.last_refresh.set(t.cRefresh);
self.have_refresh.set(true);
}
}
if counted {
if frames == 0 && gated { return; }
frames = frames.clamp(1, 8);
} else if let Some(n) = d3d_frames {
frames = n.clamp(1, 8);
} else if gated {
let now = now_ns();
let period_ns = self.sh.period_fs.load(Relaxed) / 1_000_000;
if now.saturating_sub(self.last_tick_ns.get()) < period_ns { return; }
}
self.last_tick_ns.set(now_ns());
self.core.display_tick(frames);
self.core.push_render();
}
fn message(&self, h: HWND, msg: u32, w: WPARAM, l: LPARAM) -> LRESULT {
match msg {
WM_ERASEBKGND => return 1, WM_PAINT => {
let mut ps = PAINTSTRUCT::default();
unsafe { BeginPaint(h, &mut ps) };
let (cw, ch) = (self.core.win_w.load(Relaxed) as i32, self.core.win_h.load(Relaxed) as i32);
if let Ok(g) = self.sh.surf.try_lock() {
if let Some(s) = g.as_ref() {
unsafe { BitBlt(ps.hdc, 0, 0, cw.min(s.side as i32), ch.min(s.side as i32), s.memdc, 0, 0, SRCCOPY); }
}
}
unsafe { EndPaint(h, &ps) };
return 0;
}
WM_SIZE => {
if w != SIZE_MINIMIZED {
self.update_size();
if let Ok(mut pres) = self.present.try_borrow_mut() {
if let Present::D3d(d) = &mut *pres {
d.resize(self.core.win_w.load(Relaxed), self.core.win_h.load(Relaxed));
}
}
if self.in_size_move.get() { self.frame_tick(true); self.blit(); }
}
return 0;
}
WM_ENTERSIZEMOVE => {
self.in_size_move.set(true);
unsafe { SetTimer(h, RESIZE_TIMER, RESIZE_TIMER_MS, core::ptr::null()) };
return 0;
}
WM_EXITSIZEMOVE => {
self.in_size_move.set(false);
unsafe { KillTimer(h, RESIZE_TIMER) };
self.update_size();
self.blit();
return 0;
}
WM_TIMER if w == RESIZE_TIMER => {
self.core.service_resync();
self.apply_cursor();
self.core.repeat_tick(now_ns());
self.frame_tick(true);
self.blit();
return 0;
}
WM_CLOSE => { self.core.push_close(); return 0; } WM_DESTROY => { self.core.quit.store(true, Relaxed); return 0; }
WM_SETFOCUS => { self.core.focused.store(true, Relaxed); return 0; }
WM_KILLFOCUS => {
self.core.focused.store(false, Relaxed);
self.core.release_all_keys(true);
return 0;
}
WM_ACTIVATEAPP => { self.core.focused.store(w != 0, Relaxed); return 0; }
WM_SETCURSOR => {
if (l & 0xFFFF) == 1 {
unsafe { SetCursor(if self.core.cursor_hidden.load(Relaxed) { NULL } else { self.cursor }) };
return 1;
}
}
WM_KEYDOWN | WM_SYSKEYDOWN => {
self.key_down(w as u32, l);
if msg == WM_KEYDOWN { return 0; }
}
WM_KEYUP | WM_SYSKEYUP => {
self.key_up(w as u32, l);
if msg == WM_KEYUP { return 0; }
}
WM_SYSCOMMAND => {
let sc = w & 0xFFF0;
if sc == SC_KEYMENU || sc == SC_SCREENSAVE || sc == SC_MONITORPOWER { return 0; }
}
WM_MOUSEMOVE => { self.motion(l); return 0; }
WM_LBUTTONDOWN => { self.button(BTN_LEFT, true); return 0; }
WM_LBUTTONUP => { self.button(BTN_LEFT, false); return 0; }
WM_RBUTTONDOWN => { self.button(BTN_RIGHT, true); return 0; }
WM_RBUTTONUP => { self.button(BTN_RIGHT, false); return 0; }
WM_MBUTTONDOWN => { self.button(BTN_MIDDLE, true); return 0; }
WM_MBUTTONUP => { self.button(BTN_MIDDLE, false); return 0; }
WM_XBUTTONDOWN | WM_XBUTTONUP => {
let code = if (w >> 16) & 0xFFFF == 1 { BTN_SIDE } else { BTN_EXTRA };
self.button(code, msg == WM_XBUTTONDOWN);
return 1;
}
WM_MOUSEWHEEL | WM_MOUSEHWHEEL => {
let delta = ((w >> 16) & 0xFFFF) as u16 as i16 as i32;
let delta = if msg == WM_MOUSEWHEEL { -delta } else { delta };
let vertical = msg == WM_MOUSEWHEEL;
let touch = match self.dyn_.msg_source {
Some(f) => {
let mut src = INPUT_MESSAGE_SOURCE { device_type: 0, origin_id: 0 };
let ok = unsafe { f(&mut src) } != 0;
ok && (src.device_type == IMDT_TOUCHPAD || src.device_type == IMDT_TOUCH)
}
None => delta % WHEEL_DELTA != 0,
};
if touch && vertical && (w as usize & MK_CONTROL) != 0 {
let dz = -(delta as i64) * 6554 / WHEEL_DELTA as i64;
if dz != 0 { self.core.push_axes(&[AxisDiff { axis: AXIS_ZOOM, delta: dz as i32 }]); }
} else if touch {
let axis = if vertical { AXIS_SCROLL_V } else { AXIS_SCROLL_H };
self.core.push_axes(&[AxisDiff { axis, delta: delta * (SCROLL_STEP / WHEEL_DELTA) }]);
} else {
let axis = if vertical { AXIS_WHEEL_V } else { AXIS_WHEEL_H };
self.core.push_axes(&[AxisDiff { axis, delta: delta * WHEEL_CLICK / WHEEL_DELTA }]);
}
return 0;
}
WM_DPICHANGED => {
self.update_scale();
let r = unsafe { &*(l as *const RECT) };
unsafe { SetWindowPos(h, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOZORDER | SWP_NOACTIVATE) };
return 0;
}
WM_DISPLAYCHANGE => {
let p = query_period_fs(&self.dyn_);
self.sh.period_fs.store(p, Relaxed);
self.core.set_period_fs(p);
self.have_refresh.set(false); return 0;
}
WM_SETTINGCHANGE => { self.refresh_repeat(); return 0; }
WM_SOFTER_BLIT => { self.blit(); return 0; }
WM_SOFTER_POKE => return 0,
_ => {}
}
unsafe { DefWindowProcW(h, msg, w, l) }
}
fn run(&self) {
PUMP.with(|c| c.set(self as *const Pump));
loop {
if self.core.quit.load(Relaxed) { break; }
self.core.service_resync();
let mut m = MSG::default();
while unsafe { PeekMessageW(&mut m, NULL, 0, 0, PM_REMOVE) } != 0 {
unsafe { DispatchMessageW(&m) };
if self.core.quit.load(Relaxed) { break; }
}
if self.core.quit.load(Relaxed) { break; }
if self.core.wants_cycle.swap(false, AcqRel) { self.cycle_presenter(); }
self.apply_cursor();
self.apply_fullscreen();
self.apply_icon();
let ms = self.core.repeat_tick(now_ns());
let vblank = self.wait_handle.get();
let r = unsafe { MsgWaitForMultipleObjectsEx(1, &vblank, ms as u32, QS_ALLINPUT, MWMO_INPUTAVAILABLE) };
if r == WAIT_OBJECT_0 {
self.wake_qpc.set(qpc());
self.frame_tick(false);
}
}
unsafe {
let b = self.icon_big.get(); if b != 0 { DestroyIcon(b as HICON); }
let s = self.icon_small.get(); if s != 0 { DestroyIcon(s as HICON); }
let h = self.hwnd.get();
if !h.is_null() { DestroyWindow(h); }
}
PUMP.with(|c| c.set(core::ptr::null()));
}
}
#[cfg(not(all(cosmo, target_arch = "x86_64")))]
unsafe extern "system" fn wndproc(h: HWND, msg: u32, w: WPARAM, l: LPARAM) -> LRESULT {
unsafe { wndproc_impl(h, msg, w, l) }
}
#[cfg(all(cosmo, target_arch = "x86_64"))]
unsafe extern "win64" fn wndproc(h: HWND, msg: u32, w: WPARAM, l: LPARAM) -> LRESULT {
unsafe { wndproc_impl(h, msg, w, l) }
}
unsafe fn wndproc_impl(h: HWND, msg: u32, w: WPARAM, l: LPARAM) -> LRESULT {
let p = PUMP.with(|c| c.get());
if p.is_null() { return unsafe { DefWindowProcW(h, msg, w, l) }; }
unsafe { (*p).message(h, msg, w, l) }
}
pub fn open(core: Arc<Core>, title: &str, app_id: &str, width: u32, height: u32, opts: Options) -> Option<App> {
let _ = app_id; set_dpi_aware();
let d = Arc::new(Dyn::load());
let period = query_period_fs(&d);
core.set_period_fs(period);
core.win_w.store(width, Relaxed);
core.win_h.store(height, Relaxed);
let vblank_ev = unsafe { CreateEventW(core::ptr::null_mut(), 0, 0, core::ptr::null()) };
if vblank_ev.is_null() { return None; }
let sh = Arc::new(Shared {
hwnd: AtomicUsize::new(0),
surf: Mutex::new(None),
ready: Mutex::new(0),
ready_cv: Condvar::new(),
period_fs: AtomicU64::new(period),
dyn_: d.clone(),
dirty: AtomicBool::new(false),
quit_vblank: AtomicBool::new(false),
vblank_ev: AtomicUsize::new(vblank_ev as usize),
generation: AtomicU32::new(0),
});
let title = title.to_string();
let sh2 = sh.clone();
let core2 = core.clone();
let core2b = core.clone();
std::thread::Builder::new().name("softer_gui-win-pump".into()).spawn(move || {
let dbg = opts.debug;
let ok = unsafe {
let inst = GetModuleHandleW(core::ptr::null());
let class = wide("softer_gui_window");
let cursor = LoadCursorW(NULL, IDC_ARROW);
let wc = WNDCLASSEXW {
cbSize: core::mem::size_of::<WNDCLASSEXW>() as u32,
style: CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS,
lpfnWndProc: Some(wndproc),
cbClsExtra: 0, cbWndExtra: 0,
hInstance: inst,
hIcon: NULL, hCursor: cursor, hbrBackground: NULL,
lpszMenuName: core::ptr::null(),
lpszClassName: class.as_ptr(),
hIconSm: NULL,
};
RegisterClassExW(&wc);
let style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
let mut r = RECT { left: 0, top: 0, right: width as i32, bottom: height as i32 };
AdjustWindowRectEx(&mut r, style, 0, 0);
let t = wide(&title);
let hwnd = CreateWindowExW(0, class.as_ptr(), t.as_ptr(), style,
i32::MIN, i32::MIN, r.right - r.left, r.bottom - r.top,
NULL, NULL, inst, core::ptr::null_mut());
if hwnd.is_null() { None } else { Some((hwnd, cursor)) }
};
let Some((hwnd, cursor)) = ok else {
*sh2.ready.lock().unwrap() = 2;
sh2.ready_cv.notify_all();
return;
};
sh2.hwnd.store(hwnd as usize, Relaxed);
let want = opts.backend;
let try_d3d = want != Backend_::Gdi;
let present = if !try_d3d { Present::Gdi } else {
match D3d::new(hwnd, dbg, opts.d3d_driver) {
Some(d) => Present::D3d(d),
None => {
if want == Backend_::D3d { eprintln!("softer_gui: d3d requested but unavailable; using GDI"); }
Present::Gdi
}
}
};
let use_d3d = matches!(present, Present::D3d(_));
let first_driver = if opts.d3d_driver == D3dDriver::Auto && !cfg!(cosmo) { D3dDriver::Hardware }
else if opts.d3d_driver == D3dDriver::Auto { D3dDriver::Warp }
else { opts.d3d_driver };
let wait_handle = match &present {
Present::D3d(d) => d.waitable,
Present::Gdi => sh2.vblank_ev.load(Relaxed) as HANDLE,
};
let pump = Pump {
sh: sh2.clone(), core: core2, hwnd: Cell::new(hwnd), dyn_: d.clone(),
cursor,
present: core::cell::RefCell::new(present),
wait_handle: Cell::new(wait_handle),
cur_driver: Cell::new(if use_d3d { first_driver } else { D3dDriver::Auto }),
buttons: Cell::new(0), last_refresh: Cell::new(0), last_tick_ns: Cell::new(0),
wake_qpc: Cell::new(0), hop_n: Cell::new(0), hop_sum: Cell::new(0), hop_max: Cell::new(0), have_refresh: Cell::new(false),
in_size_move: Cell::new(false), cursor_hidden: Cell::new(false), fs_applied: Cell::new(false),
saved_rect: Cell::new(RECT::default()), saved_style: Cell::new(0), saved_ex: Cell::new(0),
icon_big: Cell::new(0), icon_small: Cell::new(0),
debug: dbg,
};
if opts.fullscreen { core2b.wants_fullscreen.store(true, Relaxed); }
pump.refresh_repeat();
pump.update_scale();
unsafe { ShowWindow(hwnd, SW_SHOW); UpdateWindow(hwnd); }
pump.update_size();
let mode = choose_vsync(&d);
if dbg {
let which = if use_d3d { "d3d11 flip-model, waitable object" } else { "gdi" };
eprintln!("softer_gui: presenter {which}, vsync {:?}, period {} fs ({:.3} Hz)", mode, period, FS as f64 / period as f64);
}
let shv = sh2.clone();
let vb = std::thread::Builder::new().name("softer_gui-win-vblank".into()).spawn(move || vblank_thread(shv, mode)).ok();
*sh2.ready.lock().unwrap() = 1;
sh2.ready_cv.notify_all();
pump.run();
sh2.quit_vblank.store(true, Relaxed);
if let Some(vb) = vb { let _ = vb.join(); }
unsafe { CloseHandle(sh2.vblank_ev.load(Relaxed) as HANDLE); }
}).ok()?;
let mut g = sh.ready.lock().ok()?;
while *g == 0 { g = sh.ready_cv.wait(g).ok()?; }
if *g != 1 { return None; }
drop(g);
Some(App { sh, core, side: 0, generation: 0 })
}