three-blocks-benchmark 0.3.3 → 0.4.0-alpha.372.gf7fb70f4af27

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # three-blocks-benchmark
 
+## 0.4.0-alpha.372.gf7fb70f4af27
+
+- Tools: Installing a pro tool works again, and a cached tool refreshes itself when a new build ships.
+
+- Packages: Material environments capture reliably and transmission types expose surface distortion.
+
+- Starter: New projects install compatible devtools and run status without missing dependencies.
+
+- Website: Gaussian benchmark results now fit without horizontal page scrolling.
+
+- Website: Pages navigate faster and links stay aligned with available destinations.
+
+- Packages: Built from `f7fb70f4af27`.
+
+
 ## 0.3.3
 
 ### Patch Changes

package/NOTICE

@@ -9,3 +9,13 @@ https://polyformproject.org/licenses/noncommercial/1.0.0/
 LICENSE contains the controlling noncommercial terms. Commercial customers
 receive separate rights under the agreement they accept:
 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.

package/README.md

@@ -1,7 +1,10 @@
 # three-blocks-benchmark
 
-Reproducible browser benchmarks for Three Blocks, Spark, SuperSplat,
+Reproducible browser benchmarks for Three Blocks, the unmerged three.js
+`GaussianSplatMesh` addon ([PR #33950][pr]), Spark, SuperSplat,
 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.
@@ -29,11 +32,11 @@ Or run it with Bun:
 bunx three-blocks-benchmark --suite standard --quick --output ./benchmark-results
 ```
 
-Remove `--quick` for the publication run. Publication evidence requires headed
-Chromium on a physical GPU:
+Remove `--quick` for the publication run. Publication evidence requires a
+physical GPU:
 
 ```sh
-npx three-blocks-benchmark --suite standard --headed --output ./benchmark-results
+npx three-blocks-benchmark --suite standard --output ./benchmark-results
 ```
 
 The standard suite range-downloads and caches only the stored PLY, selected
@@ -56,9 +59,9 @@ a micro scene.
 `--revision <value>` and `--dirty` add optional repository metadata; neither
 Git nor a checkout is required.
 
-The CLI uses headed Chromium by default on macOS so WebGPU captures reach the
-physical GPU. `--headless` is available where the browser exposes a working
-WebGPU adapter in headless mode.
+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.
 
 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

@@ -22,7 +22,7 @@ Options:
   --quick                    Use one view/scene and short measurements
   --omit-captures            Write metrics JSON without renderer captures
   --headed                   Show Chromium
-  --headless                 Hide Chromium
+  --headless                 Hide Chromium (default)
   --revision <value>         Record an optional source revision
   --dirty                    Record that the source tree had changes
   --clean                    Record that the source tree was clean

package/browser/harness.js

@@ -226,6 +226,69 @@ async function createThreeBlocks( bytes ) {
 
 }
 
+async function createThreeGS( bytes ) {
+
+	const [ THREE, { PLYLoader }, { GaussianSplatMesh }, splatUtils ] = await Promise.all( [
+		import( 'three/webgpu' ),
+		import( 'three/addons/loaders/PLYLoader.js' ),
+		import( '../vendor/three-gs/objects/GaussianSplatMesh.js' ),
+		import( '../vendor/three-gs/utils/GaussianSplatUtils.js' ),
+	] );
+	const renderer = new THREE.WebGPURenderer( {
+		canvas,
+		antialias: false,
+		alpha: false,
+		powerPreference: 'high-performance',
+	} );
+	// The addon's own example keeps splat colors out of any transfer-function conversion by
+	// setting the working color space to sRGB; a LinearSRGB output space is the equivalent
+	// no-op here, and matches the display-space compositing the rest of the suite uses.
+	renderer.outputColorSpace = THREE.LinearSRGBColorSpace;
+	renderer.toneMapping = THREE.NoToneMapping;
+	renderer.setPixelRatio( benchmarkViewport.dpr );
+	renderer.setSize( benchmarkViewport.width, benchmarkViewport.height, false );
+	await renderer.init();
+
+	const scene3d = new THREE.Scene();
+	scene3d.background = new THREE.Color( suiteId === 'standard' ? 0 : BACKGROUND );
+	const camera = new THREE.PerspectiveCamera( benchmarkViewport.fov, benchmarkViewport.width / benchmarkViewport.height, 0.01, 100 );
+	setThreeCamera( camera, benchmarkPose );
+
+	// The PR reuses the stock PLYLoader plus a conversion helper rather than shipping its own
+	// splat PLY parser, so the benchmark loads it exactly that way.
+	const loader = new PLYLoader();
+	loader.setCustomPropertyNameMapping( splatUtils.GAUSSIAN_SPLAT_PLY_PROPERTY_MAPPING );
+	const splatGeometry = splatUtils.createGaussianSplatGeometryFromPLYGeometry( loader.parse( bytes ) );
+	const splats = new GaussianSplatMesh( splatGeometry );
+	// The dataset PLY is in source (COLMAP-style Y-down) space; apply the suite's shared Rx180
+	// model transform, as the other runtimes do.
+	splats.quaternion.set( 1, 0, 0, 0 );
+	scene3d.add( splats );
+
+	const render = async pose => {
+
+		setThreeCamera( camera, pose );
+		await renderer.render( scene3d, camera );
+		await renderer.backend?.device?.queue?.onSubmittedWorkDone?.();
+
+	};
+	await render( benchmarkPose );
+	return {
+		backend: 'WebGPU',
+		render,
+		async diagnostics() {
+
+			return {
+				reportedGpuBytes: null,
+				reportedGpuBytesScope: null,
+				splatCount: splatGeometry.getAttribute( 'position' ).count,
+			};
+
+		},
+	};
+
+}
+
 async function createSpark( bytes ) {
 
 	const [ THREE, { SparkRenderer, SplatMesh } ] = await Promise.all( [
@@ -636,7 +699,7 @@ async function measureBrowserMemory() {
 async function run() {
 
 	if ( ! [ 'standard', 'micro' ].includes( suiteId ) ) throw new Error( `Unknown suite: ${suiteId}` );
-	if ( ! [ 'three-blocks', 'spark', 'supersplat', 'gs3d', 'babylon' ].includes( rendererId ) ) {
+	if ( ! [ 'three-blocks', 'three-gs', 'spark', 'supersplat', 'gs3d', 'babylon' ].includes( rendererId ) ) {
 
 		throw new Error( `Unknown renderer: ${rendererId}` );
 
@@ -675,6 +738,7 @@ async function run() {
 	}
 	let adapter;
 	if ( rendererId === '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 === 'gs3d' ) adapter = await createGS3D( bytes );

package/lib/run.mjs

@@ -47,6 +47,14 @@ const RENDERERS = [
 		backend: 'WebGPU',
 		source: 'https://www.npmjs.com/package/three-blocks',
 	},
+	{
+		id: 'three-gs',
+		label: 'three.js splats',
+		version: 'PR #33950',
+		backend: 'WebGPU',
+		source: 'https://github.com/mrdoob/three.js/pull/33950',
+		commit: '5b8fcba16c8e0ab1e3745cd2c8185fe527998a36',
+	},
 	{
 		id: 'spark',
 		label: 'Spark',
@@ -275,11 +283,19 @@ async function runPage( browser, baseUrl, { renderer, suite, item, warmup, frame
 		} );
 		search.set( suite === 'standard' ? 'view' : 'scene', item.id );
 		await page.goto( `${baseUrl}/${renderer}/?${search}`, { waitUntil: 'domcontentloaded' } );
-		await page.waitForFunction(
-			() => window.__publicGaussianBenchmark && window.__publicGaussianBenchmark.status !== 'running',
-			null,
-			{ timeout: 300_000 },
-		);
+		try {
+
+			await page.waitForFunction(
+				() => window.__publicGaussianBenchmark && window.__publicGaussianBenchmark.status !== 'running',
+				null,
+				{ timeout: 300_000 },
+			);
+
+		} catch ( error ) {
+
+			throw new Error( `${renderer}/${item.id}: ${error.message}\n${diagnostics.join( '\n' )}` );
+
+		}
 		const report = await page.evaluate( () => window.__publicGaussianBenchmark );
 		if ( report.status !== 'ready' ) {
 
@@ -356,7 +372,7 @@ export async function runBenchmark( options ) {
 
 	}
 	const quick = options.quick === true;
-	const headed = options.headed ?? ( process.platform === 'darwin' );
+	const headed = options.headed ?? false;
 	const repetitions = quick ? 1 : 3;
 	// 60 settle frames: the frame lane reports each runtime's steady state at rest — long
 	// enough for idle-time optimizations (e.g. Three Blocks' auto tile promotion) to reach
@@ -414,10 +430,17 @@ export async function runBenchmark( options ) {
 				resolve: {
 					alias: [
 						{ find: 'supersplat-viewer-runtime', replacement: superSplatRuntime },
+						// Both loaders spell their worker as `new URL( './<name>.js', import.meta.url )` so
+						// bundlers emit the entry. The published chunks sit at the dist root, where those
+						// paths do not exist; point them at the real worker modules.
 						{
 							find: path.join( path.dirname( threeBlocksEntry ), 'SplatVideoInflateWorker.js' ),
 							replacement: threeBlocksInflateWorker,
 						},
+						{
+							find: path.join( path.dirname( threeBlocksEntry ), 'GaussianSplatsLoadWorker.js' ),
+							replacement: threeBlocksWorker,
+						},
 					],
 					dedupe: [ 'three' ],
 				},
@@ -457,15 +480,21 @@ export async function runBenchmark( options ) {
 		server = await serveDirectory( bundleRoot, externalFiles );
 		browser = await chromium.launch( {
 			headless: ! headed,
-			args: [ '--enable-unsafe-webgpu', '--js-flags=--expose-gc' ],
+			args: [
+				'--enable-unsafe-webgpu',
+				'--js-flags=--expose-gc',
+				// Headless Chromium on macOS otherwise picks SwiftShader, which fails the
+				// physical-GPU gate and captures blank frames.
+				...( process.platform === 'darwin' ? [ '--use-angle=metal' ] : [] ),
+			],
 		} );
 		const cdp = await browser.newBrowserCDPSession();
 		const systemInfo = await cdp.send( 'SystemInfo.getInfo' );
 		const gpu = gpuSummary( systemInfo );
 		const physicalGpu = isPhysicalGpu( gpu );
-		if ( ! quick && ( ! headed || ! physicalGpu ) ) {
+		if ( ! quick && ! physicalGpu ) {
 
-			throw new Error( 'Publication capture requires headed Chromium on a physical GPU; use --quick for local validation.' );
+			throw new Error( 'Publication capture requires a physical GPU; use --quick for local validation.' );
 
 		}
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-blocks-benchmark",
-  "version": "0.3.3",
-  "description": "Reproducible Gaussian splat browser benchmarks for Three Blocks, Spark, SuperSplat, GaussianSplats3D, and Babylon.js",
+  "version": "0.4.0-alpha.372.gf7fb70f4af27",
+  "description": "Reproducible Gaussian splat browser benchmarks for Three Blocks, the three.js GaussianSplatMesh addon, Spark, SuperSplat, GaussianSplats3D, and Babylon.js",
   "keywords": [
     "three",
     "threejs",
@@ -28,6 +28,7 @@
     "bin",
     "browser",
     "lib",
+    "vendor",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
@@ -51,7 +52,11 @@
     "playwright": "1.61.1",
     "pngjs": "7.0.0",
     "three": "0.185.1",
-    "three-blocks": "0.9.0",
+    "three-blocks": "0.9.1-alpha.372.gf7fb70f4af27",
     "vite": "8.1.3"
+  },
+  "threeBlocks": {
+    "channel": "alpha",
+    "site": "https://preprod.threejs-blocks.com"
   }
 }

package/vendor/three-gs/README.md

@@ -0,0 +1,29 @@
+# three.js Gaussian splat addon (unmerged)
+
+Verbatim copies of the addon files from mrdoob/three.js PR #33950
+("Gaussian Splat renderer / loader using TSL for WebGPU/WebGL + glTF import",
+by Ben Houston), pinned to commit `5b8fcba16c8e0ab1e3745cd2c8185fe527998a36`.
+The PR is not merged and ships in no npm release, so the benchmark vendors the
+files instead of resolving a package version.
+
+| File | SHA-256 |
+| --- | --- |
+| `objects/GaussianSplatMesh.js` | `fb04d66d3c5d10068c0aa88e2eb2002aac096def8234216b28133b1de3ea6921` |
+| `gpgpu/CountingSort.js` | `e9e90b6940a4da923534c3f249e8e7bd2c7603f8b432c54c62ecdc6db4be47e3` |
+| `utils/GaussianSplatUtils.js` | `1094941578d4ad2a56c79444d4607a679764e6fc07e83b662292e37a15a8e27e` |
+
+Refresh with:
+
+```sh
+sha=5b8fcba16c8e0ab1e3745cd2c8185fe527998a36
+for f in objects/GaussianSplatMesh.js gpgpu/CountingSort.js utils/GaussianSplatUtils.js; do
+  curl -sSfL "https://raw.githubusercontent.com/mrdoob/three.js/$sha/examples/jsm/$f" -o "$f"
+done
+```
+
+The directory layout mirrors `examples/jsm/` so the files stay byte-identical to
+upstream (`GaussianSplatMesh.js` imports `../gpgpu/CountingSort.js`). PLY input
+uses the `PLYLoader` from the installed `three` release, as the PR intends.
+
+Licensed under the MIT License, Copyright © 2010-2026 three.js authors:
+<https://github.com/mrdoob/three.js/blob/dev/LICENSE>

package/vendor/three-gs/gpgpu/CountingSort.js

@@ -0,0 +1,271 @@
+import { StorageBufferAttribute, DynamicDrawUsage } from 'three/webgpu';
+import { Fn, Loop, atomicAdd, atomicLoad, atomicStore, instanceIndex, storage, uint } from 'three/tsl';
+
+/**
+ * A reusable GPU counting sort.
+ *
+ * This computes a stable-ish permutation of the integers `[0, count)` that orders them by an
+ * arbitrary, user supplied `uint` key ("bin") in the range `[0, binCount)`. It is a good fit for
+ * approximate ordering of large element counts (hundreds of thousands to millions) where an exact
+ * comparison sort such as a bitonic sort (see {@link BitonicSort}) would be too slow: a counting
+ * sort only requires a fixed number of passes (reset, histogram, prefix sum, scatter) regardless of
+ * `count`, at the cost of only being accurate to the resolution of `binCount` - elements that land
+ * in the same bin end up in an unspecified relative order.
+ *
+ * This class does not compute the sort key itself. Instead, a TSL function is supplied via
+ * {@link CountingSort#setBinNode} that maps the current `instanceIndex` to a bin, and an equivalent
+ * plain JavaScript function can be supplied to {@link CountingSort#computeCPU} for platforms without
+ * compute shader support (e.g. the WebGL backend of {@link WebGPURenderer}).
+ *
+ * ```js
+ * const sort = new CountingSort( count, { binCount: 4096 } );
+ * sort.setBinNode( () => {
+ *
+ * 	// return a `Node<uint>` bin index for `instanceIndex`, e.g. derived from a depth value.
+ *
+ * } );
+ *
+ * sort.compute( renderer );
+ *
+ * // `sort.orderRead` now holds a storage buffer of `count` indices, ordered by bin.
+ * ```
+ *
+ * @three_import import { CountingSort } from 'three/addons/gpgpu/CountingSort.js';
+ */
+class CountingSort {
+
+	/**
+	 * Constructs a new counting sort.
+	 *
+	 * @param {number} count - The number of elements to sort.
+	 * @param {Object} [options={}] - Options that modify the counting sort.
+	 * @param {number} [options.binCount=4096] - The number of bins/buckets the sort key is quantized into. Larger values improve sort accuracy at the cost of a longer (but still single-pass) prefix sum.
+	 * @param {number} [options.workgroupSize=256] - The workgroup size of the compute shaders executed during the sort.
+	 */
+	constructor( count, { binCount = 4096, workgroupSize = 256 } = {} ) {
+
+		/**
+		 * The number of elements to sort.
+		 *
+		 * @type {number}
+		 */
+		this.count = count;
+
+		/**
+		 * The number of bins/buckets the sort key is quantized into.
+		 *
+		 * @type {number}
+		 */
+		this.binCount = binCount;
+
+		/**
+		 * The workgroup size of the compute shaders executed during the sort.
+		 *
+		 * @type {number}
+		 */
+		this.workgroupSize = workgroupSize;
+
+		const orderData = new Uint32Array( count );
+		for ( let i = 0; i < count; i ++ ) orderData[ i ] = i;
+
+		/**
+		 * The buffer attribute holding the sorted order (a permutation of `[0, count)`). This is
+		 * also the attribute that is kept up to date by {@link CountingSort#computeCPU}.
+		 *
+		 * @type {StorageBufferAttribute}
+		 */
+		this.orderAttribute = new StorageBufferAttribute( orderData, 1, Uint32Array );
+
+		const binAttribute = new StorageBufferAttribute( new Uint32Array( count ), 1, Uint32Array );
+		const histogramAttribute = new StorageBufferAttribute( new Uint32Array( binCount ), 1, Uint32Array );
+		const offsetAttribute = new StorageBufferAttribute( new Uint32Array( binCount ), 1, Uint32Array );
+
+		/**
+		 * A read-only storage node for the sorted order buffer.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.orderRead = storage( this.orderAttribute, 'uint', count ).toReadOnly();
+
+		/**
+		 * A writable storage node for the sorted order buffer.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.orderWrite = storage( this.orderAttribute, 'uint', count );
+
+		/**
+		 * A read-only storage node holding each element's bin, computed during the histogram pass.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.binRead = storage( binAttribute, 'uint', count ).toReadOnly();
+
+		/**
+		 * A writable storage node holding each element's bin.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.binWrite = storage( binAttribute, 'uint', count );
+
+		/**
+		 * An atomic storage node used to accumulate the per-bin histogram.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.histogramAtomic = storage( histogramAttribute, 'uint', binCount ).toAtomic();
+
+		/**
+		 * An atomic storage node used both for the exclusive prefix sum of the histogram and, during
+		 * the scatter pass, as a per-bin write cursor.
+		 *
+		 * @type {StorageBufferNode}
+		 */
+		this.offsetAtomic = storage( offsetAttribute, 'uint', binCount ).toAtomic();
+
+		this._webGLBuffersEnabled = false;
+
+		this._cpuBins = new Uint32Array( count );
+		this._cpuCounts = new Uint32Array( binCount );
+		this._cpuOffsets = new Uint32Array( binCount );
+
+		this._resetNode = null;
+		this._histogramNode = null;
+		this._prefixNode = null;
+		this._scatterNode = null;
+
+	}
+
+	/**
+	 * Sets the TSL function used to compute the bin of the element currently referenced by
+	 * `instanceIndex`, and (re)builds the compute nodes used by {@link CountingSort#compute}.
+	 *
+	 * @param {Function} binNode - A parameterless function returning a `Node<uint>` in `[0, binCount)`.
+	 */
+	setBinNode( binNode ) {
+
+		const { binCount, workgroupSize, count } = this;
+
+		this._resetNode = Fn( () => {
+
+			atomicStore( this.histogramAtomic.element( instanceIndex ), uint( 0 ) );
+			atomicStore( this.offsetAtomic.element( instanceIndex ), uint( 0 ) );
+
+		} )().compute( binCount, [ workgroupSize ] ).setName( 'CountingSortReset' );
+
+		this._histogramNode = Fn( () => {
+
+			const bin = binNode().toVar( 'bin' );
+
+			this.binWrite.element( instanceIndex ).assign( bin );
+			atomicAdd( this.histogramAtomic.element( bin ), uint( 1 ) );
+
+		} )().compute( count, [ workgroupSize ] ).setName( 'CountingSortHistogram' );
+
+		this._prefixNode = Fn( () => {
+
+			const sum = uint( 0 ).toVar( 'sum' );
+
+			Loop( { start: 0, end: binCount, type: 'uint', name: 'bin', condition: '<' }, ( { bin } ) => {
+
+				const binCountValue = atomicLoad( this.histogramAtomic.element( bin ) ).toVar( 'count' );
+				atomicStore( this.offsetAtomic.element( bin ), sum );
+				sum.addAssign( binCountValue );
+
+			} );
+
+		} )().compute( 1 ).setName( 'CountingSortPrefix' );
+
+		this._scatterNode = Fn( () => {
+
+			const bin = this.binRead.element( instanceIndex ).toVar( 'bin' );
+			const targetIndex = atomicAdd( this.offsetAtomic.element( bin ), uint( 1 ) ).toVar( 'targetIndex' );
+
+			this.orderWrite.element( targetIndex ).assign( instanceIndex );
+
+		} )().compute( count, [ workgroupSize ] ).setName( 'CountingSortScatter' );
+
+	}
+
+	/**
+	 * Executes a complete counting sort on the GPU, updating {@link CountingSort#orderRead}.
+	 *
+	 * @param {Renderer} renderer - The current scene's renderer.
+	 */
+	compute( renderer ) {
+
+		renderer.compute( this._resetNode );
+		renderer.compute( this._histogramNode );
+		renderer.compute( this._prefixNode );
+		renderer.compute( this._scatterNode );
+
+	}
+
+	/**
+	 * Executes a complete counting sort on the CPU, updating {@link CountingSort#orderAttribute}.
+	 * Intended as a fallback for backends without compute shader support.
+	 *
+	 * @param {Function} binFn - A function taking an element index and returning its bin (a plain number in `[0, binCount)`).
+	 */
+	computeCPU( binFn ) {
+
+		const { count, binCount } = this;
+		const order = this.orderAttribute.array;
+		const bins = this._cpuBins;
+		const counts = this._cpuCounts;
+		const offsets = this._cpuOffsets;
+
+		counts.fill( 0 );
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			const bin = binFn( i );
+
+			bins[ i ] = bin;
+			counts[ bin ] ++;
+
+		}
+
+		let sum = 0;
+
+		for ( let i = 0; i < binCount; i ++ ) {
+
+			offsets[ i ] = sum;
+			sum += counts[ i ];
+
+		}
+
+		for ( let i = 0; i < count; i ++ ) {
+
+			order[ offsets[ bins[ i ] ] ++ ] = i;
+
+		}
+
+		this.orderAttribute.needsUpdate = true;
+
+		if ( this.orderAttribute.pbo !== undefined ) {
+
+			this.orderAttribute.pbo.needsUpdate = true;
+
+		}
+
+	}
+
+	/**
+	 * Enables the WebGL-specific storage buffer path (PBO + dynamic draw usage) for the order buffer.
+	 * Only needed when {@link CountingSort#computeCPU} is used with the WebGL backend of {@link WebGPURenderer}.
+	 */
+	enableWebGLBuffers() {
+
+		if ( this._webGLBuffersEnabled === true ) return;
+
+		this.orderAttribute.setUsage( DynamicDrawUsage );
+		this.orderRead.setPBO( true );
+
+		this._webGLBuffersEnabled = true;
+
+	}
+
+}
+
+export { CountingSort };

package/vendor/three-gs/objects/GaussianSplatMesh.js

@@ -0,0 +1,474 @@
+import {
+	BufferAttribute,
+	InstancedBufferGeometry,
+	Matrix4,
+	Mesh,
+	NodeMaterial,
+	StorageBufferAttribute,
+	Vector2,
+	Vector3
+} from 'three/webgpu';
+
+import {
+	Discard,
+	Fn,
+	If,
+	atan,
+	cameraProjectionMatrix,
+	cos,
+	dot,
+	exp,
+	float,
+	highpModelViewMatrix,
+	instanceIndex,
+	max,
+	min,
+	positionGeometry,
+	screenSize,
+	sin,
+	sqrt,
+	storage,
+	uint,
+	uniform,
+	varyingProperty,
+	vec2,
+	vec3,
+	vec4
+} from 'three/tsl';
+
+import { CountingSort } from '../gpgpu/CountingSort.js';
+
+const BIN_COUNT = 4096;
+const WORKGROUP_SIZE = 256;
+const SORT_DIRECTION_THRESHOLD = 0.9995;
+const SORT_POSITION_THRESHOLD = 0.0025;
+const KERNEL_2D_SIZE = 0.3;
+const MAX_SCREEN_SPACE_SPLAT_SIZE = 1024;
+const CLIP_XY = 1.4;
+
+const _worldCenter = /*@__PURE__*/ new Vector3();
+const _viewCenter = /*@__PURE__*/ new Vector3();
+const _worldScale = /*@__PURE__*/ new Vector3();
+const _cameraPosition = /*@__PURE__*/ new Vector3();
+const _cameraDirection = /*@__PURE__*/ new Vector3();
+const _sortDepthRange = /*@__PURE__*/ new Vector2();
+
+/**
+ * A minimal renderer for 3D Gaussian splat geometry.
+ *
+ * Note that this class can only be used with {@link WebGPURenderer}. The
+ * `forceWebGL` fallback of {@link WebGPURenderer} is supported, but
+ * {@link WebGLRenderer} is not. Import maps or package exports must resolve
+ * both `three/webgpu` and `three/tsl`.
+ *
+ * ```js
+ * const splats = new GaussianSplatMesh( geometry );
+ * scene.add( splats );
+ * ```
+ *
+ * @augments Mesh
+ * @three_import import { GaussianSplatMesh } from 'three/addons/objects/GaussianSplatMesh.js';
+ */
+class GaussianSplatMesh extends Mesh {
+
+	/**
+	 * Constructs a new Gaussian splat mesh.
+	 *
+	 * @param {BufferGeometry} splatGeometry - The splat geometry to render.
+	 * @param {Object} [options] - Options.
+	 * @param {boolean} [options.autoSort=true] - Whether to sort automatically in `onBeforeRender`.
+	 */
+	constructor( splatGeometry, { autoSort = true } = {} ) {
+
+		const positionAttribute = splatGeometry.getAttribute( 'position' );
+		const covarianceAttribute = splatGeometry.getAttribute( 'covariance' );
+		const colorAttribute = splatGeometry.getAttribute( 'color' );
+		const count = positionAttribute.count;
+
+		if ( splatGeometry.boundingBox === null ) splatGeometry.computeBoundingBox();
+		if ( splatGeometry.boundingSphere === null ) splatGeometry.computeBoundingSphere();
+
+		const geometry = createGeometry( count );
+		const buffers = createStorageBuffers( count, positionAttribute.array, covarianceAttribute.array, colorAttribute.array );
+		const sort = new CountingSort( count, { binCount: BIN_COUNT, workgroupSize: WORKGROUP_SIZE } );
+		const material = createMaterial( buffers, sort );
+
+		super( geometry, material );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isGaussianSplatMesh = true;
+
+		this.type = 'GaussianSplatMesh';
+
+		/**
+		 * The source splat geometry.
+		 *
+		 * @type {BufferGeometry}
+		 */
+		this.splatGeometry = splatGeometry;
+
+		/**
+		 * Whether to sort automatically in `onBeforeRender`.
+		 *
+		 * @type {boolean}
+		 */
+		this.autoSort = autoSort;
+
+		this.frustumCulled = false;
+
+		this._buffers = buffers;
+		this._sort = sort;
+		this._sortMatrix = uniform( new Matrix4() );
+		this._sortDepthRange = uniform( new Vector2( 0, 1 ) );
+		this._sortInitialized = false;
+		this._lastSortPosition = new Vector3( Infinity, Infinity, Infinity );
+		this._lastSortDirection = new Vector3( 0, 0, - 1 );
+		this._positionAttribute = positionAttribute;
+
+		const centerRead = buffers.centerRead;
+		const sortMatrix = this._sortMatrix;
+		const sortDepthRange = this._sortDepthRange;
+
+		sort.setBinNode( () => {
+
+			const center = centerRead.element( instanceIndex ).xyz.toVar( 'center' );
+			const viewCenter = sortMatrix.mul( vec4( center, 1 ) ).xyz.toVar( 'viewCenter' );
+			const depth = viewCenter.z.negate().toVar( 'depth' );
+			const range = max( sortDepthRange.y.sub( sortDepthRange.x ), 0.0001 ).toVar( 'range' );
+			const normalized = depth.sub( sortDepthRange.x ).div( range ).clamp( 0, 1 ).toVar( 'normalized' );
+			const depthBin = uint( normalized.mul( BIN_COUNT - 1 ) ).toVar( 'depthBin' );
+
+			return uint( BIN_COUNT - 1 ).sub( depthBin );
+
+		} );
+
+		this.onBeforeRender = ( renderer, scene, camera ) => {
+
+			if ( this.autoSort === true ) {
+
+				this.updateSort( renderer, camera );
+
+			}
+
+		};
+
+	}
+
+	/**
+	 * Updates the draw order if the camera has moved enough to need a new sort.
+	 *
+	 * @param {Renderer} renderer - The renderer.
+	 * @param {Camera} camera - The camera used for rendering.
+	 * @return {boolean} Whether a sort was dispatched this call.
+	 */
+	updateSort( renderer, camera ) {
+
+		if ( this._sortInitialized === false || this._needsSort( camera ) === true ) {
+
+			this._updateSortUniforms( camera );
+
+			if ( renderer.backend && renderer.backend.isWebGLBackend === true ) {
+
+				enableWebGLBuffers( this._buffers );
+				this._sort.enableWebGLBuffers();
+				this._sortCPU();
+
+			} else {
+
+				this._sort.compute( renderer );
+
+			}
+
+			this._sortInitialized = true;
+
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	_needsSort( camera ) {
+
+		_cameraPosition.setFromMatrixPosition( camera.matrixWorld );
+
+		const e = camera.matrixWorld.elements;
+		_cameraDirection.set( - e[ 8 ], - e[ 9 ], - e[ 10 ] ).normalize();
+
+		const positionChanged = _cameraPosition.distanceToSquared( this._lastSortPosition ) > SORT_POSITION_THRESHOLD * SORT_POSITION_THRESHOLD;
+		const directionChanged = _cameraDirection.dot( this._lastSortDirection ) < SORT_DIRECTION_THRESHOLD;
+
+		if ( positionChanged === true || directionChanged === true ) {
+
+			this._lastSortPosition.copy( _cameraPosition );
+			this._lastSortDirection.copy( _cameraDirection );
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	_updateSortUniforms( camera ) {
+
+		this.updateWorldMatrix( true, false );
+
+		this._sortMatrix.value.multiplyMatrices( camera.matrixWorldInverse, this.matrixWorld );
+
+		_worldCenter.copy( this.splatGeometry.boundingSphere.center ).applyMatrix4( this.matrixWorld );
+		_viewCenter.copy( _worldCenter ).applyMatrix4( camera.matrixWorldInverse );
+		this.getWorldScale( _worldScale );
+
+		const radius = this.splatGeometry.boundingSphere.radius * Math.max( _worldScale.x, _worldScale.y, _worldScale.z );
+		const depth = - _viewCenter.z;
+		const nearDepth = Math.max( camera.near, depth - radius );
+		const farDepth = Math.max( nearDepth + 0.0001, depth + radius );
+
+		_sortDepthRange.set( nearDepth, farDepth );
+		this._sortDepthRange.value.copy( _sortDepthRange );
+
+	}
+
+	_sortCPU() {
+
+		const centers = this._positionAttribute.array;
+		const matrix = this._sortMatrix.value.elements;
+		const nearDepth = this._sortDepthRange.value.x;
+		const range = Math.max( this._sortDepthRange.value.y - nearDepth, 0.0001 );
+		const scale = ( BIN_COUNT - 1 ) / range;
+
+		this._sort.computeCPU( ( i ) => {
+
+			const i3 = i * 3;
+			const depth = - ( matrix[ 2 ] * centers[ i3 ] + matrix[ 6 ] * centers[ i3 + 1 ] + matrix[ 10 ] * centers[ i3 + 2 ] + matrix[ 14 ] );
+			const depthBin = Math.min( BIN_COUNT - 1, Math.max( 0, Math.floor( ( depth - nearDepth ) * scale ) ) );
+
+			return BIN_COUNT - 1 - depthBin;
+
+		} );
+
+	}
+
+}
+
+function createGeometry( count ) {
+
+	const geometry = new InstancedBufferGeometry();
+	geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( [
+		- 2, - 2, 0,
+		2, - 2, 0,
+		2, 2, 0,
+		- 2, 2, 0
+	] ), 3 ) );
+	geometry.setIndex( [ 0, 1, 2, 0, 2, 3 ] );
+	geometry.instanceCount = count;
+
+	return geometry;
+
+}
+
+function createStorageBuffers( count, centers, covariances, colors ) {
+
+	const centerData = new Float32Array( count * 4 );
+	const covarianceAData = new Float32Array( count * 4 );
+	const covarianceBData = new Float32Array( count * 4 );
+	const colorData = new Float32Array( count * 4 );
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		const i3 = i * 3;
+		const i4 = i * 4;
+		const i6 = i * 6;
+
+		centerData[ i4 ] = centers[ i3 ];
+		centerData[ i4 + 1 ] = centers[ i3 + 1 ];
+		centerData[ i4 + 2 ] = centers[ i3 + 2 ];
+
+		covarianceAData[ i4 ] = covariances[ i6 ];
+		covarianceAData[ i4 + 1 ] = covariances[ i6 + 1 ];
+		covarianceAData[ i4 + 2 ] = covariances[ i6 + 2 ];
+		covarianceAData[ i4 + 3 ] = covariances[ i6 + 3 ];
+
+		covarianceBData[ i4 ] = covariances[ i6 + 4 ];
+		covarianceBData[ i4 + 1 ] = covariances[ i6 + 5 ];
+
+		colorData[ i4 ] = colors[ i4 ] / 255;
+		colorData[ i4 + 1 ] = colors[ i4 + 1 ] / 255;
+		colorData[ i4 + 2 ] = colors[ i4 + 2 ] / 255;
+		colorData[ i4 + 3 ] = colors[ i4 + 3 ] / 255;
+
+	}
+
+	const centerAttribute = new StorageBufferAttribute( centerData, 4 );
+	const covarianceAAttribute = new StorageBufferAttribute( covarianceAData, 4 );
+	const covarianceBAttribute = new StorageBufferAttribute( covarianceBData, 4 );
+	const colorAttribute = new StorageBufferAttribute( colorData, 4 );
+
+	return {
+		count,
+		webGLBuffersEnabled: false,
+		centerRead: storage( centerAttribute, 'vec4', count ).toReadOnly(),
+		covarianceARead: storage( covarianceAAttribute, 'vec4', count ).toReadOnly(),
+		covarianceBRead: storage( covarianceBAttribute, 'vec4', count ).toReadOnly(),
+		colorRead: storage( colorAttribute, 'vec4', count ).toReadOnly()
+	};
+
+}
+
+function enableWebGLBuffers( buffers ) {
+
+	if ( buffers.webGLBuffersEnabled === true ) return;
+
+	buffers.centerRead.setPBO( true );
+	buffers.covarianceARead.setPBO( true );
+	buffers.covarianceBRead.setPBO( true );
+	buffers.colorRead.setPBO( true );
+	buffers.webGLBuffersEnabled = true;
+
+}
+
+function createMaterial( buffers, sort ) {
+
+	const splatUv = varyingProperty( 'vec2', 'vSplatUv' );
+	const splatColor = varyingProperty( 'vec4', 'vSplatColor' );
+
+	const vertexNode = Fn( () => {
+
+		const splatIndex = sort.orderRead.element( instanceIndex ).toVar( 'splatIndex' );
+		const center = buffers.centerRead.element( splatIndex ).xyz.toVar( 'center' );
+		const covA = buffers.covarianceARead.element( splatIndex ).toVar( 'covA' );
+		const covB = buffers.covarianceBRead.element( splatIndex ).toVar( 'covB' );
+		const color = buffers.colorRead.element( splatIndex ).toVar( 'splatColor' );
+
+		splatUv.assign( positionGeometry.xy );
+
+		const viewCenter4 = highpModelViewMatrix.mul( vec4( center, 1 ) ).toVar( 'viewCenter4' );
+		const viewCenter = viewCenter4.xyz.toVar( 'viewCenter' );
+		const centerClip = cameraProjectionMatrix.mul( viewCenter4 ).toVar( 'centerClip' );
+
+		const m = highpModelViewMatrix;
+		const r0 = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x ).toVar( 'r0' );
+		const r1 = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y ).toVar( 'r1' );
+		const r2 = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z ).toVar( 'r2' );
+
+		const cov0 = vec3( covA.x, covA.y, covA.z ).toVar( 'cov0' );
+		const cov1 = vec3( covA.y, covA.w, covB.x ).toVar( 'cov1' );
+		const cov2 = vec3( covA.z, covB.x, covB.y ).toVar( 'cov2' );
+
+		const vc0 = vec3( dot( r0, cov0 ), dot( r0, cov1 ), dot( r0, cov2 ) ).toVar( 'vc0' );
+		const vc1 = vec3( dot( r1, cov0 ), dot( r1, cov1 ), dot( r1, cov2 ) ).toVar( 'vc1' );
+		const vc2 = vec3( dot( r2, cov0 ), dot( r2, cov1 ), dot( r2, cov2 ) ).toVar( 'vc2' );
+
+		const c00 = dot( vc0, r0 ).toVar( 'c00' );
+		const c01 = dot( vc0, r1 ).toVar( 'c01' );
+		const c02 = dot( vc0, r2 ).toVar( 'c02' );
+		const c11 = dot( vc1, r1 ).toVar( 'c11' );
+		const c12 = dot( vc1, r2 ).toVar( 'c12' );
+		const c22 = dot( vc2, r2 ).toVar( 'c22' );
+
+		const z = min( viewCenter.z, - 0.01 ).toVar( 'z' );
+		const invZ = float( 1 ).div( z ).toVar( 'invZ' );
+		const invZ2 = invZ.mul( invZ ).toVar( 'invZ2' );
+		const focal = screenSize.mul( 0.5 ).mul( vec2( cameraProjectionMatrix[ 0 ].x, cameraProjectionMatrix[ 1 ].y ) ).toVar( 'focal' );
+
+		const j00 = focal.x.negate().mul( invZ ).toVar( 'j00' );
+		const j11 = focal.y.negate().mul( invZ ).toVar( 'j11' );
+		const j02 = focal.x.mul( viewCenter.x ).mul( invZ2 ).toVar( 'j02' );
+		const j12 = focal.y.mul( viewCenter.y ).mul( invZ2 ).toVar( 'j12' );
+
+		const aBase = j00.mul( j00 ).mul( c00 )
+			.add( j00.mul( j02 ).mul( c02 ).mul( 2 ) )
+			.add( j02.mul( j02 ).mul( c22 ) )
+			.toVar( 'cov2dABase' );
+		const b = j00.mul( j11 ).mul( c01 )
+			.add( j00.mul( j12 ).mul( c02 ) )
+			.add( j02.mul( j11 ).mul( c12 ) )
+			.add( j02.mul( j12 ).mul( c22 ) )
+			.toVar( 'cov2dB' );
+		const cBase = j11.mul( j11 ).mul( c11 )
+			.add( j11.mul( j12 ).mul( c12 ).mul( 2 ) )
+			.add( j12.mul( j12 ).mul( c22 ) )
+			.toVar( 'cov2dCBase' );
+		const a = aBase.add( KERNEL_2D_SIZE ).toVar( 'cov2dA' );
+		const c = cBase.add( KERNEL_2D_SIZE ).toVar( 'cov2dC' );
+		const detBase = aBase.mul( cBase ).sub( b.mul( b ) ).toVar( 'detBase' );
+		const det = a.mul( c ).sub( b.mul( b ) ).toVar( 'det' );
+		const alphaScale = sqrt( max( detBase.div( max( det, 0.000001 ) ), 0 ) ).toVar( 'alphaScale' );
+
+		splatColor.assign( vec4( color.rgb, color.a.mul( alphaScale ) ) );
+
+		const halfTrace = a.add( c ).mul( 0.5 ).toVar( 'halfTrace' );
+		const radius = sqrt( max( a.sub( c ).mul( 0.5 ).pow2().add( b.mul( b ) ), 0.0000001 ) ).toVar( 'radius' );
+		const lambda1 = max( halfTrace.add( radius ), 0.0000001 ).toVar( 'lambda1' );
+		const lambda2 = max( halfTrace.sub( radius ), 0.0000001 ).toVar( 'lambda2' );
+		const axis1 = vec2( 1, 0 ).toVar( 'axis1' );
+
+		If( radius.greaterThan( 0.00001 ), () => {
+
+			const angle = atan( b.mul( 2 ), a.sub( c ) ).mul( 0.5 ).toVar( 'angle' );
+			axis1.assign( vec2( cos( angle ), sin( angle ) ) );
+
+		} );
+
+		const axis2 = vec2( axis1.y.negate(), axis1.x ).toVar( 'axis2' );
+
+		const scale1 = min( sqrt( lambda1 ), MAX_SCREEN_SPACE_SPLAT_SIZE ).toVar( 'scale1' );
+		const scale2 = min( sqrt( lambda2 ), MAX_SCREEN_SPACE_SPLAT_SIZE ).toVar( 'scale2' );
+		const offsetPixels = axis1.mul( positionGeometry.x ).mul( scale1 ).add( axis2.mul( positionGeometry.y ).mul( scale2 ) ).toVar( 'offsetPixels' );
+		const offsetNdc = offsetPixels.mul( 2 ).div( screenSize ).toVar( 'offsetNdc' );
+		const clip = centerClip.add( vec4( offsetNdc.mul( centerClip.w ), 0, 0 ) ).toVar( 'clip' );
+
+		const clipLimit = centerClip.w.mul( CLIP_XY ).toVar( 'clipLimit' );
+
+		If( viewCenter.z.greaterThanEqual( - 0.01 )
+			.or( centerClip.z.lessThan( centerClip.w.negate() ) )
+			.or( centerClip.z.greaterThan( centerClip.w ) )
+			.or( centerClip.x.lessThan( clipLimit.negate() ) )
+			.or( centerClip.x.greaterThan( clipLimit ) )
+			.or( centerClip.y.lessThan( clipLimit.negate() ) )
+			.or( centerClip.y.greaterThan( clipLimit ) ), () => {
+
+			clip.assign( vec4( 2, 2, 2, 1 ) );
+
+		} );
+
+		return clip;
+
+	} )();
+
+	const fragmentNode = Fn( () => {
+
+		const r2 = dot( splatUv, splatUv ).toVar( 'r2' );
+
+		If( r2.greaterThan( 4 ), () => {
+
+			Discard();
+
+		} );
+
+		return vec4( splatColor.rgb, exp( r2.mul( - 0.5 ) ).mul( splatColor.a ) );
+
+	} )();
+
+	const material = new NodeMaterial();
+	material.vertexNode = vertexNode;
+	material.colorNode = fragmentNode;
+	material.transparent = true;
+	material.depthWrite = false;
+	material.depthTest = true;
+	material.forceSinglePass = true;
+	material.fog = false;
+
+	return material;
+
+}
+
+export { GaussianSplatMesh };

package/vendor/three-gs/utils/GaussianSplatUtils.js

@@ -0,0 +1,218 @@
+import {
+	BufferAttribute,
+	BufferGeometry
+} from 'three';
+
+const SH_C0 = 0.2820947917738781;
+const GAUSSIAN_SPLAT_PLY_PROPERTY_MAPPING = {
+	scale: [ 'scale_0', 'scale_1', 'scale_2' ],
+	rotation: [ 'rot_0', 'rot_1', 'rot_2', 'rot_3' ],
+	f_dc: [ 'f_dc_0', 'f_dc_1', 'f_dc_2' ],
+	opacity: [ 'opacity' ]
+};
+
+function clampByte( value ) {
+
+	return Math.min( 255, Math.max( 0, Math.round( value ) ) );
+
+}
+
+function sigmoid( value ) {
+
+	return 1 / ( 1 + Math.exp( - value ) );
+
+}
+
+function writeColorBytes( target, offset, r, g, b, a ) {
+
+	target[ offset ] = clampByte( r );
+	target[ offset + 1 ] = clampByte( g );
+	target[ offset + 2 ] = clampByte( b );
+	target[ offset + 3 ] = clampByte( a );
+
+}
+
+function sh0ToLinear( coefficient ) {
+
+	return coefficient * SH_C0 + 0.5;
+
+}
+
+function linearToSH0( color ) {
+
+	return ( color - 0.5 ) / SH_C0;
+
+}
+
+function writeColorBytesFromSH0( target, offset, r, g, b, a ) {
+
+	writeColorBytes(
+		target,
+		offset,
+		sh0ToLinear( r ) * 255,
+		sh0ToLinear( g ) * 255,
+		sh0ToLinear( b ) * 255,
+		a * 255
+	);
+
+}
+
+function writeCovariance( target, offset, sx, sy, sz, qx, qy, qz, qw ) {
+
+	const length = Math.hypot( qx, qy, qz, qw );
+
+	if ( length === 0 ) {
+
+		qx = 0;
+		qy = 0;
+		qz = 0;
+		qw = 1;
+
+	} else {
+
+		const invLength = 1 / length;
+		qx *= invLength;
+		qy *= invLength;
+		qz *= invLength;
+		qw *= invLength;
+
+	}
+
+	const x2 = qx + qx;
+	const y2 = qy + qy;
+	const z2 = qz + qz;
+	const xx = qx * x2;
+	const xy = qx * y2;
+	const xz = qx * z2;
+	const yy = qy * y2;
+	const yz = qy * z2;
+	const zz = qz * z2;
+	const wx = qw * x2;
+	const wy = qw * y2;
+	const wz = qw * z2;
+
+	const r00 = 1 - ( yy + zz );
+	const r01 = xy - wz;
+	const r02 = xz + wy;
+	const r10 = xy + wz;
+	const r11 = 1 - ( xx + zz );
+	const r12 = yz - wx;
+	const r20 = xz - wy;
+	const r21 = yz + wx;
+	const r22 = 1 - ( xx + yy );
+
+	const sxx = sx * sx;
+	const syy = sy * sy;
+	const szz = sz * sz;
+
+	target[ offset ] = r00 * r00 * sxx + r01 * r01 * syy + r02 * r02 * szz;
+	target[ offset + 1 ] = r00 * r10 * sxx + r01 * r11 * syy + r02 * r12 * szz;
+	target[ offset + 2 ] = r00 * r20 * sxx + r01 * r21 * syy + r02 * r22 * szz;
+	target[ offset + 3 ] = r10 * r10 * sxx + r11 * r11 * syy + r12 * r12 * szz;
+	target[ offset + 4 ] = r10 * r20 * sxx + r11 * r21 * syy + r12 * r22 * szz;
+	target[ offset + 5 ] = r20 * r20 * sxx + r21 * r21 * syy + r22 * r22 * szz;
+
+}
+
+function createGaussianSplatGeometry( centers, covariances, colors ) {
+
+	const geometry = new BufferGeometry();
+	geometry.setAttribute( 'position', new BufferAttribute( centers, 3 ) );
+	geometry.setAttribute( 'covariance', new BufferAttribute( covariances, 6 ) );
+	geometry.setAttribute( 'color', new BufferAttribute( colors, 4, true ) );
+	geometry.computeBoundingBox();
+	geometry.computeBoundingSphere();
+
+	return geometry;
+
+}
+
+function createGaussianSplatGeometryFromPLYGeometry( geometry, {
+	scaleAttribute = 'scale',
+	rotationAttribute = 'rotation',
+	sh0Attribute = 'f_dc',
+	opacityAttribute = 'opacity'
+} = {} ) {
+
+	if ( geometry === undefined || geometry.isBufferGeometry !== true ) {
+
+		throw new Error( 'THREE.createGaussianSplatGeometryFromPLYGeometry: PLY geometry must be a BufferGeometry.' );
+
+	}
+
+	const position = geometry.getAttribute( 'position' );
+	const scale = geometry.getAttribute( scaleAttribute );
+	const rotation = geometry.getAttribute( rotationAttribute );
+	const sh0 = geometry.getAttribute( sh0Attribute );
+	const opacity = geometry.getAttribute( opacityAttribute );
+
+	if ( position === undefined || scale === undefined || rotation === undefined || sh0 === undefined || opacity === undefined ) {
+
+		throw new Error( 'THREE.createGaussianSplatGeometryFromPLYGeometry: PLY geometry requires position, scale, rotation, f_dc and opacity attributes.' );
+
+	}
+
+	const count = position.count;
+
+	if ( position.itemSize !== 3 || scale.itemSize !== 3 || rotation.itemSize !== 4 || sh0.itemSize !== 3 || opacity.itemSize !== 1 ) {
+
+		throw new Error( 'THREE.createGaussianSplatGeometryFromPLYGeometry: Invalid Gaussian splat PLY attribute itemSize.' );
+
+	}
+
+	if ( scale.count !== count || rotation.count !== count || sh0.count !== count || opacity.count !== count ) {
+
+		throw new Error( 'THREE.createGaussianSplatGeometryFromPLYGeometry: Gaussian splat PLY attribute counts must match position.' );
+
+	}
+
+	const centers = new Float32Array( count * 3 );
+	const covariances = new Float32Array( count * 6 );
+	const colors = new Uint8Array( count * 4 );
+
+	for ( let i = 0; i < count; i ++ ) {
+
+		const i3 = i * 3;
+		centers[ i3 ] = position.getX( i );
+		centers[ i3 + 1 ] = position.getY( i );
+		centers[ i3 + 2 ] = position.getZ( i );
+
+		const sx = Math.exp( scale.getX( i ) );
+		const sy = Math.exp( scale.getY( i ) );
+		const sz = Math.exp( scale.getZ( i ) );
+
+		// GraphDECO/INRIA PLY stores quaternions as rot_0=w, rot_1=x, rot_2=y, rot_3=z.
+		const qw = rotation.getX( i );
+		const qx = rotation.getY( i );
+		const qy = rotation.getZ( i );
+		const qz = rotation.getW( i );
+
+		writeCovariance( covariances, i * 6, sx, sy, sz, qx, qy, qz, qw );
+		writeColorBytesFromSH0(
+			colors,
+			i * 4,
+			sh0.getX( i ),
+			sh0.getY( i ),
+			sh0.getZ( i ),
+			sigmoid( opacity.getX( i ) )
+		);
+
+	}
+
+	return createGaussianSplatGeometry( centers, covariances, colors );
+
+}
+
+export {
+	GAUSSIAN_SPLAT_PLY_PROPERTY_MAPPING,
+	SH_C0,
+	clampByte,
+	createGaussianSplatGeometry,
+	createGaussianSplatGeometryFromPLYGeometry,
+	linearToSH0,
+	sh0ToLinear,
+	sigmoid,
+	writeColorBytes,
+	writeColorBytesFromSH0,
+	writeCovariance
+};