dsh-plugin-vrmpet3d 0.1.1 → 0.1.3

package/desktop/game-visibility.cjs

@@ -0,0 +1,50 @@
+// A focused game temporarily hides only a pet window that was visible beforehand.
+const http = require('node:http');
+const https = require('node:https');
+// A transparent window can paint and report pixel hits after showInactive while
+// Chromium still uses the pre-hide input surface. A real bounds transition (the
+// same transition wheel zoom causes) rebuilds that surface without changing the pet.
+function refreshInputRegion(win, schedule = setTimeout) {
+  if (win.isDestroyed() || !win.isVisible()) return;
+  const original = win.getBounds();
+  const temporary = { ...original, width: original.width + 1 };
+  win.setBounds(temporary, false);
+  schedule(() => {
+    if (win.isDestroyed()) return;
+    const current = win.getBounds();
+    // A drag or another layout update owns its new bounds; never move it back.
+    if (['x', 'y', 'width', 'height'].every(key => current[key] === temporary[key])) win.setBounds(original, false);
+  }, 32);
+}
+function createVisibilityController(win, hooks = {}) {
+  let hiddenByGame = false;
+  return function apply(active) {
+    if (win.isDestroyed()) return;
+    if (active && !hiddenByGame && win.isVisible()) { hiddenByGame = true; hooks.suspend?.(); win.hide(); }
+    else if (!active && hiddenByGame) { hiddenByGame = false; win.showInactive(); hooks.resume?.(); }
+  };
+}
+function watchGameVisibility(win, pageURL, interval = 500, hooks = {}) {
+  const apply = createVisibilityController(win, hooks);
+  const url = new URL('/vrmpet3d/desktop', pageURL);
+  const transport = url.protocol === 'https:' ? https : http;
+  let request = null, stopped = false;
+  function poll() {
+    if (stopped || request || win.isDestroyed()) return;
+    request = transport.get(url, { timeout: 1500 }, response => {
+      let body = '', failed = response.statusCode !== 200;
+      response.on('data', chunk => { body += chunk; if (body.length > 16384) { failed = true; response.destroy(); } });
+      response.on('end', () => {
+        if (stopped) return;
+        try { apply(!failed && JSON.parse(body).gameFocused === true); } catch (_) { apply(false); }
+      });
+      response.on('error', () => { if (!stopped) apply(false); });
+    });
+    request.on('timeout', () => request.destroy());
+    request.on('error', () => { if (!stopped) apply(false); });
+    request.on('close', () => { request = null; });
+  }
+  const timer = setInterval(poll, interval); timer.unref(); poll();
+  return function stop() { stopped = true; clearInterval(timer); if (request) request.destroy(); apply(false); };
+}
+module.exports = { createVisibilityController, watchGameVisibility, refreshInputRegion };

package/desktop/main.js

@@ -8,9 +8,10 @@
 // Everything here was measured before it was written (see HANDOFF §12): a transparent
 // always-on-top window renders WebGL with a real alpha channel, can be resized to the whole
 // screen, and `capturePage()` returns pixels that are mostly fully transparent.
-const { app, BrowserWindow, dialog, ipcMain, screen } = require('electron');
+const { app, BrowserWindow, dialog, ipcMain, screen, shell } = require('electron');
 const fs = require('node:fs');
 const path = require('node:path');
+const { watchGameVisibility, refreshInputRegion } = require('./game-visibility.cjs');
 
 /** Cursor polling rate. The gaze is smoothed by the idle, so this is about drag latency. */
 const CURSOR_HZ = 60;
@@ -251,6 +252,19 @@ function writeSelfTest(code) {
   app.exit(code);
 }
 
+// A second game launch focuses the existing game instead of opening another process on its profile.
+const gameMode = options.config === true && new URL(options.url).pathname === '/vrmpet3d/game';
+let activeGameWindow = null;
+function focusGameWindow() {
+  if (!activeGameWindow || activeGameWindow.isDestroyed()) return;
+  if (activeGameWindow.isMinimized()) activeGameWindow.restore();
+  activeGameWindow.show(); activeGameWindow.focus();
+}
+if (gameMode) {
+  if (!app.requestSingleInstanceLock()) app.exit(0);
+  else app.on('second-instance', focusGameWindow);
+}
+
 /** The pet's rectangle on screen, as last reported by the page; null until it mounts. */
 let petRect = null;
 /** The right-click menu's rectangle in screen coordinates, while it is open. DOM, so the window holds it. */
@@ -269,6 +283,7 @@ let speechRect = null;
 let lastCursor = null;
 /** Whether the cursor is on a pixel the page actually painted — the page's own verdict. */
 let overPet = false;
+const inputDiagnostics = { through: true, recoveries: 0, regions: 0, events: {}, lastEvent: null };
 let interacting = false;
 /** True while the self-test drives the page with synthetic cursors. */
 let probing = false;
@@ -300,6 +315,7 @@ app.whenReady().then(async () => {
     // settings form. Read from the argument rather than from a separate entry point, because the rest of
     // the launcher (the borrowed runtime, the watchdog, the parent-pid handshake) is identical for both.
     const isConfig = options.config === true;
+    const isGame = isConfig && new URL(options.url).pathname === '/vrmpet3d/game';
 
     /**
      * Arm the self-test's own deadline before anything can hang.
@@ -329,7 +345,8 @@ app.whenReady().then(async () => {
       height: 860,
       minWidth: 560,
       minHeight: 420,
-      title: 'vrmpet3d - model settings',
+      title: isGame ? '吃白饭 · 桌宠弹球' : 'vrmpet3d - model settings',
+      fullscreen: isGame,
       backgroundColor: '#16171c',
       show: true,
       webPreferences: {
@@ -428,7 +445,7 @@ app.whenReady().then(async () => {
 
     const setClickThrough = (through) => {
       if (win.isDestroyed() || mouseThrough === through) return;
-      mouseThrough = through;
+      mouseThrough = through; inputDiagnostics.through = through;
       if (through) win.setIgnoreMouseEvents(true, { forward: true });
       else win.setIgnoreMouseEvents(false);
       keepOnTop();
@@ -604,6 +621,7 @@ app.whenReady().then(async () => {
       if (!probing) sendCursor(lastCursor);
     };
 
+    ipcMain.on('vrmpet3d:focus-host', () => { shell.openExternal('dsh://open').catch(() => {}); });
     ipcMain.handle('vrmpet3d:config', () => ({
       modelId: options.modelId,
       assetBase: '/vrmpet3d/asset',
@@ -650,6 +668,12 @@ app.whenReady().then(async () => {
         return null;
       }
     });
+    ipcMain.on('vrmpet3d:input-event', (event, value) => {
+      if (event.sender !== win.webContents || !value || !['pointerdown','pointerup','mousedown','mouseup','wheel'].includes(value.type)) return;
+      inputDiagnostics.events[value.type] = (inputDiagnostics.events[value.type] || 0) + 1;
+      inputDiagnostics.lastEvent = {type:value.type,button:Number.isInteger(value.button) ? value.button : null,
+        target:typeof value.target === 'string' ? value.target.slice(0,32) : '',trusted:value.trusted === true};
+    });
     ipcMain.on('vrmpet3d:rect', (_event, rect) => {
       if (!rect || typeof rect !== 'object') return;
       petRect = {
@@ -794,6 +818,31 @@ app.whenReady().then(async () => {
     });
     ipcMain.on('vrmpet3d:quit', () => app.quit());
     win.on('closed', () => app.quit());
+    if (!isConfig) {
+      const resetPetInput = () => {
+        interacting = false; overPet = false; zoomHoldUntil = 0; orbitFocus = false;
+        win.setFocusable(false); releaseOrbitLock();
+        // Recreate Electron's native forwarding hook; repeating `true` alone can reuse the stale hook after hide/show.
+        win.setIgnoreMouseEvents(false);
+        mouseThrough = false;
+        setClickThrough(true);
+        inputDiagnostics.recoveries++;
+        sendCursor(screen.getCursorScreenPoint());
+      };
+      const stopGameVisibility = watchGameVisibility(win, options.url, 500, {
+        suspend: resetPetInput,
+        resume: () => {
+          resetPetInput();
+          refreshInputRegion(win); inputDiagnostics.regions++;
+        },
+      });
+      win.once('closed', stopGameVisibility);
+    }
+
+    if (isGame) {
+      activeGameWindow = win;
+      win.once('closed', () => { activeGameWindow = null; });
+    }
 
     // The cursor is read from the OS rather than from page events: a click-through window
     // receives no pointer events at all outside the pet, so events cannot drive the gaze,
@@ -1623,6 +1672,14 @@ function announce(info) {
      * from the page state, so a page that never published reports `null` rather than a stale number.
      */
     frames: lastPageState && typeof lastPageState.frames === 'number' ? lastPageState.frames : null,
+    input: {
+      through: inputDiagnostics.through, recoveries: inputDiagnostics.recoveries,
+      regions: inputDiagnostics.regions, events: inputDiagnostics.events, lastEvent: inputDiagnostics.lastEvent,
+      cursor: lastCursor, pageCursor: lastPageState && lastPageState.cursor || null,
+      lastHit: lastPageState && lastPageState.lastHit || null,
+      hitReads: lastPageState && lastPageState.hitReads || 0,
+      hit: lastPageState && lastPageState.hit || null,
+    },
     over: overPet,
     interacting: interacting,
     rect: petRect,

package/desktop/preload.js

@@ -7,12 +7,23 @@
 // process, or any other window.
 const { contextBridge, ipcRenderer } = require('electron');
 
+// Read-only counters distinguish pixel hits from actual button delivery after hide/show.
+for (const type of ['pointerdown', 'pointerup', 'mousedown', 'mouseup', 'wheel']) {
+  document.addEventListener(type, event => {
+    ipcRenderer.send('vrmpet3d:input-event', {
+      type, button: event.button, trusted: event.isTrusted === true,
+      target: event.target && event.target.tagName || '',
+    });
+  }, true);
+}
+
 contextBridge.exposeInMainWorld('vrmpet3dDesktop', {
   /**
    * Ask for the launch configuration: which model to show, where the asset route lives.
    * Sent as an invoke so the page can await it before mounting anything.
    */
   config: () => ipcRenderer.invoke('vrmpet3d:config'),
+  focusHost: () => ipcRenderer.send('vrmpet3d:focus-host'),
 
   /** The global cursor position, pushed by the main process at frame rate. */
   onCursor: (callback) => {