chore: sync v1.2.9 (html-export, electron file writer, screen projection)

Author: Re-qi

.gitignore

@@ -17,3 +17,4 @@ native/build
 *.log
 Thumbs.db
 desktop.ini
+skills-lock.json

debug-browser-import-lag.md

@@ -0,0 +1,45 @@
+# Debug Session: browser-import-lag
+
+**状态**: [CLOSED]
+**创建时间**: 2026-08-08
+**症状**: 浏览器导入任何高斯文件后持续卡顿（FPS 低）；Electron 正常
+**复现步骤**: 打开浏览器版应用 → 导入高斯文件 → 旋转/缩放相机 → 持续卡顿
+
+## 环境
+- OS: Windows
+- 浏览器: (待用户确认)
+- 应用: ReSplat (supersplat-2.27.0 base, PlayCanvas 2.18.2)
+- Electron 正常, 浏览器卡顿
+
+## 结论 (2026-08-08 实测)
+
+**根因（最终确认）：Trae CN 的 GPU 进程强制 `--use-angle=swiftshader-webgl`，导致内置浏览器所有 WebGL（含 ReSplat）走 SwiftShader 纯软件渲染，比硬件慢约 40 倍。非应用逻辑/版本问题。**
+
+证据：
+- 控制台日志（Trae 内置浏览器）：`[ReSplat] WebGL renderer: ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero)), SwiftShader driver)`
+- Trae CN GPU 进程命令行：`--type=gpu-process ... --use-gl=angle --use-angle=swiftshader-webgl`（应用内置，argv.json/快捷方式均无此配置）
+- TRAE SOLO CN GPU 进程**无** swiftshader 参数 → 硬件加速，不卡
+- `c:\Users\123\.trae-cn\argv.json` 无 `disable-hardware-acceleration`
+
+**实测（同一 release 构建、50k 合成高斯）**：
+| 渲染环境 | 渲染器 | 导入后帧耗时 |
+|---|---|---|
+| Edge 硬件 GL | NVIDIA RTX 5060 Ti D3D11 | 17.6ms (57fps) |
+| 强制软件 GL (模拟 Trae 内置浏览器) | SwiftShader (Subzero) | **3776ms (0.3fps)** |
+
+- 空闲时 60fps、renderNextFrame=false、sorter worker 健康（1-2ms）、无内存压力 → 假设 A/B/D/E 均排除。
+- 旧版 1.2.4（备份）与新版 1.2.7 帧耗时几乎一致 → 非版本回归。
+
+### 建议
+- 交互式编辑请使用 **Edge 浏览器 / Electron**（硬件加速）。
+- Trae 内置浏览器因内置 swiftshader-webgl 参数无法用于 GPU 重负载应用。
+
+### 已实施修复 (2026-08-08)
+在 `src/main.ts` 启动时检测 WebGL 渲染器（`WEBGL_debug_renderer_info`）：
+- 检测到软件渲染（SwiftShader/llvmpipe）→ 控制台输出 + 弹窗提示"开启硬件加速或改用 Edge/Electron"。
+- 注：曾尝试自动 `pixelScale=2` 降分辨率，用户反馈视口变糊且对软件渲染帮助有限，**已撤销**，仅保留检测+提示。
+- 新增 locale 键：`popup.software-rendering.title/message`（en/zh-CN）。
+
+### 说明
+- 当前 dist 已用 `npm run build` 重建为 release（之前是 develop 的 debug 引擎构建 playcanvas.dbg）。
+- 临时调试文件（scripts/diag-*.cjs、.diag-edge-profile、%TEMP%\resplat-temp\diag_*.ply）已清理。

electron/main.cjs

@@ -9,6 +9,7 @@
 const { app: electronApp, BrowserWindow, ipcMain, dialog, shell, Menu, protocol, net } = require('electron');
 const path = require('path');
 const crypto = require('crypto');
+const { extractGzipProjectEntry } = require('./project-extractor.cjs');
 
 // ---------------------------------------------------------------------------
 // Raise renderer V8 heap limit above the ~4 GB default
@@ -27,7 +28,12 @@ const crypto = require('crypto');
 // [4 GB, 16 GB], to avoid triggering swap on memory-constrained machines.
 const totalMemMB = Math.floor(require('os').totalmem() / 1024 / 1024);
 const rendererMaxOldSpace = Math.min(16384, Math.max(4096, Math.floor((totalMemMB - 2048) * 0.75)));
-electronApp.commandLine.appendSwitch('js-flags', `--max-old-space-size=${rendererMaxOldSpace}`);
+// --expose-gc enables global.gc() in the renderer. The LCC2/HTML export paths
+// call (globalThis).gc?.() to release multi-GB intermediate DataTables between
+// LOD loads (serializeLcc2FromLodLog, html export). Without the flag those
+// hints silently no-op and previous LOD tables stay resident until the next
+// multi-GB allocation throws "Array buffer allocation failed".
+electronApp.commandLine.appendSwitch('js-flags', `--expose-gc --max-old-space-size=${rendererMaxOldSpace}`);
 console.log(`[electron] Renderer V8 heap limit: ${rendererMaxOldSpace} MB (system RAM: ${totalMemMB} MB)`);
 
 // ---------------------------------------------------------------------------
@@ -173,6 +179,14 @@ async function createWindow() {
         console.log('[electron] WebGPU check failed:', e.message);
     }
 
+    // Forward renderer errors to the main-process terminal so export failures
+    // can be diagnosed without opening DevTools.
+    mainWindow.webContents.on('console-message', (_e, level, message, line, sourceId) => {
+        if (typeof message === 'string' && level >= 3) {
+            console.log(`[renderer] ${message}${sourceId ? ` (${sourceId}:${line})` : ''}`);
+        }
+    });
+
     mainWindow.on('closed', () => {
         mainWindow = null;
     });
@@ -236,6 +250,30 @@ ipcMain.handle('fs:readFile', async (_event, filePath) => {
     return fs.readFileSync(filePath);
 });
 
+// Read a byte range from a file by absolute path + position. Used by the LCC
+// reader to stream GB-scale sibling files (data.bin/shcoef.bin) on demand
+// WITHOUT going through Chromium's network stack — system proxies / flaky
+// localhost routing made fetch-based reads (HTTP Range) unreliable, and IPC
+// readFileSync of the whole file blows the renderer's ~4GB memory limit.
+ipcMain.handle('fs:readRange', async (_event, filePath, position, length) => {
+    const fs = require('fs');
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buf = Buffer.allocUnsafe(length);
+        const bytesRead = fs.readSync(fd, buf, 0, length, position);
+        return buf.subarray(0, bytesRead);
+    } finally {
+        fs.closeSync(fd);
+    }
+});
+
+// Stat a file; returns { size } (bytes)
+ipcMain.handle('fs:stat', async (_event, filePath) => {
+    const fs = require('fs');
+    const s = fs.statSync(filePath);
+    return { size: s.size };
+});
+
 // Check if a file path exists
 ipcMain.handle('fs:exists', async (_event, filePath) => {
     const fs = require('fs');
@@ -250,9 +288,11 @@ ipcMain.handle('fs:readDir', async (_event, dirPath) => {
     return fs.readdirSync(dirPath).map(name => path.join(dirPath, name));
 });
 
-// Recursively walk a directory tree. Returns [{ path, rel }] for every regular
-// file, where `path` is absolute and `rel` is the path relative to `dirPath`
-// using forward slashes (so it matches web FileSystemEntry fullPath conventions).
+// Recursively walk a directory tree. Returns [{ path, rel, size }] for every
+// regular file, where `path` is absolute, `rel` is the path relative to `dirPath`
+// using forward slashes (so it matches web FileSystemEntry fullPath conventions),
+// and `size` is the file size in bytes. The size lets the renderer skip
+// GB-scale LCC siblings (data.bin/shcoef.bin) instead of shipping them over IPC.
 // Used to auto-resolve LCC2 chunk siblings (.sog/.spz) that live in subdirectories
 // next to a dropped .lcc2 meta file.
 ipcMain.handle('fs:walk', async (_event, dirPath) => {
@@ -271,7 +311,7 @@ ipcMain.handle('fs:walk', async (_event, dirPath) => {
             if (stat.isDirectory()) {
                 walk(full, rel);
             } else if (stat.isFile()) {
-                result.push({ path: full, rel });
+                result.push({ path: full, rel, size: stat.size });
             }
         }
     };
@@ -356,6 +396,16 @@ ipcMain.handle('fs:unlink', async (_event, p) => {
     }
 });
 
+// Expand a .respproj PLY into a temporary file in the main process. Sending a
+// multi-GB project payload to the renderer first creates avoidable heap copies.
+ipcMain.handle('project:extractGzipEntry', async (_event, projectPath, entryName) => {
+    if (typeof projectPath !== 'string' || typeof entryName !== 'string' || !/^splat_\d+\.ply\.gz$/.test(entryName)) {
+        throw new Error('Invalid project extraction request');
+    }
+    const tempDir = path.join(electronApp.getPath('temp'), 'ReSplat-projects');
+    return extractGzipProjectEntry(projectPath, entryName, tempDir);
+});
+
 // Open URL in system default browser
 ipcMain.handle('shell:openExternal', async (_event, url) => {
     await shell.openExternal(url);

electron/preload.cjs

@@ -16,6 +16,27 @@ const { contextBridge, ipcRenderer, webUtils } = require('electron');
 // 'drop' events in the preload context (capture phase) and extract paths
 // using the original File objects BEFORE they enter the renderer world.
 const _dropFilePaths = new Map();
+const _inputFilePaths = new Map();
+
+// Chromium no longer exposes File.path to the isolated renderer. Capture
+// native paths while the FileList is still in the preload world, then let the
+// renderer resolve the path by the stable name+size pair. This is needed for
+// path-based backend exports of large .respproj files.
+const rememberInputFilePaths = (files) => {
+    for (const file of files || []) {
+        try {
+            const path = webUtils.getPathForFile(file);
+            if (path) _inputFilePaths.set(`${file.name}|${file.size}`, path);
+        } catch (_err) {
+            // ignore — file has no accessible path
+        }
+    }
+};
+
+document.addEventListener('change', (event) => {
+    const files = event.target?.files;
+    if (files) rememberInputFilePaths(files);
+}, true);
 
 document.addEventListener('drop', (e) => {
     _dropFilePaths.clear();
@@ -94,6 +115,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
     /** Read a file from disk (by absolute path) */
     readFile: (filePath) => ipcRenderer.invoke('fs:readFile', filePath),
 
+    /** Read a byte range [position, position+length) from a file (by absolute path).
+     *  Used by the LCC reader to stream GB-scale siblings on demand over IPC —
+     *  avoids Chromium's proxy/network stack AND renderer OOM. */
+    readRange: (filePath, position, length) => ipcRenderer.invoke('fs:readRange', filePath, position, length),
+
+    /** Stat a file; resolves to { size } (bytes) */
+    fileSize: (filePath) => ipcRenderer.invoke('fs:stat', filePath),
+
     /** Check if a file exists */
     fileExists: (filePath) => ipcRenderer.invoke('fs:exists', filePath),
 
@@ -118,6 +147,9 @@ contextBridge.exposeInMainWorld('electronAPI', {
     /** Best-effort delete a file (used by writer abort cleanup); resolves to true on success */
     unlink: (filePath) => ipcRenderer.invoke('fs:unlink', filePath),
 
+    /** Extract a gzip PLY entry from a .respproj archive to a temporary file. */
+    extractProjectGzipEntry: (projectPath, entryName) => ipcRenderer.invoke('project:extractGzipEntry', projectPath, entryName),
+
     /** Get the current browser zoom factor */
     getZoomFactor: () => ipcRenderer.invoke('zoom:get'),
 
@@ -148,6 +180,9 @@ contextBridge.exposeInMainWorld('electronAPI', {
         }
     },
 
+    /** Resolve a file-input path captured in preload before context cloning. */
+    getInputFilePath: (name, size) => _inputFilePaths.get(`${name}|${size}`),
+
     /**
      * Retrieve the filesystem path of a drag-dropped file.
      * Must be called from the renderer's drop handler (same tick) after a
@@ -179,4 +214,4 @@ contextBridge.exposeInMainWorld('electronAPI', {
      * Receives `docName` (string), should resolve to 'save' | 'discard' | 'cancel'.
      */
     registerSavePromptHandler: (fn) => { closeHandlers.savePromptHandler = fn; }
-});
+});

electron/project-extractor.cjs

@@ -0,0 +1,100 @@
+/**
+ * Extract a gzip-compressed PLY stored in a .respproj ZIP archive directly to
+ * a temporary file. Keeping this in the main process prevents the renderer
+ * from materialising both the compressed and decompressed multi-GB payload.
+ */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const { pipeline } = require('stream/promises');
+const zlib = require('zlib');
+
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const LOCAL_FILE_SIGNATURE = 0x04034b50;
+
+const findEocdOffset = (buffer) => {
+    for (let offset = buffer.length - 22; offset >= 0; offset--) {
+        if (buffer.readUInt32LE(offset) === EOCD_SIGNATURE) return offset;
+    }
+    throw new Error('Invalid project archive: end of central directory not found');
+};
+
+const readZipEntry = async (archivePath, entryName) => {
+    const { size } = await fsp.stat(archivePath);
+    const tailSize = Math.min(size, 65536 + 22);
+    const tail = Buffer.alloc(tailSize);
+    const handle = await fsp.open(archivePath, 'r');
+
+    try {
+        await handle.read(tail, 0, tailSize, size - tailSize);
+        const eocd = findEocdOffset(tail);
+        const entryCount = tail.readUInt16LE(eocd + 10);
+        const directorySize = tail.readUInt32LE(eocd + 12);
+        const directoryOffset = tail.readUInt32LE(eocd + 16);
+        const directory = Buffer.alloc(directorySize);
+        await handle.read(directory, 0, directorySize, directoryOffset);
+
+        let offset = 0;
+        for (let i = 0; i < entryCount; i++) {
+            if (offset + 46 > directory.length || directory.readUInt32LE(offset) !== CENTRAL_DIRECTORY_SIGNATURE) {
+                throw new Error('Invalid project archive: malformed central directory');
+            }
+            const flags = directory.readUInt16LE(offset + 8);
+            const compressionMethod = directory.readUInt16LE(offset + 10);
+            const compressedSize = directory.readUInt32LE(offset + 20);
+            const nameLength = directory.readUInt16LE(offset + 28);
+            const extraLength = directory.readUInt16LE(offset + 30);
+            const commentLength = directory.readUInt16LE(offset + 32);
+            const localHeaderOffset = directory.readUInt32LE(offset + 42);
+            const encoding = (flags & 0x800) !== 0 ? 'utf8' : 'ascii';
+            const name = directory.toString(encoding, offset + 46, offset + 46 + nameLength);
+
+            if (name === entryName) {
+                const localHeader = Buffer.alloc(30);
+                await handle.read(localHeader, 0, localHeader.length, localHeaderOffset);
+                if (localHeader.readUInt32LE(0) !== LOCAL_FILE_SIGNATURE) {
+                    throw new Error('Invalid project archive: malformed local file header');
+                }
+                const localNameLength = localHeader.readUInt16LE(26);
+                const localExtraLength = localHeader.readUInt16LE(28);
+                return {
+                    compressionMethod,
+                    compressedSize,
+                    dataOffset: localHeaderOffset + 30 + localNameLength + localExtraLength
+                };
+            }
+            offset += 46 + nameLength + extraLength + commentLength;
+        }
+    } finally {
+        await handle.close();
+    }
+
+    throw new Error(`Invalid project archive: entry "${entryName}" not found`);
+};
+
+const extractGzipProjectEntry = async (archivePath, entryName, outputDir) => {
+    const entry = await readZipEntry(archivePath, entryName);
+    if (entry.compressionMethod !== 0 && entry.compressionMethod !== 8) {
+        throw new Error(`Unsupported ZIP compression method ${entry.compressionMethod}`);
+    }
+
+    await fsp.mkdir(outputDir, { recursive: true });
+    const outputPath = path.join(outputDir, `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}.ply`);
+    const input = fs.createReadStream(archivePath, {
+        start: entry.dataOffset,
+        end: entry.dataOffset + entry.compressedSize - 1
+    });
+    const transforms = entry.compressionMethod === 8 ? [zlib.createInflateRaw()] : [];
+
+    try {
+        await pipeline(input, ...transforms, zlib.createGunzip(), fs.createWriteStream(outputPath, { flags: 'wx' }));
+        const { size } = await fsp.stat(outputPath);
+        return { path: outputPath, size };
+    } catch (error) {
+        await fsp.rm(outputPath, { force: true }).catch(() => {});
+        throw error;
+    }
+};
+
+module.exports = { extractGzipProjectEntry };

global.d.ts

@@ -27,6 +27,8 @@ interface ElectronAPI {
     openFolderDialog: () => Promise<string | null>;
     saveFileDialog: (options?: { title?: string; defaultPath?: string; filters?: Array<{ name: string; extensions: string[] }> }) => Promise<string | null>;
     readFile: (filePath: string) => Promise<Uint8Array>;
+    readRange: (filePath: string, position: number, length: number) => Promise<Uint8Array>;
+    fileSize: (filePath: string) => Promise<{ size: number }>;
     fileExists: (filePath: string) => Promise<boolean>;
     readDir: (dirPath: string) => Promise<string[]>;
     /** Create a directory (recursive when opts.recursive is true) */
@@ -39,6 +41,7 @@ interface ElectronAPI {
     writeStreamClose: (id: number) => Promise<void>;
     /** Best-effort delete a file (used by writer abort cleanup) */
     unlink: (filePath: string) => Promise<boolean>;
+    extractProjectGzipEntry: (projectPath: string, entryName: string) => Promise<{ path: string, size: number }>;
     /** Register a callback returning { dirty, docName } for close-time save prompt */
     registerDirtyChecker: (fn: () => Promise<{ dirty: boolean; docName: string | null }>) => void;
     /** Register a callback that saves the current doc; resolves true on success */

package.json

@@ -1,6 +1,6 @@
 {
     "name": "ReSplat",
-    "version": "1.2.8",
+    "version": "1.2.9",
     "main": "electron/main.cjs",
     "author": "Re祁",
     "homepage": "https://playcanvas.com/ReSplat/editor",
@@ -78,6 +78,7 @@
         "directories": {
             "output": "dist-release"
         },
+        "artifactName": "ReSplat Setup ${version}.${ext}",
         "files": [
             "dist/**/*",
             "electron/**/*",