@matjash/pixi-native-win32-x64 0.1.2 → 0.2.0

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

@@ -2778,7 +2778,7 @@ type PresentMode = "fifo" | "fifoRelaxed" | "immediate" | "mailbox";
 
 interface Renderer {
   getPreferredFormat(): GPUTextureFormat;
-  getAlphaMode(): 'opaque' | 'premultiplied';
+  getAlphaMode(): 'opaque' | 'premultiplied' | 'inherit';
   getCurrentTexture(): GPUTexture;
   getCurrentTextureView(): GPUTextureView;
   swap();
@@ -2839,6 +2839,8 @@ interface WebGPU {
     adapter: GPUAdapter;
     device: GPUDevice;
     renderer: Renderer;
+    requestedAlphaMode: "opaque" | "premultiplied";
+    alphaMode: "opaque" | "premultiplied" | "inherit";
   };
   destroy(context: object);
 }

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

@@ -1,11 +1,46 @@
-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 NativeSurfaceDescriptor {
+  readonly version: 1;
+  readonly api: "win32" | "x11" | "wayland";
+  readonly window: Buffer;
+  readonly display?: Buffer;
+  readonly instance?: Buffer;
+  readonly eglWindow?: Buffer;
+}
+
+export interface NativeWindowOptions {
+  readonly title: string;
+  readonly width: number;
+  readonly height: number;
+  readonly resizable: boolean;
+  readonly borderless: boolean;
+  readonly transparent: boolean;
+  readonly x?: number;
+  readonly y?: number;
+  readonly graphics: "webgpu" | "webgl";
+}
+
+export interface NativeWindow {
+  readonly id: number;
+  readonly x: number;
+  readonly y: number;
+  readonly pixelWidth: number;
+  readonly pixelHeight: number;
+  readonly display: { readonly frequency: number };
+  readonly destroyed: boolean;
+  readonly surface: NativeSurfaceDescriptor;
+  readonly videoDriver: string;
+  readonly transparent: boolean;
+  pollEvents(): void;
+  setPosition(x: number, y: number): void;
+  minimize(): void;
+  maximize(): void;
+  restore(): void;
+  makeGlCurrent(): boolean;
+  setGlSwapInterval(interval: number): boolean;
+  swapGl(): boolean;
+  glVersion(): string;
+  on(event: string, listener: (event: Record<string, unknown>) => void): this;
+  destroy(): void;
 }
 
 export interface ModalFrameController {
@@ -13,5 +48,16 @@ export interface ModalFrameController {
   detach(): void;
 }
 
+export interface NativeWindowApi {
+  createWindow(options: NativeWindowOptions): NativeWindow;
+  pollEvents(): void;
+  waitForCompositorFrame(timeoutMs?: number): Promise<boolean>;
+  createModalFrameController(
+    nativeData: Buffer,
+    onFrame: () => void,
+    onState: (active: boolean) => void,
+  ): ModalFrameController;
+}
+
 declare const nativeWindow: NativeWindowApi;
 export = nativeWindow;

package/native/window/src/index.js

@@ -1,6 +1,8 @@
-const Fs = require("fs");
+const { EventEmitter } = require("node:events");
+const Fs = require("node:fs");
 const { createRequire } = require("node:module");
 const { getBindingPath } = require("../binding-path.js");
+const { normalizeSdlKeyName } = require("./key-mapping.js");
 
 const requireNative = createRequire(__filename);
 const bindingPath = getBindingPath();
@@ -11,22 +13,89 @@ if (!Fs.existsSync(bindingPath)) {
 }
 
 const binding = requireNative(bindingPath);
+const windows = new Map();
+let waylandPositionWarned = false;
 
-const setTransparent = (nativeData, transparent) => {
-  binding.setTransparent(nativeData, transparent);
+class NativeWindow extends EventEmitter {
+  constructor(options) {
+    super();
+    this._nativeWindow = new binding.NativeSdlWindow(options);
+    windows.set(this._nativeWindow.id, this);
+  }
+
+  get id() { return this._nativeWindow.id; }
+  get x() { return this._nativeWindow.x; }
+  get y() { return this._nativeWindow.y; }
+  get pixelWidth() { return this._nativeWindow.pixelWidth; }
+  get pixelHeight() { return this._nativeWindow.pixelHeight; }
+  get display() { return { frequency: this._nativeWindow.refreshRate }; }
+  get destroyed() { return this._nativeWindow.destroyed; }
+  get surface() { return this._nativeWindow.surface; }
+  get videoDriver() { return this._nativeWindow.videoDriver; }
+  get transparent() { return this._nativeWindow.transparent; }
+
+  pollEvents() { pollEvents(); }
+
+  setPosition(x, y) {
+    if (this._nativeWindow.setPosition(x, y)) return;
+    if (!waylandPositionWarned) {
+      waylandPositionWarned = true;
+      console.warn(
+        "[pixi-native] SDL3 Wayland ignores absolute toplevel window positioning.",
+      );
+    }
+  }
+
+  minimize() { this._nativeWindow.minimize(); }
+  maximize() { this._nativeWindow.maximize(); }
+  restore() { this._nativeWindow.restore(); }
+  makeGlCurrent() { return this._nativeWindow.makeGlCurrent(); }
+  setGlSwapInterval(interval) { return this._nativeWindow.setGlSwapInterval(interval); }
+  swapGl() { return this._nativeWindow.swapGl(); }
+  glVersion() { return this._nativeWindow.glVersion(); }
+
+  destroy() {
+    if (this.destroyed) return;
+    windows.delete(this.id);
+    this._nativeWindow.destroy();
+    this.removeAllListeners();
+  }
+}
+
+const emitNativeEvent = (window, event) => {
+  const { kind, windowId, superKey, ...payload } = event;
+  if (kind === "keyDown" || kind === "keyUp") {
+    payload.key = normalizeSdlKeyName(payload.key);
+  }
+  window.emit(kind, { ...payload, type: kind, super: superKey });
+};
+
+const pollEvents = () => {
+  for (const event of binding.pollEvents()) {
+    if (event.kind === "quit") {
+      for (const window of [...windows.values()]) {
+        emitNativeEvent(window, { ...event, kind: "close" });
+      }
+      continue;
+    }
+    const window = windows.get(event.windowId);
+    if (window) emitNativeEvent(window, event);
+  }
 };
 
+const createWindow = (options) => new NativeWindow(options);
 const waitForCompositorFrame = (timeoutMs) =>
   binding.waitForCompositorFrame(timeoutMs);
-
-const create = (nativeData, onFrame, onState) => {
-  const controller = new binding.ModalFrameController(
-    nativeData,
-    onFrame,
-    onState,
-  );
+const createModalFrameController = (nativeData, onFrame, onState) => {
+  const controller = new binding.ModalFrameController(nativeData, onFrame, onState);
   controller.attach();
   return controller;
 };
 
-module.exports = { create, setTransparent, waitForCompositorFrame };
+module.exports = {
+  NativeWindow,
+  createWindow,
+  createModalFrameController,
+  pollEvents,
+  waitForCompositorFrame,
+};

package/native/window/src/key-mapping.js

@@ -0,0 +1,32 @@
+const SDL_KEY_NAMES = Object.freeze({
+  Up: "up",
+  Down: "down",
+  Left: "left",
+  Right: "right",
+  Space: "space",
+  Return: "return",
+  Escape: "escape",
+  Backspace: "backspace",
+  Tab: "tab",
+  "Left Ctrl": "ctrl",
+  "Right Ctrl": "ctrl",
+  "Left Shift": "shift",
+  "Right Shift": "shift",
+  "Left Alt": "alt",
+  "Right Alt": "alt",
+  "Left GUI": "gui",
+  "Right GUI": "gui",
+});
+
+/** Preserves the key names exposed by the previous @kmamal/sdl adapter. */
+const normalizeSdlKeyName = (name) => {
+  if (typeof name !== "string") return name;
+  const mapped = SDL_KEY_NAMES[name];
+  if (mapped) return mapped;
+  if (/^[A-Z]$/.test(name) || /^F\d{1,2}$/.test(name)) {
+    return name.toLowerCase();
+  }
+  return name;
+};
+
+module.exports = { normalizeSdlKeyName };