From b304107755cd4efdad97ea1f5709edcd2323a22b Mon Sep 17 00:00:00 2001 From: eust-w Date: Thu, 25 Jun 2026 00:53:47 +0800 Subject: [PATCH] Reduce large scene interaction overhead --- docs/product-readiness.md | 34 ++++++----- scripts/product-readiness-gate.mjs | 8 ++- src/main.ts | 14 ++++- src/preview/UniversalPreviewer.ts | 98 +++++++++++++++++++++++++++--- src/types.ts | 4 ++ 5 files changed, 130 insertions(+), 28 deletions(-) diff --git a/docs/product-readiness.md b/docs/product-readiness.md index 429b5d4..78b4473 100644 --- a/docs/product-readiness.md +++ b/docs/product-readiness.md @@ -304,36 +304,38 @@ Scene evidence: Bundle evidence: - JavaScript chunks: `4` -- App entry chunk: `169.28 kB raw / 43.33 KiB gzip` +- App entry chunk: `171.55 kB raw / 43.83 KiB gzip` - Largest JavaScript gzip chunk: `141.04 KiB / 170.00 KiB` -- Total JavaScript gzip: `208.24 KiB / 230.00 KiB` +- Total JavaScript gzip: `208.73 KiB / 230.00 KiB` - Large-scene performance mode: `large-scene`, target `30 fps`, - DPR cap observed at `1.00` in release gate, shadows `off`. + actual idle render rate `0.8 fps`, DPR cap observed at `1.00` in release + gate, shadows `off`, hover picking throttled to `32ms`, and `324` empty + frames skipped. Control evidence: -- Compose endpoint: `292ms`, `4/4` composed object bodies synced. -- Scene Builder UI compose: representative run `5933ms` end to end with real +- Compose endpoint: `267ms`, `4/4` composed object bodies synced. +- Scene Builder UI compose: representative run `4168ms` end to end with real backend diagnostics. -- Composed object body edit: `67ms`. -- Fixed inventory edit rejection: `33ms`. -- Dynamic composed object drop: `0.47701m`. +- Composed object body edit: `52ms`. +- Fixed inventory edit rejection: `61ms`. +- Dynamic composed object drop: `0.48012m`. - Static shelf anchor stability: `max drift 0.00000m` after a 2500 ms resume window. -- Resume backend state: `79ms paused=false` -- Resume visible UI state: `66ms` -- Pause backend state: `78ms paused=true` -- Pause visible UI state: `63ms` -- Desktop acceptance wait: `3ms` total, product telemetry `0ms` -- Mobile acceptance wait: `477ms` total, product telemetry `2ms` +- Resume backend state: `41ms paused=false` +- Resume visible UI state: `44ms` +- Pause backend state: `229ms paused=true` +- Pause visible UI state: `61ms` +- Desktop acceptance wait: `2ms` total, product telemetry `0ms` +- Mobile acceptance wait: `421ms` total, product telemetry `0ms` - Runtime diagnostics panel: `state=http://127.0.0.1:18090/state`, `control=http://127.0.0.1:18090/control`, - `latency=响应 62 ms / 确认 62 ms / 可见 63 ms`, + `latency=响应 60 ms / 确认 61 ms / 可见 61 ms`, `acceptanceLatency=0 ms / 11-0-0`, `binding=635/636; 4/568`, `builderPhysics=已添加物体 4: 后端动态 4 / 仅视觉 0`, - `renderPerformance=large-scene; target 30 fps; dpr 1.00; shadows off`. + `renderPerformance=large-scene; target 30 fps; actual 0.8 fps; dpr 1.00; shadows off; skipped 324; hover 32ms`. - Evidence screenshot artifacts: `builder page; share page; import page; visual-only boundary canvas; desktop canvas; mobile canvas` - Evidence export artifacts: diff --git a/scripts/product-readiness-gate.mjs b/scripts/product-readiness-gate.mjs index e68e5a5..e0cb689 100644 --- a/scripts/product-readiness-gate.mjs +++ b/scripts/product-readiness-gate.mjs @@ -621,8 +621,12 @@ async function readBrowserStats(page) { renderPerformance: { largeSceneMode: data.largeSceneMode === "true", targetRenderFps: numberData("targetRenderFps"), + actualRenderFps: numberData("actualRenderFps"), renderPixelRatio: numberData("renderPixelRatio"), shadowsEnabled: data.shadowsEnabled === "true", + renderSkipCount: numberData("renderSkipCount"), + lastRenderDurationMs: numberData("lastRenderDurationMs"), + hoverPickIntervalMs: numberData("hoverPickIntervalMs"), }, diagnostics: { manifestUrl: text("#diag-manifest-url"), @@ -1504,8 +1508,10 @@ async function verifyBrowser() { && renderPerformance.targetRenderFps === 30 && (renderPerformance.renderPixelRatio ?? Number.POSITIVE_INFINITY) <= 1.25 && renderPerformance.shadowsEnabled === false + && renderPerformance.hoverPickIntervalMs === 32 + && (renderPerformance.renderSkipCount ?? 0) > 0 && desktopStats.diagnostics.renderPerformance.includes("large-scene"), - `mode=${renderPerformance.largeSceneMode} fps=${renderPerformance.targetRenderFps ?? "-"} dpr=${renderPerformance.renderPixelRatio ?? "-"} shadows=${renderPerformance.shadowsEnabled}; ${desktopStats.diagnostics.renderPerformance}`, + `mode=${renderPerformance.largeSceneMode} fps=${renderPerformance.targetRenderFps ?? "-"} dpr=${renderPerformance.renderPixelRatio ?? "-"} shadows=${renderPerformance.shadowsEnabled} hover=${renderPerformance.hoverPickIntervalMs ?? "-"} skipped=${renderPerformance.renderSkipCount ?? "-"}; ${desktopStats.diagnostics.renderPerformance}`, ); check( "browser-builder-compose-ui", diff --git a/src/main.ts b/src/main.ts index 33b70fe..43b1320 100644 --- a/src/main.ts +++ b/src/main.ts @@ -161,8 +161,12 @@ interface RuntimeDiagnostics { builderPhysics: BuilderPhysicsProfile; largeSceneMode: boolean; targetRenderFps: number; + actualRenderFps: number; renderPixelRatio: number; shadowsEnabled: boolean; + renderSkipCount: number; + lastRenderDurationMs: number; + hoverPickIntervalMs: number; editableGroups: number; groupedObjects: number; meshes: number; @@ -2398,8 +2402,12 @@ function currentRuntimeDiagnostics(): RuntimeDiagnostics { builderPhysics, largeSceneMode: stats.largeSceneMode, targetRenderFps: stats.targetRenderFps, + actualRenderFps: stats.actualRenderFps, renderPixelRatio: stats.renderPixelRatio, shadowsEnabled: stats.shadowsEnabled, + renderSkipCount: stats.renderSkipCount, + lastRenderDurationMs: stats.lastRenderDurationMs, + hoverPickIntervalMs: stats.hoverPickIntervalMs, editableGroups: stats.editableGroupCount, groupedObjects: stats.groupedObjectCount, meshes: stats.loadedMeshCount, @@ -2458,7 +2466,7 @@ function currentDiagnosticsReport(): string { function renderPerformanceLabel(stats: RuntimeDiagnostics["stats"]): string { const mode = stats.largeSceneMode ? "large-scene" : "standard"; const shadows = stats.shadowsEnabled ? "shadows on" : "shadows off"; - return `${mode}; target ${stats.targetRenderFps} fps; dpr ${stats.renderPixelRatio.toFixed(2)}; ${shadows}`; + return `${mode}; target ${stats.targetRenderFps} fps; actual ${stats.actualRenderFps.toFixed(1)} fps; dpr ${stats.renderPixelRatio.toFixed(2)}; ${shadows}; skipped ${stats.renderSkipCount}; hover ${stats.hoverPickIntervalMs}ms`; } function renderDiagnosticsPanel(): void { @@ -2475,8 +2483,12 @@ function renderDiagnosticsPanel(): void { data.builderPhysicsReady = String(diagnostics.stats.builderPhysics.ready); data.largeSceneMode = String(diagnostics.stats.largeSceneMode); data.targetRenderFps = String(diagnostics.stats.targetRenderFps); + data.actualRenderFps = diagnostics.stats.actualRenderFps.toFixed(1); data.renderPixelRatio = diagnostics.stats.renderPixelRatio.toFixed(2); data.shadowsEnabled = String(diagnostics.stats.shadowsEnabled); + data.renderSkipCount = String(diagnostics.stats.renderSkipCount); + data.lastRenderDurationMs = diagnostics.stats.lastRenderDurationMs.toFixed(2); + data.hoverPickIntervalMs = String(diagnostics.stats.hoverPickIntervalMs); setText("#diag-manifest-url", diagnostics.manifestUrl); setText("#diag-state-url", endpointLabel(diagnostics.stateUrl)); setText("#diag-control-url", endpointLabel(diagnostics.controlUrl)); diff --git a/src/preview/UniversalPreviewer.ts b/src/preview/UniversalPreviewer.ts index def8272..58a97ef 100644 --- a/src/preview/UniversalPreviewer.ts +++ b/src/preview/UniversalPreviewer.ts @@ -94,6 +94,9 @@ export class UniversalPreviewer { private readonly objectsById = new Map(); private readonly objectBodyIds = new Map(); private readonly editableGroups = new Map(); + private readonly pickRoots: THREE.Object3D[] = []; + private readonly editablePickRoots: THREE.Object3D[] = []; + private readonly spinningObjects: THREE.Object3D[] = []; private readonly hoverOutline = new THREE.BoxHelper(new THREE.Object3D(), "#38bdf8"); private readonly editableObjectIds = new Set(); private readonly clock = new THREE.Clock(); @@ -118,6 +121,11 @@ export class UniversalPreviewer { private animationHandle = 0; private focusMarkerHideHandle = 0; private frameCount = 0; + private renderSkipCount = 0; + private lastRenderDurationMs = 0; + private renderWindowStartedAt = 0; + private renderWindowFrameCount = 0; + private measuredRenderFps = 0; private loadedMeshCount = 0; private fallbackCount = 0; private lastPixelSampleAt = 0; @@ -126,6 +134,8 @@ export class UniversalPreviewer { private renderDirty = true; private lastRenderAt = 0; private targetRenderIntervalMs = 0; + private hoverPickIntervalMs = 0; + private lastHoverPickAt = 0; private largeSceneMode = false; private loadToken = 0; private lastFrame?: PreviewFrame; @@ -191,6 +201,7 @@ export class UniversalPreviewer { this.setupCameraInput(); this.resize(); window.addEventListener("resize", () => this.resize()); + this.renderWindowStartedAt = performance.now(); this.animate(); } @@ -299,6 +310,7 @@ export class UniversalPreviewer { } } } + this.refreshEditablePickRoots(); } getStats(): RendererStats { @@ -308,8 +320,12 @@ export class UniversalPreviewer { bodyBoundObjectCount: Array.from(this.bodyBindings.values()).reduce((sum, items) => sum + items.length, 0), largeSceneMode: this.largeSceneMode, targetRenderFps: this.targetRenderIntervalMs > 0 ? Math.round(1000 / this.targetRenderIntervalMs) : 60, + actualRenderFps: this.measuredRenderFps, renderPixelRatio: this.renderer.getPixelRatio(), shadowsEnabled: this.renderer.shadowMap.enabled, + renderSkipCount: this.renderSkipCount, + lastRenderDurationMs: this.lastRenderDurationMs, + hoverPickIntervalMs: this.hoverPickIntervalMs, loadedMeshCount: this.loadedMeshCount, fallbackCount: this.fallbackCount, editableGroupCount: this.editableGroups.size, @@ -388,6 +404,7 @@ export class UniversalPreviewer { private configurePerformanceForManifest(manifest: SceneManifest): void { this.largeSceneMode = manifest.objects.length > 300; this.targetRenderIntervalMs = this.largeSceneMode ? 1000 / 30 : 0; + this.hoverPickIntervalMs = this.largeSceneMode ? 32 : 0; const pixelRatioCap = this.largeSceneMode ? 1.25 : 2; this.renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, pixelRatioCap)); this.renderer.shadowMap.enabled = !this.largeSceneMode; @@ -412,24 +429,42 @@ export class UniversalPreviewer { const now = performance.now(); const controlsChanged = this.controls.update(); const focusChanged = this.updateFocusMarker(); - const elapsed = this.clock.getElapsedTime(); - let spinChanged = false; - this.root.traverse((child) => { - if (child.userData.spin) { - child.rotation.y = elapsed * 0.6; - spinChanged = true; - } - }); + const spinChanged = this.updateSpinningObjects(this.clock.getElapsedTime()); const enoughTimeElapsed = this.targetRenderIntervalMs <= 0 || now - this.lastRenderAt >= this.targetRenderIntervalMs; if (!enoughTimeElapsed || (!this.renderDirty && !controlsChanged && !focusChanged && !spinChanged)) { + this.renderSkipCount += 1; return; } this.frameCount += 1; this.lastRenderAt = now; this.renderDirty = false; + const renderStartedAt = performance.now(); this.renderer.render(this.scene, this.camera); + this.lastRenderDurationMs = performance.now() - renderStartedAt; + this.updateRenderFps(performance.now()); }; + private updateSpinningObjects(elapsed: number): boolean { + if (this.spinningObjects.length === 0) { + return false; + } + for (const object of this.spinningObjects) { + object.rotation.y = elapsed * 0.6; + } + return true; + } + + private updateRenderFps(now: number): void { + this.renderWindowFrameCount += 1; + const elapsedMs = now - this.renderWindowStartedAt; + if (elapsedMs < 1000) { + return; + } + this.measuredRenderFps = (this.renderWindowFrameCount * 1000) / elapsedMs; + this.renderWindowFrameCount = 0; + this.renderWindowStartedAt = now; + } + private setupCameraInput(): void { const canvas = this.renderer.domElement; canvas.addEventListener("contextmenu", (event) => event.preventDefault()); @@ -692,6 +727,11 @@ export class UniversalPreviewer { if (this.currentMode === "dragging") { return; } + const now = performance.now(); + if (this.hoverPickIntervalMs > 0 && now - this.lastHoverPickAt < this.hoverPickIntervalMs) { + return; + } + this.lastHoverPickAt = now; const pick = this.pickAnyObject(event); this.setHoverFromPick(pick); } @@ -747,6 +787,9 @@ export class UniversalPreviewer { this.objectsById.clear(); this.objectBodyIds.clear(); this.editableGroups.clear(); + this.pickRoots.length = 0; + this.editablePickRoots.length = 0; + this.spinningObjects.length = 0; this.bodySourceOffsets.clear(); this.bodyVisualOffsets.clear(); this.robotObjectIds.clear(); @@ -758,6 +801,12 @@ export class UniversalPreviewer { this.loadedMeshCount = 0; this.fallbackCount = 0; this.lastFrame = undefined; + this.frameCount = 0; + this.renderSkipCount = 0; + this.lastRenderDurationMs = 0; + this.measuredRenderFps = 0; + this.renderWindowFrameCount = 0; + this.renderWindowStartedAt = performance.now(); this.markRenderDirty(); } @@ -1024,7 +1073,7 @@ export class UniversalPreviewer { } this.updatePointerFromEvent(event); this.raycaster.setFromCamera(this.pointer, this.camera); - const intersects = this.raycaster.intersectObjects(this.root.children, true); + const intersects = this.raycaster.intersectObjects(this.editablePickRoots, true); for (const hit of intersects) { const manifestId = this.extractManifestId(hit.object); if (!manifestId) { @@ -1050,7 +1099,7 @@ export class UniversalPreviewer { } this.updatePointerFromEvent(event); this.raycaster.setFromCamera(this.pointer, this.camera); - const intersects = this.raycaster.intersectObjects(this.root.children, true); + const intersects = this.raycaster.intersectObjects(this.pickRoots, true); for (const hit of intersects) { const manifestId = this.extractManifestId(hit.object); if (!manifestId) { @@ -1367,6 +1416,8 @@ export class UniversalPreviewer { root.add(visual); } this.root.add(root); + this.pickRoots.push(root); + this.registerSpinningObjects(root); this.objectsById.set(object.id, { manifest: object, root }); if (object.editableGroup) { const group = this.editableGroups.get(object.editableGroup) ?? []; @@ -1411,6 +1462,33 @@ export class UniversalPreviewer { } }); await Promise.all(workers); + this.refreshEditablePickRoots(); + } + + private refreshEditablePickRoots(): void { + this.editablePickRoots.length = 0; + const roots = new Set(); + for (const id of this.editableObjectIds) { + const root = this.objectsById.get(id)?.root; + if (root) { + roots.add(root); + } + } + for (const id of this.robotObjectIds) { + const root = this.objectsById.get(id)?.root; + if (root) { + roots.add(root); + } + } + this.editablePickRoots.push(...roots); + } + + private registerSpinningObjects(root: THREE.Object3D): void { + root.traverse((child) => { + if (child.userData.spin === true) { + this.spinningObjects.push(child); + } + }); } private async createVisual(geometry: PreviewGeometry, materialId: string | undefined, token: number): Promise { diff --git a/src/types.ts b/src/types.ts index 02aacf1..cffa5c6 100644 --- a/src/types.ts +++ b/src/types.ts @@ -189,8 +189,12 @@ export interface RendererStats { bodyBoundObjectCount: number; largeSceneMode: boolean; targetRenderFps: number; + actualRenderFps: number; renderPixelRatio: number; shadowsEnabled: boolean; + renderSkipCount: number; + lastRenderDurationMs: number; + hoverPickIntervalMs: number; loadedMeshCount: number; fallbackCount: number; editableGroupCount: number;