@matjash/pixi-native-win32-x64 0.1.2

package/native/window/binding-path.js

@@ -0,0 +1,11 @@
+const Path = require("path");
+
+const getBindingPath = () =>
+  Path.join(
+    __dirname,
+    "dist",
+    `${process.platform}-${process.arch}`,
+    "native_window.node",
+  );
+
+module.exports = { getBindingPath };

package/native/window/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@pixi-native/native-window",
+  "version": "0.1.0",
+  "private": true,
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts"
+}

package/native/window/src/index.d.ts

@@ -0,0 +1,17 @@
+export interface NativeWindowApi {
+  setTransparent(nativeData: Uint8Array, transparent: boolean): void;
+  waitForCompositorFrame(timeoutMs?: number): Promise<boolean>;
+  create(
+    nativeData: Uint8Array,
+    onFrame: () => void,
+    onState: (active: boolean) => void,
+  ): ModalFrameController;
+}
+
+export interface ModalFrameController {
+  attach(): void;
+  detach(): void;
+}
+
+declare const nativeWindow: NativeWindowApi;
+export = nativeWindow;

package/native/window/src/index.js

@@ -0,0 +1,32 @@
+const Fs = require("fs");
+const { createRequire } = require("node:module");
+const { getBindingPath } = require("../binding-path.js");
+
+const requireNative = createRequire(__filename);
+const bindingPath = getBindingPath();
+if (!Fs.existsSync(bindingPath)) {
+  throw new Error(
+    `Native window addon not found for ${process.platform}-${process.arch}. Run pnpm native:window:build.`,
+  );
+}
+
+const binding = requireNative(bindingPath);
+
+const setTransparent = (nativeData, transparent) => {
+  binding.setTransparent(nativeData, transparent);
+};
+
+const waitForCompositorFrame = (timeoutMs) =>
+  binding.waitForCompositorFrame(timeoutMs);
+
+const create = (nativeData, onFrame, onState) => {
+  const controller = new binding.ModalFrameController(
+    nativeData,
+    onFrame,
+    onState,
+  );
+  controller.attach();
+  return controller;
+};
+
+module.exports = { create, setTransparent, waitForCompositorFrame };

package/native/window/src/lib.rs

@@ -0,0 +1,308 @@
+use napi::bindgen_prelude::FunctionRef;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+
+#[cfg(windows)]
+use windows_sys::Win32::Foundation::FreeLibrary;
+#[cfg(windows)]
+use windows_sys::Win32::Foundation::{HANDLE, HWND, LPARAM, LRESULT, WPARAM};
+#[cfg(windows)]
+use windows_sys::Win32::Graphics::Dwm::{
+    DwmEnableBlurBehindWindow, DWM_BB_BLURREGION, DWM_BB_ENABLE, DWM_BLURBEHIND,
+};
+#[cfg(windows)]
+use windows_sys::Win32::Graphics::Gdi::{CreateRectRgn, DeleteObject};
+#[cfg(windows)]
+use windows_sys::Win32::System::LibraryLoader::{GetProcAddress, LoadLibraryW};
+#[cfg(windows)]
+use windows_sys::Win32::UI::WindowsAndMessaging::{
+    CallWindowProcW, DefWindowProcW, GetWindowLongPtrW, KillTimer, SetTimer, SetWindowLongPtrW,
+    GWLP_USERDATA, GWLP_WNDPROC, WM_ENTERMENULOOP, WM_ENTERSIZEMOVE, WM_EXITMENULOOP,
+    WM_EXITSIZEMOVE, WM_TIMER, WNDPROC,
+};
+
+#[cfg(windows)]
+fn hwnd_from_native_data(native_data: &[u8]) -> Result<HWND> {
+    if native_data.len() < std::mem::size_of::<usize>() {
+        return Err(Error::from_reason("native window data is invalid"));
+    }
+    let hwnd = unsafe { *(native_data.as_ptr() as *const usize) as HWND };
+    if hwnd.is_null() {
+        return Err(Error::from_reason("native window handle is null"));
+    }
+    Ok(hwnd)
+}
+
+const DEFAULT_COMPOSITOR_WAIT_MS: u32 = 1_000;
+
+pub struct CompositorFrameTask {
+    timeout_ms: u32,
+}
+
+impl Task for CompositorFrameTask {
+    type Output = bool;
+    type JsValue = bool;
+
+    fn compute(&mut self) -> Result<Self::Output> {
+        #[cfg(windows)]
+        {
+            return Ok(wait_for_windows_compositor(self.timeout_ms));
+        }
+
+        #[cfg(not(windows))]
+        {
+            Ok(false)
+        }
+    }
+
+    fn resolve(&mut self, _env: Env, signaled: Self::Output) -> Result<Self::JsValue> {
+        Ok(signaled)
+    }
+}
+
+/// Waits off the JavaScript thread for the next Windows compositor clock tick.
+#[napi]
+pub fn wait_for_compositor_frame(timeout_ms: Option<u32>) -> AsyncTask<CompositorFrameTask> {
+    AsyncTask::new(CompositorFrameTask {
+        timeout_ms: timeout_ms.unwrap_or(DEFAULT_COMPOSITOR_WAIT_MS).max(1),
+    })
+}
+
+#[cfg(windows)]
+fn wait_for_windows_compositor(timeout_ms: u32) -> bool {
+    type WaitForCompositorClock = unsafe extern "system" fn(u32, *const HANDLE, u32) -> u32;
+
+    let library_name: Vec<u16> = "dcomp.dll\0".encode_utf16().collect();
+    let module = unsafe { LoadLibraryW(library_name.as_ptr()) };
+    if module.is_null() {
+        return false;
+    }
+
+    let procedure =
+        unsafe { GetProcAddress(module, b"DCompositionWaitForCompositorClock\0".as_ptr()) };
+    let signaled = match procedure {
+        Some(procedure) => {
+            let wait = unsafe {
+                std::mem::transmute::<unsafe extern "system" fn() -> isize, WaitForCompositorClock>(
+                    procedure,
+                )
+            };
+            unsafe { wait(0, std::ptr::null(), timeout_ms) == 0 }
+        }
+        None => false,
+    };
+    unsafe {
+        FreeLibrary(module);
+    }
+    signaled
+}
+
+#[napi]
+pub fn set_transparent(native_data: Buffer, transparent: bool) -> Result<()> {
+    #[cfg(windows)]
+    {
+        let hwnd = hwnd_from_native_data(&native_data)?;
+        configure_dwm_transparency(hwnd, transparent)?;
+    }
+
+    #[cfg(not(windows))]
+    {
+        let _ = (native_data, transparent);
+        return Err(Error::from_reason(
+            "transparent native windows are supported only on Windows 11",
+        ));
+    }
+
+    Ok(())
+}
+
+#[cfg(windows)]
+fn configure_dwm_transparency(hwnd: HWND, transparent: bool) -> Result<()> {
+    let region = if transparent {
+        unsafe { CreateRectRgn(0, 0, -1, -1) }
+    } else {
+        std::ptr::null_mut()
+    };
+    if transparent && region.is_null() {
+        return Err(Error::from_reason(
+            "could not create DWM transparency region",
+        ));
+    }
+
+    let blur = DWM_BLURBEHIND {
+        dwFlags: if transparent {
+            DWM_BB_ENABLE | DWM_BB_BLURREGION
+        } else {
+            DWM_BB_ENABLE
+        },
+        fEnable: i32::from(transparent),
+        hRgnBlur: region,
+        fTransitionOnMaximized: 0,
+    };
+    let result = unsafe { DwmEnableBlurBehindWindow(hwnd, &blur) };
+    if !region.is_null() {
+        unsafe {
+            DeleteObject(region as _);
+        }
+    }
+    if result < 0 {
+        return Err(Error::from_reason(format!(
+            "DwmEnableBlurBehindWindow failed with HRESULT 0x{:08x}",
+            result as u32,
+        )));
+    }
+    Ok(())
+}
+
+#[napi]
+pub struct ModalFrameController {
+    env: Env,
+    frame_callback: FunctionRef<(), ()>,
+    state_callback: FunctionRef<(bool,), ()>,
+    #[cfg(windows)]
+    hwnd: HWND,
+    #[cfg(windows)]
+    previous_proc: isize,
+    #[cfg(windows)]
+    previous_userdata: isize,
+    #[cfg(windows)]
+    attached: bool,
+    #[cfg(windows)]
+    invoking: bool,
+}
+
+#[napi]
+impl ModalFrameController {
+    #[napi(constructor)]
+    pub fn new(
+        env: Env,
+        native_data: Buffer,
+        frame_callback: FunctionRef<(), ()>,
+        state_callback: FunctionRef<(bool,), ()>,
+    ) -> Result<Self> {
+        #[cfg(windows)]
+        let hwnd = hwnd_from_native_data(&native_data)?;
+
+        #[cfg(not(windows))]
+        let _ = native_data;
+
+        Ok(Self {
+            env,
+            frame_callback,
+            state_callback,
+            #[cfg(windows)]
+            hwnd,
+            #[cfg(windows)]
+            previous_proc: 0,
+            #[cfg(windows)]
+            previous_userdata: 0,
+            #[cfg(windows)]
+            attached: false,
+            #[cfg(windows)]
+            invoking: false,
+        })
+    }
+
+    #[napi]
+    pub fn attach(&mut self) -> Result<()> {
+        #[cfg(windows)]
+        {
+            if self.hwnd.is_null() || self.attached {
+                return Ok(());
+            }
+            self.previous_userdata = unsafe { GetWindowLongPtrW(self.hwnd, GWLP_USERDATA) };
+            let self_pointer = self as *mut Self as isize;
+            let previous_proc =
+                unsafe { SetWindowLongPtrW(self.hwnd, GWLP_USERDATA, self_pointer) };
+            self.previous_proc = unsafe {
+                SetWindowLongPtrW(self.hwnd, GWLP_WNDPROC, modal_window_proc as usize as isize)
+            };
+            if self.previous_proc == 0 {
+                unsafe {
+                    SetWindowLongPtrW(self.hwnd, GWLP_USERDATA, self.previous_userdata);
+                }
+                return Err(Error::from_reason(
+                    "could not install Windows modal window hook",
+                ));
+            }
+            let _ = previous_proc;
+            self.attached = true;
+        }
+        Ok(())
+    }
+
+    #[napi]
+    pub fn detach(&mut self) {
+        #[cfg(windows)]
+        if self.attached {
+            unsafe {
+                KillTimer(self.hwnd, MODAL_TIMER_ID);
+                SetWindowLongPtrW(self.hwnd, GWLP_WNDPROC, self.previous_proc);
+                SetWindowLongPtrW(self.hwnd, GWLP_USERDATA, self.previous_userdata);
+            }
+            self.attached = false;
+        }
+    }
+
+    #[cfg(windows)]
+    fn invoke_frame(&mut self) {
+        if self.invoking {
+            return;
+        }
+        self.invoking = true;
+        if let Ok(callback) = self.frame_callback.borrow_back(&self.env) {
+            let _ = callback.call(());
+        }
+        self.invoking = false;
+    }
+
+    #[cfg(windows)]
+    fn invoke_state(&self, active: bool) {
+        if let Ok(callback) = self.state_callback.borrow_back(&self.env) {
+            let _ = callback.call((active,));
+        }
+    }
+}
+
+impl Drop for ModalFrameController {
+    fn drop(&mut self) {
+        self.detach();
+    }
+}
+
+#[cfg(windows)]
+const MODAL_TIMER_ID: usize = 0x5049_5849;
+
+#[cfg(windows)]
+unsafe extern "system" fn modal_window_proc(
+    hwnd: HWND,
+    message: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    let controller = GetWindowLongPtrW(hwnd, GWLP_USERDATA) as *mut ModalFrameController;
+    if !controller.is_null() {
+        let controller = &mut *controller;
+        match message {
+            WM_ENTERSIZEMOVE | WM_ENTERMENULOOP => {
+                controller.invoke_state(true);
+                SetTimer(hwnd, MODAL_TIMER_ID, 16, None);
+            }
+            WM_TIMER if wparam == MODAL_TIMER_ID => {
+                controller.invoke_frame();
+                return 0;
+            }
+            WM_EXITSIZEMOVE | WM_EXITMENULOOP => {
+                KillTimer(hwnd, MODAL_TIMER_ID);
+                controller.invoke_state(false);
+            }
+            _ => {}
+        }
+        let previous = std::mem::transmute::<isize, WNDPROC>(controller.previous_proc);
+        return match previous {
+            Some(proc) => CallWindowProcW(Some(proc), hwnd, message, wparam, lparam),
+            None => DefWindowProcW(hwnd, message, wparam, lparam),
+        };
+    }
+    DefWindowProcW(hwnd, message, wparam, lparam)
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@matjash/pixi-native-win32-x64",
+  "version": "0.1.2",
+  "type": "commonjs",
+  "description": "Windows x64 native binaries for @matjash/pixi-native",
+  "license": "MIT",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "index.cjs",
+    "index.d.ts",
+    "native",
+    "THIRD_PARTY_NOTICES.md",
+    "third_party"
+  ],
+  "main": "./index.cjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matjazPrijatelj/pixi-native.git",
+    "directory": "packages/native-win32-x64"
+  },
+  "homepage": "https://github.com/matjazPrijatelj/pixi-native#readme",
+  "bugs": {
+    "url": "https://github.com/matjazPrijatelj/pixi-native/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}

package/third_party/ffmpeg-source-8.0-140fd653ae.tar.gz.sha256

@@ -0,0 +1 @@
+083d0987eb7a1827187a6d4c6e5d37d71293a68eaecd7e0a03dccb38cc249b89  ffmpeg-source-8.0-140fd653ae.tar.gz