three-blocks-benchmark 0.2.1 → 0.3.0-alpha.320.g7e6e67cd7214

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # three-blocks-benchmark
 
+## 0.3.0-alpha.320.g7e6e67cd7214
+
+- Website: Stripe billing events now reach the production webhook reliably.
+
+- Devtools: Loading no longer spins the status chip or terminal progress indicator.
+
+- Devtools: Vite asset config and inspection handle HDR files and report exact GPU memory.
+
+- Packages: Text projects hydrate precompiled shaders and stay crisp across display resolutions.
+
+- Packages: Gaussian benchmarks now compare Babylon.js and fully revealed GaussianSplats3D scenes.
+
+- Packages: Built from `7e6e67cd7214`.
+
+
 ## 0.2.1
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,7 @@
 # three-blocks-benchmark
 
-Reproducible browser benchmarks for Three Blocks, Spark, and SuperSplat.
+Reproducible browser benchmarks for Three Blocks, Spark, SuperSplat,
+GaussianSplats3D, and Babylon.js.
 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.

package/browser/harness.js

@@ -317,6 +317,10 @@ async function createGS3D( bytes ) {
 		sharedMemoryForWorkers,
 		sphericalHarmonicsDegree: 3,
 		logLevel: 0,
+		// Faithful-viewing configuration: render the whole checkpoint immediately instead of
+		// the default progressive reveal animation, whose expanding visible region leaves
+		// distant splats black until enough update() calls have elapsed.
+		sceneRevealMode: GaussianSplats3D.SceneRevealMode.Instant,
 	} );
 	// The dataset PLY is in source (COLMAP-style Y-down) space; the suite's other meshes
 	// carry an Rx180 model transform, so give GS3D the identical scene rotation.
@@ -369,6 +373,104 @@ async function createGS3D( bytes ) {
 
 }
 
+async function createBabylon( bytes ) {
+
+	const [ { Engine }, { Scene }, { TargetCamera }, { Matrix, Quaternion, Vector3 }, { Color4 }, { ImportMeshAsync } ] = await Promise.all( [
+		import( '@babylonjs/core/Engines/engine.js' ),
+		import( '@babylonjs/core/scene.js' ),
+		import( '@babylonjs/core/Cameras/targetCamera.js' ),
+		import( '@babylonjs/core/Maths/math.vector.js' ),
+		import( '@babylonjs/core/Maths/math.color.js' ),
+		import( '@babylonjs/core/Loading/sceneLoader.js' ),
+		// Registers the SPLAT/PLY scene-loader plugin (side effect).
+		import( '@babylonjs/loaders/SPLAT/splatFileLoader.js' ),
+	] );
+	const engine = new Engine( canvas, false, {
+		antialias: false,
+		alpha: false,
+		preserveDrawingBuffer: true,
+		powerPreference: 'high-performance',
+	} );
+	engine.setSize( benchmarkViewport.width, benchmarkViewport.height );
+	const scene3d = new Scene( engine );
+	scene3d.useRightHandedSystem = true;
+	scene3d.clearColor = suiteId === 'standard'
+		? new Color4( 0, 0, 0, 1 )
+		: new Color4( 7 / 255, 10 / 255, 15 / 255, 1 );
+	const camera = new TargetCamera( 'camera', Vector3.Zero(), scene3d );
+	camera.minZ = 0.01;
+	camera.maxZ = 100;
+	const setBabylonCamera = pose => {
+
+		camera.fov = pose.fov * Math.PI / 180;
+		if ( pose.matrix ) {
+
+			// Right-handed Babylon cameras share the three.js convention (forward -Z, up +Y),
+			// so the dataset camera-to-world matrix transfers directly. Babylon has no
+			// principal-point offset API; views render with a centered pinhole projection.
+			camera.updateUpVectorFromRotation = true;
+			if ( ! camera.rotationQuaternion ) camera.rotationQuaternion = new Quaternion();
+			Quaternion.FromRotationMatrixToRef(
+				Matrix.FromArray( pose.matrix ).getRotationMatrix(),
+				camera.rotationQuaternion,
+			);
+			camera.position.set( pose.matrix[ 12 ], pose.matrix[ 13 ], pose.matrix[ 14 ] );
+
+		} else {
+
+			camera.position.set( ...pose.position );
+			camera.setTarget( new Vector3( ...pose.target ) );
+
+		}
+
+	};
+	setBabylonCamera( benchmarkPose );
+
+	const result = await ImportMeshAsync( new File( [ bytes ], benchmarkFileName ), scene3d );
+	const splats = result.meshes[ 0 ];
+	// The dataset PLY is in source (COLMAP-style Y-down) space. The loader ships a Y-mirror
+	// (scaling.y = -1) for Babylon's default left-handed world; in this right-handed scene
+	// the suite's shared model transform is the proper rotation Rx180, so reset the mirror.
+	splats.scaling.set( 1, 1, 1 );
+	splats.rotationQuaternion = new Quaternion( 1, 0, 0, 0 );
+
+	const gl = canvas.getContext( 'webgl2' );
+	const fencePixel = new Uint8Array( 4 );
+	const render = async pose => {
+
+		setBabylonCamera( pose );
+		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.
+		gl.readPixels( 0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, fencePixel );
+
+	};
+	// Load ends at the first frame whose worker sort has been applied, so the first
+	// counted frame really displays the scene.
+	while ( ! splats.isReady( true ) ) {
+
+		scene3d.render();
+		await new Promise( resolve => requestAnimationFrame( resolve ) );
+
+	}
+	await render( benchmarkPose );
+	return {
+		backend: 'WebGL2',
+		render,
+		async diagnostics() {
+
+			return {
+				reportedGpuBytes: null,
+				reportedGpuBytesScope: null,
+				shDegree: splats.shDegree,
+				webgl: webGLInfo( gl ),
+			};
+
+		},
+	};
+
+}
+
 function superSplatSettings() {
 
 	const initialFov = suiteId === 'standard' ? benchmarkPose.fov : QUALITY_CAMERA.fov;
@@ -534,7 +636,7 @@ async function measureBrowserMemory() {
 async function run() {
 
 	if ( ! [ 'standard', 'micro' ].includes( suiteId ) ) throw new Error( `Unknown suite: ${suiteId}` );
-	if ( ! [ 'three-blocks', 'spark', 'supersplat', 'gs3d' ].includes( rendererId ) ) {
+	if ( ! [ 'three-blocks', 'spark', 'supersplat', 'gs3d', 'babylon' ].includes( rendererId ) ) {
 
 		throw new Error( `Unknown renderer: ${rendererId}` );
 
@@ -576,6 +678,7 @@ async function run() {
 	if ( rendererId === 'spark' ) adapter = await createSpark( bytes );
 	if ( rendererId === 'supersplat' ) adapter = await createSuperSplat( bytes, 'webgpu' );
 	if ( rendererId === 'gs3d' ) adapter = await createGS3D( bytes );
+	if ( rendererId === 'babylon' ) adapter = await createBabylon( bytes );
 	const loadMilliseconds = performance.now();
 	const measurementPose = frame => suiteId === 'micro'
 		? cameraPose( frame )

package/lib/run.mjs

@@ -72,6 +72,15 @@ const RENDERERS = [
 		backend: 'WebGL2',
 		source: 'https://github.com/mkkellogg/GaussianSplats3D',
 	},
+	{
+		id: 'babylon',
+		label: 'Babylon.js',
+		version: '9.19.1',
+		backend: 'WebGL2',
+		source: 'https://github.com/BabylonJS/Babylon.js',
+		commit: 'c37eae3db20d04335d7cf4b2e6e4491070e2848d',
+		integrity: 'sha512-Uu2VchxBGBEEUh73YoobP1U5aNGO7AH4nZB2hs1azxd9fWxj5C1obIVs5wcA05fppAsYPJiNy/+HfaaPdoqbbQ==',
+	},
 ];
 
 function percentile( sorted, fraction ) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-blocks-benchmark",
-  "version": "0.2.1",
-  "description": "Reproducible Gaussian splat browser benchmarks for Three Blocks, Spark, and SuperSplat",
+  "version": "0.3.0-alpha.320.g7e6e67cd7214",
+  "description": "Reproducible Gaussian splat browser benchmarks for Three Blocks, Spark, SuperSplat, GaussianSplats3D, and Babylon.js",
   "keywords": [
     "three",
     "threejs",
@@ -44,12 +44,18 @@
     "prepack": "node --test tests/run.test.mjs"
   },
   "dependencies": {
+    "@babylonjs/core": "9.19.1",
+    "@babylonjs/loaders": "9.19.1",
     "@playcanvas/supersplat-viewer": "1.28.0",
     "@sparkjsdev/spark": "2.1.0",
     "playwright": "1.61.1",
     "pngjs": "7.0.0",
     "three": "0.185.1",
-    "three-blocks": "0.5.0",
+    "three-blocks": "0.6.0-alpha.320.g7e6e67cd7214",
     "vite": "8.1.3"
+  },
+  "threeBlocks": {
+    "channel": "alpha",
+    "site": "https://preprod.threejs-blocks.com"
   }
 }