three-blocks-benchmark 0.5.0 → 0.5.1-alpha.390.ga7db0265ceed

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # three-blocks-benchmark
 
+## 0.5.1-alpha.390.ga7db0265ceed
+
+- Packages: This alpha contains no user-facing changes.
+
+- Packages: Built from `a7db0265ceed`.
+
+
+## 0.5.1
+
+### Patch Changes
+
+- aa1d655: Packages: Gaussian benchmarks no longer charge display-frame waits to SuperSplat.
+- aa1d655: Packages: Gaussian splats now use one full-quality default in the library and benchmark.
+- aa1d655: Packages: Splats use less memory, with full frame benchmarks for r186 and SuperSplat 3.
+- Updated dependencies [aa1d655]
+- Updated dependencies [aa1d655]
+- Updated dependencies [aa1d655]
+- Updated dependencies [aa1d655]
+- Updated dependencies [aa1d655]
+- Updated dependencies [aa1d655]
+  - three-blocks@0.12.0
+
 ## 0.5.0
 
 ### Minor Changes

package/NOTICE

@@ -13,9 +13,8 @@ https://threejs-blocks.com/license
 Third-party code
 ================
 
-vendor/three-gs/ contains verbatim copies of three.js addon files from the
-unmerged pull request https://github.com/mrdoob/three.js/pull/33950, used to
-benchmark that implementation. They remain under the MIT License,
-Copyright (c) 2010-2026 three.js authors:
-https://github.com/mrdoob/three.js/blob/dev/LICENSE
-See vendor/three-gs/README.md for the pinned commit and file digests.
+vendor/supersplat-editor/ contains verbatim sources from SuperSplat Editor v3.0.0.
+They remain under the upstream MIT License, included at
+vendor/supersplat-editor/LICENSE. See vendor/README.md and the accompanying
+manifest.json for the pinned commit and file digests.
+https://github.com/playcanvas/supersplat/tree/v3.0.0

package/README.md

@@ -1,14 +1,18 @@
 # three-blocks-benchmark
 
-Reproducible browser benchmarks for Three Blocks, the three.js `GaussianSplat`
-addon ([merged into `dev`][pr], vendored with the `dev` build it needs — see
-`vendor/README.md`), Spark, SuperSplat, GaussianSplats3D, and Babylon.js.
+Reproducible browser benchmarks for Three Blocks, the official three.js r186
+`GaussianSplat` addon, Spark, SuperSplat Viewer 1.31.2, SuperSplat Editor 3.0.0's
+renderer, GaussianSplats3D, and Babylon.js.
 
-[pr]: https://github.com/mrdoob/three.js/pull/33950
 The default `standard` suite uses fixed held-out cameras from Mip-NeRF 360
 Bonsai and a pinned NerfBaselines Graphdeco 30K artifact. The synthetic
 `micro` suite is performance-only.
 
+Three Blocks uses its default and only preset, `quality`, at native resolution.
+It uses full-precision depth keys and wider Gaussian support cropped at the
+fragment alpha threshold. Load, frame time, memory, and image quality all use
+that same configuration.
+
 Published results and methodology:
 <https://threejs-blocks.com/benchmark/gaussian>
 
@@ -59,9 +63,39 @@ a micro scene.
 `--revision <value>` and `--dirty` add optional repository metadata; neither
 Git nor a checkout is required.
 
-The CLI runs headless Chromium by default. On macOS it forces the Metal ANGLE
-backend, without which headless Chromium selects SwiftShader and captures blank
-frames. Use `--headed` to watch a run; the recorded metrics are the same.
+The CLI uses full Chromium in headless mode, including the Metal ANGLE backend
+on macOS. Publication runs reject software GPU adapters.
+Memory sampling uses [Chromium's `ForceEagerMeasureMemory` test mode][eager-memory] after
+forced GC, outside the load and frame clocks, to avoid waiting for idle GC.
+
+[eager-memory]: https://chromium.googlesource.com/chromium/src/+/refs/tags/143.0.7458.0/third_party/blink/web_tests/VirtualTestSuites
+
+Frame timing directly executes each renderer's frame, without waiting for a display
+refresh, and cycles through the three held-out cameras. SuperSplat's complete viewer
+tick is driven directly and uses its WebGPU GPU-sort pipeline. Every timed frame
+completes its current-camera sort, index upload and GPU draw. GaussianSplats3D
+forces a complete visible-set sort and waits for its applied worker result;
+Babylon waits for the matching camera sort request to be applied. These are
+serial camera-to-image latencies, not pipelined interactive FPS. Worker completion
+counts are recorded, and a run fails if any timed frame lacks a complete sort.
+Quality captures use a settled camera and are measured separately.
+
+The September 9 timing correction replaces earlier draw-only figures: the tight
+loop starved worker-result messages in GaussianSplats3D and Babylon.js. Those
+old timings must not be compared with the current complete-frame measurements.
+GaussianSplats3D supports SH2 maximum and therefore omits the third band of the
+shared SH3 PLY; its effective degree is recorded and labeled on the website.
+
+The Editor 3.0 column runs its verbatim projector, radix sorter and draw shaders
+with sorted transparency and fp16 accumulation; it excludes editor UI and the
+motion-adaptive stochastic mode. It consumes resident PLY bytes using the
+loader's `MemoryReadFileSystem`, so page memory includes the retained source
+PLY. This does not reproduce the editor's file-backed memory figures. See
+`vendor/README.md` for provenance. The viewer is a separate product and column.
+
+Use `--renderer <id>` for a focused check. A partial run is never labeled
+publication evidence. All WebGL2 timings include a 1×1 GPU readback; WebGPU
+timings wait for queue completion.
 
 Standard reports contain neutral PSNR and dm_pix-compatible SSIM versus ground
 truth. Metrics versus the pinned NerfBaselines Graphdeco 30K prediction are

package/bin/three-blocks-benchmark.mjs

@@ -19,6 +19,7 @@ Options:
   --report <file>            Write the JSON report to a different path
   --capture-url-prefix <url> Prefix capture paths stored in the report
   --scene <id>               Select a micro scene
+  --renderer <id>            Validate one renderer (not publication evidence)
   --quick                    Use one view/scene and short measurements
   --omit-captures            Write metrics JSON without renderer captures
   --headed                   Show Chromium
@@ -42,7 +43,7 @@ function parseArgs( rawArgs ) {
 		else if ( argument === '--headless' ) options.headed = false;
 		else if ( argument === '--dirty' ) options.workingTreeDirty = true;
 		else if ( argument === '--clean' ) options.workingTreeDirty = false;
-		else if ( [ '--suite', '--output', '--cache', '--report', '--capture-url-prefix', '--scene', '--revision' ].includes( argument ) ) {
+		else if ( [ '--suite', '--output', '--cache', '--report', '--capture-url-prefix', '--scene', '--renderer', '--revision' ].includes( argument ) ) {
 
 			const value = rawArgs[ ++ index ];
 			if ( ! value || value.startsWith( '--' ) ) throw new Error( `${argument} requires a value.` );
@@ -53,6 +54,7 @@ function parseArgs( rawArgs ) {
 				'--report': 'report',
 				'--capture-url-prefix': 'captureUrlPrefix',
 				'--scene': 'scene',
+				'--renderer': 'renderer',
 				'--revision': 'revision',
 			}[ argument ];
 			options[ key ] = value;

package/browser/harness.js

@@ -6,6 +6,7 @@ import {
 	createScenePLY,
 	playCanvasEulerFromMatrix,
 } from './scenes.js';
+import { sortBabylon, sortGS3D } from './worker-sort.js';
 
 const BACKGROUND = 0x070a0f;
 const canvas = document.querySelector( '#viewport' );
@@ -13,6 +14,7 @@ const status = document.querySelector( '#status' );
 const query = new URLSearchParams( location.search );
 const rendererId = __BENCHMARK_RENDERER__;
 const suiteId = query.get( 'suite' ) ?? 'micro';
+let benchmarkPhase = 'load';
 let scene = SCENES.find( candidate => candidate.id === query.get( 'scene' ) );
 let benchmarkViewport = VIEWPORT;
 let benchmarkPose = QUALITY_CAMERA;
@@ -90,17 +92,16 @@ async function createThreeBlocks( bytes ) {
 	// dilation, and reference view-Z ordering.
 	const standard = suiteId === 'standard';
 	const compositing = query.get( 'compositing' ) ?? ( standard ? 'display' : 'linear' );
-	const sortPrecision = query.get( 'sortprec' ) ?? 'float16';
+	const sortPrecision = query.get( 'sortprec' );
 	const parseOptions = {
 		enableSH: standard,
-		shDegree: standard ? 3 : 0,
+		shDegree: query.has( 'shdegree' ) ? Number( query.get( 'shdegree' ) ) : ( standard ? 3 : 0 ),
 		coordinateSystem: 'threejs',
 		compositing,
-		sortPrecision,
+		...( sortPrecision ? { sortPrecision } : {} ),
 		sortMode: query.get( 'sortmode' ) ?? ( standard ? 'depth' : 'radial' ),
 		...( standard ? { preBlurAmount: 0.3, blurAmount: 0 } : {} ),
 		...( query.has( 'maxstddev' ) ? { maxStdDev: Number( query.get( 'maxstddev' ) ) } : {} ),
-		...( query.has( 'quality' ) ? { quality: query.get( 'quality' ) } : {} ),
 		...( query.has( 'fragclip' ) ? { fragmentAlphaClip: Number( query.get( 'fragclip' ) ) } : {} ),
 		...( query.has( 'shformat' ) ? { shFormat: query.get( 'shformat' ) } : {} ),
 		...( standard ? { maxBufferBytes: shBufferBytes } : {} ),
@@ -230,8 +231,8 @@ async function createThreeGS( bytes ) {
 
 	const [ THREE, { GaussianSplatPLYLoader }, { GaussianSplat } ] = await Promise.all( [
 		import( 'three/webgpu' ),
-		import( '../vendor/three-gs/loaders/GaussianSplatPLYLoader.js' ),
-		import( '../vendor/three-gs/objects/GaussianSplat.js' ),
+		import( 'three-r186/addons/loaders/GaussianSplatPLYLoader.js' ),
+		import( 'three-r186/addons/objects/GaussianSplat.js' ),
 	] );
 	const renderer = new THREE.WebGPURenderer( {
 		canvas,
@@ -321,13 +322,14 @@ async function createSpark( bytes ) {
 	await splats.initialized;
 
 	const gl = renderer.getContext();
+	const fencePixel = new Uint8Array( 4 );
 	const render = async pose => {
 
 		setThreeCamera( camera, pose );
 		renderer.getDrawingBufferSize( spark.renderSize );
 		await spark.update( { scene: scene3d, camera } );
 		renderer.render( scene3d, camera );
-		gl.finish();
+		gl.readPixels( 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, fencePixel );
 
 	};
 	await render( benchmarkPose );
@@ -375,7 +377,8 @@ async function createGS3D( bytes ) {
 		camera,
 		useBuiltInControls: false,
 		sharedMemoryForWorkers,
-		sphericalHarmonicsDegree: 3,
+		// 0.4.7's PLY loader and shader support at most degree 2.
+		sphericalHarmonicsDegree: suiteId === 'standard' ? 2 : 0,
 		logLevel: 0,
 		// Faithful-viewing configuration: render the whole checkpoint immediately instead of
 		// the default progressive reveal animation, whose expanding visible region leaves
@@ -404,11 +407,14 @@ async function createGS3D( bytes ) {
 		await viewer.addSplatScene( sceneUrl, sceneOptions );
 
 	}
+	const sortCompletions = { load: 0, warmup: 0, measure: 0, capture: 0 };
 	const gl = renderer.getContext();
 	const fencePixel = new Uint8Array( 4 );
 	const render = async pose => {
 
 		setThreeCamera( camera, pose );
+		await sortGS3D( viewer );
+		sortCompletions[ benchmarkPhase ] ++;
 		viewer.update();
 		viewer.render();
 		// gl.finish() alone is not a reliable completion fence under ANGLE-Metal; a 1x1
@@ -425,6 +431,10 @@ async function createGS3D( bytes ) {
 			return {
 				reportedGpuBytes: null,
 				reportedGpuBytesScope: null,
+				shDegree: viewer.splatMesh.minSphericalHarmonicsDegree,
+				sortCompletions,
+				splatRenderCount: viewer.splatRenderCount,
+				lastWorkerSortMilliseconds: viewer.lastSortTime,
 				webgl: webGLInfo( gl ),
 			};
 
@@ -494,14 +504,18 @@ async function createBabylon( bytes ) {
 	splats.scaling.set( 1, 1, 1 );
 	splats.rotationQuaternion = new Quaternion( 1, 0, 0, 0 );
 
+	const sortCompletions = { load: 0, warmup: 0, measure: 0, capture: 0 };
 	const gl = canvas.getContext( 'webgl2' );
 	const fencePixel = new Uint8Array( 4 );
 	const render = async pose => {
 
 		setBabylonCamera( pose );
+		camera.getViewMatrix( true );
+		await sortBabylon( splats, camera );
+		sortCompletions[ benchmarkPhase ] ++;
 		scene3d.render();
-		// Babylon depth-sorts on a worker outside the frame (like GS3D and SuperSplat); the
-		// timed frame is the raster. The 1x1 readback forces true GPU completion.
+		if ( ! splats._isDepthSortSettled ) throw new Error( 'Babylon started an unexpected sort during draw.' );
+		// The timed frame includes worker sorting, index upload and rasterization.
 		gl.readPixels( 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, fencePixel );
 
 	};
@@ -523,6 +537,7 @@ async function createBabylon( bytes ) {
 				reportedGpuBytes: null,
 				reportedGpuBytesScope: null,
 				shDegree: splats.shDegree,
+				sortCompletions,
 				webgl: webGLInfo( gl ),
 			};
 
@@ -641,9 +656,11 @@ async function createSuperSplat( bytes, requestedBackend ) {
 	const render = async pose => {
 
 		setSuperSplatCamera( viewer, pose );
-		const frameEnd = new Promise( resolve => app.once( 'frameend', resolve ) );
 		app.renderNextFrame = true;
-		await frameEnd;
+		// Drive the complete viewer tick directly, as the other adapters do. Waiting
+		// for its next rAF charges display scheduling to SuperSplat alone.
+		app.tick( performance.now() );
+		cancelAnimationFrame( app.frameRequestId );
 		const device = app.graphicsDevice;
 		await device.wgpu?.queue?.onSubmittedWorkDone?.();
 		device.gl?.finish?.();
@@ -696,7 +713,7 @@ async function measureBrowserMemory() {
 async function run() {
 
 	if ( ! [ 'standard', 'micro' ].includes( suiteId ) ) throw new Error( `Unknown suite: ${suiteId}` );
-	if ( ! [ 'three-blocks', 'three-gs', 'spark', 'supersplat', 'gs3d', 'babylon' ].includes( rendererId ) ) {
+	if ( ! [ 'three-blocks', 'three-gs', 'spark', 'supersplat', 'supersplat-editor', 'gs3d', 'babylon' ].includes( rendererId ) ) {
 
 		throw new Error( `Unknown renderer: ${rendererId}` );
 
@@ -719,7 +736,7 @@ async function run() {
 		canvas.style.height = `${view.height}px`;
 		// Three Blocks streams the PLY read through its Response-based parse API inside the
 		// adapter (fetch and parse overlap); the other runtimes consume resident bytes.
-		if ( rendererId !== 'three-blocks' ) {
+		if ( ! rendererId.startsWith( 'three-blocks' ) ) {
 
 			loadMarks.fetchStart = performance.now();
 			bytes = await fetch( '/standard/point_cloud.ply' ).then( response => response.arrayBuffer() );
@@ -734,10 +751,16 @@ async function run() {
 
 	}
 	let adapter;
-	if ( rendererId === 'three-blocks' ) adapter = await createThreeBlocks( bytes );
+	if ( rendererId.startsWith( 'three-blocks' ) ) adapter = await createThreeBlocks( bytes );
 	if ( rendererId === 'three-gs' ) adapter = await createThreeGS( bytes );
 	if ( rendererId === 'spark' ) adapter = await createSpark( bytes );
 	if ( rendererId === 'supersplat' ) adapter = await createSuperSplat( bytes, 'webgpu' );
+	if ( rendererId === 'supersplat-editor' ) {
+
+		const { createSuperSplatEditor } = await import( './supersplat-editor.js' );
+		adapter = await createSuperSplatEditor( canvas, bytes, benchmarkFileName, benchmarkViewport, benchmarkPose, suiteId );
+
+	}
 	if ( rendererId === 'gs3d' ) adapter = await createGS3D( bytes );
 	if ( rendererId === 'babylon' ) adapter = await createBabylon( bytes );
 	const loadMilliseconds = performance.now();
@@ -745,11 +768,13 @@ async function run() {
 		? cameraPose( frame )
 		: benchmarkPoses[ frame % benchmarkPoses.length ];
 
+	benchmarkPhase = 'warmup';
 	for ( let frame = 0; frame < warmupFrames; frame ++ ) {
 
 		await adapter.render( measurementPose( frame ) );
 
 	}
+	benchmarkPhase = 'measure';
 	const frameSamplesMilliseconds = [];
 	for ( let frame = 0; frame < measureFrames; frame ++ ) {
 
@@ -758,11 +783,23 @@ async function run() {
 		frameSamplesMilliseconds.push( performance.now() - start );
 
 	}
-	await adapter.render( benchmarkPose );
+	// Keep the same stationary capture protocol for every renderer, outside timing.
+	benchmarkPhase = 'capture';
+	for ( let frame = 0; frame < warmupFrames; frame ++ ) {
+
+		await new Promise( resolve => requestAnimationFrame( resolve ) );
+		await adapter.render( benchmarkPose );
+
+	}
 	const [ memory, diagnostics ] = await Promise.all( [
 		measureBrowserMemory(),
 		adapter.diagnostics(),
 	] );
+	if ( [ 'gs3d', 'babylon' ].includes( rendererId ) && diagnostics.sortCompletions.measure !== measureFrames ) {
+
+		throw new Error( `${rendererId}: every measured frame must apply a complete camera sort.` );
+
+	}
 	const resources = performance.getEntriesByType( 'resource' );
 	return {
 		renderer: rendererId,

package/browser/supersplat-editor.js

@@ -0,0 +1,118 @@
+import * as pc from 'playcanvas';
+import { MemoryReadFileSystem } from '@playcanvas/splat-transform';
+import { ProjectedSplatRenderer } from '../vendor/supersplat-editor/src/projected-splat-renderer.ts';
+import { EditorSplatResource } from '../vendor/supersplat-editor/src/editor-splat-resource.ts';
+import { GaussianInstances } from '../vendor/supersplat-editor/src/gaussian-instances.ts';
+import { TransformPalette } from '../vendor/supersplat-editor/src/transform-palette.ts';
+import { ColorPalette } from '../vendor/supersplat-editor/src/color-palette.ts';
+import { Events } from '../vendor/supersplat-editor/src/events.ts';
+import { loadSplatSource } from '../vendor/supersplat-editor/src/io/read/index.ts';
+import { ShaderQuad, SimpleRenderPass } from '../vendor/supersplat-editor/src/utils/simple-render-pass.ts';
+import { vertexShader, fragmentShader } from '../vendor/supersplat-editor/src/shaders/blit-shader.ts';
+import { playCanvasEulerFromMatrix } from './scenes.js';
+
+// The v3 editor's actual loader, GPU projector, radix sorter and draw shaders.
+// This adapter supplies a neutral scene, with editing overlays disabled. It does
+// not measure the editor UI or substitute the separately shipped viewer.
+export async function createSuperSplatEditor( canvas, bytes, filename, viewport, initialPose, suite ) {
+
+	const device = await pc.createGraphicsDevice( canvas, {
+		deviceTypes: [ 'webgpu' ], antialias: false, alpha: false,
+		powerPreference: 'high-performance',
+	} );
+	const app = new pc.Application( canvas, { graphicsDevice: device } );
+	device.maxPixelRatio = viewport.dpr;
+	app.setCanvasResolution( pc.RESOLUTION_FIXED, viewport.width, viewport.height );
+	const mainCamera = new pc.Entity( 'benchmark-camera' );
+	mainCamera.addComponent( 'camera', {
+		nearClip: 0.01, farClip: 100,
+		// gsplatOutputVS passes display-space RGB unchanged with this combination.
+		toneMapping: pc.TONEMAP_NONE, gammaCorrection: pc.GAMMA_SRGB,
+		clearColor: suite === 'standard' ? new pc.Color( 0, 0, 0, 1 ) : new pc.Color( 7 / 255, 10 / 255, 15 / 255, 1 ),
+	} );
+	app.root.addChild( mainCamera );
+	const events = new Events();
+	const neutral = {
+		selection: null, selectedClr: pc.Color.WHITE, unselectedClr: pc.Color.WHITE, lockedClr: pc.Color.WHITE,
+		'view.bands': suite === 'standard' ? 3 : 0, 'view.minPixelSize': 0,
+		'colorPanel.pending': null, 'view.outlineSelection': false, 'view.editView': false,
+		'view.gaussians': true, 'view.selectionColor': false, 'view.rings': false,
+		'view.selectionRings': false, 'view.splatsColorBlend': 0, 'view.ringsColorBlend': 0,
+	};
+	for ( const [ name, value ] of Object.entries( neutral ) ) events.function( name, () => value );
+	const scene = {
+		app, graphicsDevice: device, events,
+		splatLayer: app.scene.layers.getLayerById( pc.LAYERID_WORLD ),
+		camera: { camera: mainCamera.camera, mainCamera, renderOverlays: false },
+		targetSize: viewport, movingRender: false,
+	};
+	const projected = new ProjectedSplatRenderer( scene );
+	// A resident PLY input, as in the other byte-based adapters. Its retained
+	// bytes count towards page memory; this is not the editor's file-backed heap.
+	const fileSystem = new MemoryReadFileSystem();
+	fileSystem.set( filename, new Uint8Array( bytes ) );
+	const { source } = await loadSplatSource( filename, fileSystem );
+	const resource = await EditorSplatResource.create( device, source );
+	const entity = new pc.Entity( 'benchmark-splats' );
+	entity.setLocalEulerAngles( 180, 0, 0 );
+	app.root.addChild( entity );
+	const instances = new GaussianInstances( device, resource.numRows, resource.initialState );
+	instances.flush();
+	projected.add( {
+		uid: 0, visible: true, entity, resource,
+		instances,
+		transformPalette: new TransformPalette( device ),
+		colorPalette: new ColorPalette( device ),
+	} );
+	// Match the editor's fp16 accumulation, second overlay attachment and native
+	// resolve. The sorted path uses the upstream blit's unfiltered mode.
+	const colorBuffer = new pc.Texture( device, {
+		name: 'benchmark-color', width: viewport.width, height: viewport.height,
+		format: pc.PIXELFORMAT_RGBA16F, mipmaps: false,
+	} );
+	const overlay = new pc.Texture( device, {
+		name: 'benchmark-overlay', width: viewport.width, height: viewport.height,
+		format: pc.PIXELFORMAT_RGBA8, mipmaps: false,
+	} );
+	mainCamera.camera.renderTarget = new pc.RenderTarget( { colorBuffers: [ colorBuffer, overlay ], depth: true } );
+	const resolve = new SimpleRenderPass( device, new ShaderQuad( device, vertexShader, fragmentShader, 'benchmark-resolve' ), {
+		vars: () => ( { srcTexture: colorBuffer, blitScale: [ 1, 1 ], quadResolve: 0 } ),
+	} );
+	resolve.init( null );
+	app.on( 'prerender', () => projected.render() );
+	app.on( 'postrender', () => resolve.render() );
+	const render = async pose => {
+
+		mainCamera.camera.fov = pose.fov;
+		if ( pose.matrix ) {
+
+			mainCamera.setPosition( pose.matrix[ 12 ], pose.matrix[ 13 ], pose.matrix[ 14 ] );
+			mainCamera.setEulerAngles( ...playCanvasEulerFromMatrix( pose.matrix ) );
+
+		} else {
+
+			mainCamera.setPosition( ...pose.position );
+			mainCamera.lookAt( new pc.Vec3( ...pose.target ) );
+
+		}
+		app.update( 0 );
+		app.render();
+		await device.wgpu.queue.onSubmittedWorkDone();
+
+	};
+	await render( initialPose );
+	return {
+		backend: device.deviceType === 'webgpu' ? 'WebGPU' : device.deviceType,
+		render,
+		async diagnostics() {
+
+			return {
+				reportedGpuBytes: projected.stats.totalSplatGpuBytes,
+				reportedGpuBytesScope: 'SuperSplat Editor source, editing and estimated transient splat resources',
+				rendererMode: 'sorted', splatCount: resource.numRows, engineVersion: pc.version,
+			};
+
+		},
+	};
+
+}

package/browser/worker-sort.js

@@ -0,0 +1,56 @@
+// Version-specific benchmark integration: the frame clock ends only after the
+// requested camera's full ordering is installed, including worker round trips.
+export async function sortGS3D( viewer ) {
+
+	if ( viewer.sortRunning ) throw new Error( 'GaussianSplats3D still has a previous camera sort in flight.' );
+	// runSplatSort resolves after GPU distance readback and posting the worker;
+	// sortPromise resolves later, after updateRenderIndexes applies its result.
+	await viewer.runSplatSort( true, true );
+	await viewer.sortPromise;
+	if ( viewer.sortRunning || viewer.lastSplatSortCount !== viewer.splatRenderCount ) {
+
+		throw new Error( 'GaussianSplats3D did not apply a complete current-camera sort.' );
+
+	}
+
+}
+
+export async function sortBabylon( splats, camera ) {
+
+	const worker = splats._worker;
+	if ( ! worker ) throw new Error( 'Babylon Gaussian sort worker is unavailable.' );
+	await new Promise( ( resolve, reject ) => {
+
+		let requestId;
+		const finish = error => {
+
+			clearTimeout( timeout );
+			worker.removeEventListener( 'message', advance );
+			worker.removeEventListener( 'error', failed );
+			if ( error ) reject( error ); else resolve();
+
+		};
+		const failed = () => finish( new Error( 'Babylon Gaussian sort worker failed.' ) );
+		const advance = () => {
+
+			if ( ! splats._canPostToWorker ) return;
+			if ( requestId !== undefined ) {
+
+				const applied = splats._cameraViewInfos.get( camera.uniqueId )?.sortAppliedId;
+				finish( applied === requestId ? null : new Error( 'Babylon applied a different camera sort.' ) );
+				return;
+
+			}
+			splats._postToWorker( true );
+			requestId = splats._cameraViewInfos.get( camera.uniqueId )?.sortRequestId;
+			if ( requestId === undefined || splats._canPostToWorker ) failed();
+
+		};
+		const timeout = setTimeout( failed, 30_000 );
+		worker.addEventListener( 'message', advance );
+		worker.addEventListener( 'error', failed );
+		advance();
+
+	} );
+
+}