playcanvas 2.24.0-beta.33 → 2.24.0-beta.34

package/build/playcanvas/src/core/core.js

@@ -1,5 +1,5 @@
-const version = "2.24.0-beta.33";
-const revision = "217cc5b";
+const version = "2.24.0-beta.34";
+const revision = "eb5f1c2";
 function extend(target, ex) {
 	for (const prop in ex) {
 		const copy = ex[prop];

package/build/playcanvas/src/framework/components/gsplat/component.d.ts

@@ -29,13 +29,13 @@
  * - [Billions of Splats](https://playcanvas.github.io/#/gaussian-splatting/billions)
  * - [Downtown Streaming](https://playcanvas.github.io/#/gaussian-splatting/downtown)
  * - [Global Sorting](https://playcanvas.github.io/#/gaussian-splatting/global-sorting)
- * - [LOD Instances](https://playcanvas.github.io/#/gaussian-splatting/lod-instances)
+ * - [LOD Instances](https://playcanvas.github.io/#/gaussian-splatting/streamed-instances)
  * - [Multi-Splat](https://playcanvas.github.io/#/gaussian-splatting/multi-splat)
  * - [Multi-View](https://playcanvas.github.io/#/gaussian-splatting/multi-view)
  * - [Picking](https://playcanvas.github.io/#/gaussian-splatting/picking)
- * - [Reveal Effect](https://playcanvas.github.io/#/gaussian-splatting/reveal)
- * - [Shader Effects](https://playcanvas.github.io/#/gaussian-splatting/shader-effects)
- * - [Spherical Harmonics](https://playcanvas.github.io/#/gaussian-splatting/spherical-harmonics)
+ * - [Reveal Effect](https://playcanvas.github.io/#/gaussian-splatting-fx/reveal)
+ * - [Shader Effects](https://playcanvas.github.io/#/gaussian-splatting-fx/shader-effects)
+ * - [Spherical Harmonics](https://playcanvas.github.io/#/gaussian-splatting/simple-sh)
  * - [Streamed LCC2](https://playcanvas.github.io/#/gaussian-splatting/streamed-lcc2)
  * - [Streamed SOG](https://playcanvas.github.io/#/gaussian-splatting/streamed-sog)
  * - [Streamed SOG with Spherical Harmonics](https://playcanvas.github.io/#/gaussian-splatting/streamed-sog-sh)

package/build/playcanvas/src/framework/parsers/sog-bundle.js

@@ -159,7 +159,14 @@ class SogBundleParser {
 				callback(`Error parsing meta.json: ${err}`);
 				return;
 			}
-			const filenames = ["means", "scales", "quats", "sh0", "shN"].map((key) => meta[key]?.files ?? []).flat();
+			if (meta.version !== void 0 && meta.version !== 2 && meta.version !== 3) {
+				callback(`Error loading gsplat: unsupported SOG version ${meta.version} in ${url.original}`);
+				return;
+			}
+			const filenames = [
+				...["means", "scales", "quats", "sh0", "shN"].map((key) => meta[key]?.files ?? []).flat(),
+				...(meta.blind ?? []).map((t) => t.files[0])
+			];
 			const promises = [];
 			for (const filename of filenames) {
 				const file = files.find((f) => f.filename === filename);
@@ -194,7 +201,7 @@ class SogBundleParser {
 				promises.push(promise);
 			}
 			Object.values(textures).forEach((t) => this.app.assets.load(t));
-			await Promise.allSettled(promises);
+			const results = await Promise.allSettled(promises);
 			if (this._shouldAbort(asset, unloaded)) {
 				Object.values(textures).forEach((t) => {
 					assets.remove(t);
@@ -203,6 +210,15 @@ class SogBundleParser {
 				callback(null, null);
 				return;
 			}
+			const failed = results.findIndex((r) => r.status === "rejected");
+			if (failed !== -1) {
+				Object.values(textures).forEach((t) => {
+					assets.remove(t);
+					t.unload();
+				});
+				callback(`Error loading gsplat: failed to load ${filenames[failed]} in ${url.original}: ${results[failed].reason}`);
+				return;
+			}
 			Object.values(textures).forEach((t) => {
 				if (t.file) {
 					t.file.contents = null;
@@ -215,11 +231,12 @@ class SogBundleParser {
 			data.numSplats = meta.count;
 			data.means_l = textures[meta.means.files[0]].resource;
 			data.means_u = textures[meta.means.files[1]].resource;
-			data.quats = textures[meta.quats.files[0]].resource;
+			data.quats = meta.quats ? textures[meta.quats.files[0]].resource : null;
 			data.scales = textures[meta.scales.files[0]].resource;
 			data.sh0 = textures[meta.sh0.files[0]].resource;
 			data.sh_centroids = textures[meta.shN?.files[0]]?.resource;
 			data.sh_labels = textures[meta.shN?.files[1]]?.resource;
+			data.blind = (meta.blind ?? []).map((t) => textures[t.files[0]].resource);
 			data.shBands = GSplatSogData.calcBands(data.sh_centroids?.width);
 			if (!decompress) {
 				if (this._shouldAbort(asset, unloaded)) {

package/build/playcanvas/src/framework/parsers/sog.js

@@ -81,16 +81,19 @@ class SogParser {
 	}
 	async loadTextures(url, callback, asset, meta) {
 		const gsplatCentersEnabledAtLoad = this.app.scene?.gsplatCentersEnabled !== false;
-		if (meta.version !== 2) {
+		if (meta.version === void 0) {
 			meta = upgradeMeta(meta);
+		} else if (meta.version !== 2 && meta.version !== 3) {
+			callback(`Error loading gsplat: unsupported SOG version ${meta.version} in ${url.original}`);
+			return;
 		}
 		const { assets } = this.app;
-		const subs = ["means", "quats", "scales", "sh0", "shN"];
+		const subs = ["means", "quats", "scales", "sh0", "shN", "blind"];
 		const textures = {};
 		const promises = [];
 		const base = window.document?.baseURI ?? window.location.href;
 		subs.forEach((sub) => {
-			const files = meta[sub]?.files ?? [];
+			const files = sub === "blind" ? (meta.blind ?? []).map((t) => t.files[0]) : meta[sub]?.files ?? [];
 			textures[sub] = files.map((filename) => {
 				const texture = new Asset(filename, "texture", {
 					url: asset.options?.mapUrl?.(filename) ?? new URL(filename, new URL(url.load, base).toString()).toString(),
@@ -125,7 +128,7 @@ class SogParser {
 		});
 		combineProgress(asset, textureAssets);
 		textureAssets.forEach((t) => assets.load(t));
-		await Promise.allSettled(promises);
+		const results = await Promise.allSettled(promises);
 		if (this._shouldAbort(asset, unloaded)) {
 			textureAssets.forEach((t) => {
 				assets.remove(t);
@@ -134,17 +137,27 @@ class SogParser {
 			callback(null, null);
 			return;
 		}
+		const failed = results.findIndex((r) => r.status === "rejected");
+		if (failed !== -1) {
+			textureAssets.forEach((t) => {
+				assets.remove(t);
+				t.unload();
+			});
+			callback(`Error loading gsplat: failed to load ${textureAssets[failed].file.filename} in ${url.original}: ${results[failed].reason}`);
+			return;
+		}
 		const data = new GSplatSogData();
 		data.url = url.original;
 		data.meta = meta;
 		data.numSplats = meta.count;
 		data.means_l = textures.means[0].resource;
 		data.means_u = textures.means[1].resource;
-		data.quats = textures.quats[0].resource;
+		data.quats = textures.quats[0]?.resource ?? null;
 		data.scales = textures.scales[0].resource;
 		data.sh0 = textures.sh0[0].resource;
 		data.sh_centroids = textures.shN?.[0]?.resource;
 		data.sh_labels = textures.shN?.[1]?.resource;
+		data.blind = textures.blind.map((t) => t.resource);
 		data.shBands = GSplatSogData.calcBands(data.sh_centroids?.width);
 		const decompress = asset.data?.decompress;
 		if (!decompress) {
@@ -180,8 +193,11 @@ class SogParser {
 		callback(null, resource);
 	}
 	load(url, callback, asset) {
+		const loadTextures = (meta) => {
+			this.loadTextures(url, callback, asset, meta).catch((err) => callback(`Error loading gsplat: ${url.original} [${err}]`));
+		};
 		if (asset.data?.means) {
-			this.loadTextures(url, callback, asset, asset.data);
+			loadTextures(asset.data);
 		} else {
 			if (typeof url === "string") {
 				url = {
@@ -200,7 +216,7 @@ class SogParser {
 					return;
 				}
 				if (!err) {
-					this.loadTextures(url, callback, asset, meta);
+					loadTextures(meta);
 				} else {
 					callback(`Error loading gsplat meta: ${url.original} [${err}]`);
 				}

package/build/playcanvas/src/scene/gsplat/gsplat-data.d.ts

@@ -28,6 +28,13 @@ export class GSplatData {
      * @type {boolean}
      */
     activated: boolean;
+    /**
+     * Application-defined data stored with the splat file, as in glTF's `extras`: the `extras`
+     * value of a decompressed SOG's meta.json. Undefined when the source has none.
+     *
+     * @type {*}
+     */
+    extras: any;
     getProp(name: any, elementName?: string): import("../../framework/parsers/ply.js").DataType;
     getElement(name: any): PlyElement;
     addProp(name: any, storage: any): void;

package/build/playcanvas/src/scene/gsplat/gsplat-data.js

@@ -69,6 +69,7 @@ class GSplatData {
 	numSplats;
 	comments;
 	activated = false;
+	extras;
 	constructor(elements, comments = []) {
 		this.elements = elements;
 		this.numSplats = this.getElement("vertex").count;

package/build/playcanvas/src/scene/gsplat/gsplat-resource-base.d.ts

@@ -171,6 +171,14 @@ export class GSplatResourceBase {
      * @ignore
      */
     get supportsWorkBufferGeometry(): boolean;
+    /**
+     * Application-defined data stored with the splat file, as in glTF's `extras`: the `extras`
+     * value of a SOG's meta.json. The engine attaches no meaning to it. Undefined when the file
+     * has none, and for formats that cannot carry it.
+     *
+     * @type {*}
+     */
+    get extras(): any;
     /**
      * Gets the number of splats in the resource.
      *

package/build/playcanvas/src/scene/gsplat/gsplat-resource-base.js

@@ -77,6 +77,9 @@ class GSplatResourceBase {
 	get supportsWorkBufferGeometry() {
 		return false;
 	}
+	get extras() {
+		return void 0;
+	}
 	static createMesh(device) {
 		const splatInstanceSize = GSplatResourceBase.instanceSize;
 		const meshPositions = new Float32Array(12 * splatInstanceSize);

package/build/playcanvas/src/scene/gsplat/gsplat-resource.d.ts

@@ -22,7 +22,8 @@ export class GSplatResource extends GSplatResourceBase {
     /**
      * Updates pixel data of splatColor texture based on the supplied color components and opacity.
      * Assumes that the texture is using an RGBA format where RGB are color components influenced
-     * by SH spherical harmonics and A is opacity after a sigmoid transformation.
+     * by SH spherical harmonics and A is opacity after a sigmoid transformation, plus the optional
+     * `opacity_excess` property: the opacity above 1 that merged (decimated) gaussians carry.
      *
      * @param {GSplatData} gsplatData - The source data
      * @ignore

package/build/playcanvas/src/scene/gsplat/gsplat-resource.js

@@ -57,6 +57,9 @@ class GSplatResource extends GSplatResourceBase {
 	configureMaterialDefines(defines) {
 		defines.set("SH_BANDS", this.shBands);
 	}
+	get extras() {
+		return this.gsplatData.extras;
+	}
 	updateColorData(gsplatData) {
 		const texture = this.streams.getTexture("splatColor");
 		if (!texture) {
@@ -68,13 +71,17 @@ class GSplatResource extends GSplatResourceBase {
 		const cg = gsplatData.getProp("f_dc_1");
 		const cb = gsplatData.getProp("f_dc_2");
 		const ca = gsplatData.getProp("opacity");
+		const excess = gsplatData.getProp("opacity_excess");
 		const activated = gsplatData.activated;
 		const SH_C0 = 0.28209479177387814;
 		for (let i = 0; i < this.numSplats; ++i) {
 			const r = cr[i] * SH_C0 + 0.5;
 			const g = cg[i] * SH_C0 + 0.5;
 			const b = cb[i] * SH_C0 + 0.5;
-			const a = activated ? ca[i] : 1 / (1 + Math.exp(-ca[i]));
+			let a = activated ? ca[i] : 1 / (1 + Math.exp(-ca[i]));
+			if (excess && excess[i] > 0) {
+				a = Math.min(a + excess[i], 1.5625);
+			}
 			data[i * 4 + 0] = float2Half(r);
 			data[i * 4 + 1] = float2Half(g);
 			data[i * 4 + 2] = float2Half(b);

package/build/playcanvas/src/scene/gsplat/gsplat-sog-blind.d.ts

@@ -0,0 +1,55 @@
+export type BlindField = {
+    /**
+     * - Index of the field's texture in `meta.blind`.
+     */
+    texture: number;
+    /**
+     * - The field name.
+     */
+    name: string;
+    /**
+     * - Shader identifier suffix derived from the name.
+     */
+    id: string;
+    /**
+     * - The encoding.
+     */
+    type: string;
+    /**
+     * - Index of the field's first byte in the texel (0 = R).
+     */
+    offset: number;
+    /**
+     * - Number of bytes.
+     */
+    bytes: number;
+    /**
+     * - Value of the smallest code (unorm encodings).
+     */
+    min: number;
+    /**
+     * - Value of the largest code (unorm encodings).
+     */
+    max: number;
+};
+/**
+ * Shader code for the blind field accessors, appended to the SOG read code: the
+ * `gsplatSogBlindVS` decoding helpers, then one accessor per field from the `sogBlindField`
+ * template. The textures are declared as streams `blind0`, `blind1`, ... whose generated
+ * `loadBlind<i>()` returns the RGBA8 texel as normalized floats.
+ *
+ * @param {BlindField[]} fields - The fields, from {@link parseBlindFields}.
+ * @param {boolean} wgsl - Generate WGSL (else GLSL).
+ * @returns {string} The accessor functions, empty when there are no fields.
+ */
+export function blindAccessors(fields: BlindField[], wgsl: boolean): string;
+/**
+ * The fields of a SOG meta's blind textures, each with its texture index, byte offset and shader
+ * identifier. Fields are packed in order, so each starts where the previous field of its texture
+ * ended. The data is assumed valid, as the tools writing it check it; debug builds report
+ * problems.
+ *
+ * @param {object} meta - The SOG meta.json.
+ * @returns {BlindField[]} The fields.
+ */
+export function parseBlindFields(meta: object): BlindField[];

package/build/playcanvas/src/scene/gsplat/gsplat-sog-blind.js

@@ -0,0 +1,55 @@
+import glslBlindField from "../shader-lib/glsl/chunks/gsplat/vert/formats/sogBlindField.js";
+import wgslBlindField from "../shader-lib/wgsl/chunks/gsplat/vert/formats/sogBlindField.js";
+const BLIND_TYPE_BYTES = { u8: 1, u16: 2, u24: 3, u32: 4, f16: 2, f32: 4, unorm8: 1, unorm16: 2 };
+const DEFAULT_RANGE = [0, 1];
+const isIntegerType = (type) => type[0] === "u" && !type.startsWith("unorm");
+const RE_ID = /\{id\}/g;
+const RE_RETURN_TYPE = /\{returnType\}/g;
+const RE_TEXTURE = /\{texture\}/g;
+const RE_OFFSET = /\{offset\}/g;
+const RE_BYTES = /\{bytes\}/g;
+const RE_DECODE = /\{decode\}/g;
+const blindFieldId = (name) => name.replace(/\W/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+const parseBlindFields = (meta) => {
+	const fields = [];
+	(meta.blind ?? []).forEach((texture, t) => {
+		let offset = 0;
+		for (const f of texture.fields) {
+			const bytes = BLIND_TYPE_BYTES[f.type];
+			const [min, max] = f.range ?? DEFAULT_RANGE;
+			fields.push({ texture: t, name: f.name, id: blindFieldId(f.name), type: f.type, offset, bytes, min, max });
+			offset += bytes;
+		}
+	});
+	return fields;
+};
+const floatLiteral = (v) => {
+	const s = String(v);
+	return /[.e]/i.test(s) ? s : `${s}.0`;
+};
+const blindAccessors = (fields, wgsl) => {
+	if (!fields.length) {
+		return "";
+	}
+	const template = wgsl ? wgslBlindField : glslBlindField;
+	const accessors = fields.map((f) => {
+		const integer = isIntegerType(f.type);
+		let decode = "bits";
+		if (f.type === "f16") {
+			decode = "sogBlindF16(bits)";
+		} else if (f.type === "f32") {
+			decode = "sogBlindF32(bits)";
+		} else if (!integer) {
+			const steps = f.type === "unorm8" ? "255.0" : "65535.0";
+			decode = `sogBlindUnorm(bits, ${steps}, ${floatLiteral(f.min)}, ${floatLiteral(f.max)})`;
+		}
+		return template.replace(RE_ID, f.id).replace(RE_RETURN_TYPE, integer ? wgsl ? "u32" : "uint" : wgsl ? "f32" : "float").replace(RE_TEXTURE, String(f.texture)).replace(RE_OFFSET, String(f.offset)).replace(RE_BYTES, String(f.bytes)).replace(RE_DECODE, decode);
+	});
+	return `
+#include "gsplatSogBlindVS"
+${accessors.join("")}`;
+};
+export {
+	blindAccessors,
+	parseBlindFields
+};

package/build/playcanvas/src/scene/gsplat/gsplat-sog-data.d.ts

@@ -10,7 +10,13 @@ export class GSplatSogData {
     sh_centroids: any;
     sh_labels: any;
     /**
-     * V2-only codebook LUT (256x1 RGBA32F): .r = scales, .g = sh0, .b = shN, .a unused.
+     * V3 per-gaussian blind data textures (RGBA8), one per `meta.blind` entry.
+     *
+     * @type {Texture[]}
+     */
+    blind: Texture[];
+    /**
+     * V2/V3 codebook LUT (256x1 RGBA32F): .r = scales, .g = sh0, .b = shN, .a unused.
      * Built from meta codebooks in prepareCodebook(). Null for V1 assets.
      *
      * @type {Texture|null}
@@ -49,8 +55,8 @@ export class GSplatSogData {
     decompress(): Promise<GSplatData>;
     generateCenters(): Promise<void>;
     /**
-     * Creates the V2 codebook LUT texture. Packs the three 256-entry scalar codebooks
-     * (scales, sh0, shN) into a single 256x1 RGBA32F texture:
+     * Creates the V2/V3 codebook LUT texture. Packs the 256-entry scalar codebooks into a
+     * single 256x1 RGBA32F texture:
      * - .r = scales codebook
      * - .g = sh0 codebook
      * - .b = shN codebook

package/build/playcanvas/src/scene/gsplat/gsplat-sog-data.js

@@ -29,6 +29,11 @@ const readImageDataAsync = (texture) => {
 		immediate: true
 	});
 };
+const shCoeffs = (shBands) => ({ 1: 3, 2: 8, 3: 15, 4: 24 })[shBands] ?? 0;
+const decodeSogOpacity = (b) => {
+	const s = b / 204;
+	return s * s;
+};
 const resolve = (scope, values) => {
 	for (const key in values) {
 		scope.resolve(key).setValue(values[key]);
@@ -39,15 +44,18 @@ class GSplatSogIterator {
 		const lerp = (a, b, t) => a * (1 - t) + b * t;
 		const { meta, shBands } = data;
 		const { means, scales, sh0, shN } = meta;
-		const means_l_data = p && data.means_l._levels[0];
-		const means_u_data = p && data.means_u._levels[0];
-		const quats_data = r && data.quats._levels[0];
-		const scales_data = s && data.scales._levels[0];
+		const v3 = meta.version === 3;
+		const codebooks = meta.version >= 2;
+		const means_l_data = (p || r && v3) && data.means_l._levels[0];
+		const means_u_data = (p || r && v3) && data.means_u._levels[0];
+		const quats_data = r && !v3 && data.quats._levels[0];
+		const scales_data = (s || r && v3) && data.scales._levels[0];
 		const sh0_data = c && data.sh0._levels[0];
 		const sh_labels_data = sh && data.sh_labels._levels[0];
 		const sh_centroids_data = sh && data.sh_centroids._levels[0];
 		const norm = Math.SQRT2;
-		const coeffs = { 1: 3, 2: 8, 3: 15 }[shBands] ?? 0;
+		const coeffs = shCoeffs(shBands);
+		const shStride = shBands > 3 ? 24 : 15;
 		this.read = (i) => {
 			if (p) {
 				const nx = lerp(means.mins[0], means.maxs[0], ((means_u_data[i * 4 + 0] << 8) + means_l_data[i * 4 + 0]) / 65535);
@@ -57,7 +65,15 @@ class GSplatSogIterator {
 				p.y = Math.sign(ny) * (Math.exp(Math.abs(ny)) - 1);
 				p.z = Math.sign(nz) * (Math.exp(Math.abs(nz)) - 1);
 			}
-			if (r) {
+			if (r && v3) {
+				const px = (means_l_data[i * 4 + 3] - 128) / 127;
+				const py = (means_u_data[i * 4 + 3] - 128) / 127;
+				const pz = (scales_data[i * 4 + 3] - 128) / 127;
+				const len = Math.sqrt(px * px + py * py + pz * pz);
+				const t = len * Math.PI * 0.5;
+				const k = len > 1e-12 ? Math.sin(t) / len : Math.PI * 0.5;
+				r.set(px * k, py * k, pz * k, Math.cos(t));
+			} else if (r) {
 				const a = (quats_data[i * 4 + 0] / 255 - 0.5) * norm;
 				const b = (quats_data[i * 4 + 1] / 255 - 0.5) * norm;
 				const c2 = (quats_data[i * 4 + 2] / 255 - 0.5) * norm;
@@ -79,7 +95,7 @@ class GSplatSogIterator {
 				}
 			}
 			if (s) {
-				if (meta.version === 2) {
+				if (codebooks) {
 					const sx = scales.codebook[scales_data[i * 4 + 0]];
 					const sy = scales.codebook[scales_data[i * 4 + 1]];
 					const sz = scales.codebook[scales_data[i * 4 + 2]];
@@ -92,11 +108,11 @@ class GSplatSogIterator {
 				}
 			}
 			if (c) {
-				if (meta.version === 2) {
+				if (codebooks) {
 					const r2 = sh0.codebook[sh0_data[i * 4 + 0]];
 					const g = sh0.codebook[sh0_data[i * 4 + 1]];
 					const b = sh0.codebook[sh0_data[i * 4 + 2]];
-					const a = sh0_data[i * 4 + 3] / 255;
+					const a = v3 ? decodeSogOpacity(sh0_data[i * 4 + 3]) : sh0_data[i * 4 + 3] / 255;
 					c.set(
 						0.5 + r2 * SH_C0,
 						0.5 + g * SH_C0,
@@ -117,19 +133,19 @@ class GSplatSogIterator {
 				}
 			}
 			if (sh) {
-				const n = sh_labels_data[i * 4 + 0] + (sh_labels_data[i * 4 + 1] << 8);
+				const n = sh_labels_data[i * 4 + 0] + (sh_labels_data[i * 4 + 1] << 8) + (v3 ? sh_labels_data[i * 4 + 2] << 16 : 0);
 				const u = n % 64 * coeffs;
 				const v = Math.floor(n / 64);
-				if (meta.version === 2) {
+				if (codebooks) {
 					for (let j = 0; j < 3; ++j) {
 						for (let k = 0; k < coeffs; ++k) {
-							sh[j * 15 + k] = shN.codebook[sh_centroids_data[(u + k) * 4 + j + v * data.sh_centroids.width * 4]];
+							sh[j * shStride + k] = shN.codebook[sh_centroids_data[(u + k) * 4 + j + v * data.sh_centroids.width * 4]];
 						}
 					}
 				} else {
 					for (let j = 0; j < 3; ++j) {
 						for (let k = 0; k < coeffs; ++k) {
-							sh[j * 15 + k] = lerp(shN.mins, shN.maxs, sh_centroids_data[(u + k) * 4 + j + v * data.sh_centroids.width * 4] / 255);
+							sh[j * shStride + k] = lerp(shN.mins, shN.maxs, sh_centroids_data[(u + k) * 4 + j + v * data.sh_centroids.width * 4] / 255);
 						}
 					}
 				}
@@ -147,6 +163,7 @@ class GSplatSogData {
 	sh0;
 	sh_centroids;
 	sh_labels;
+	blind = [];
 	codebookTexture = null;
 	url = "";
 	_centers = null;
@@ -162,12 +179,13 @@ class GSplatSogData {
 		this.sh0?.destroy();
 		this.sh_centroids?.destroy();
 		this.sh_labels?.destroy();
+		this.blind.forEach((t) => t.destroy());
 		this.codebookTexture?.destroy();
 		this.codebookTexture = null;
 	}
 	// calculate the number of bands given the centroids texture width
 	static calcBands(centroidsWidth) {
-		const shBandsWidths = { 192: 1, 512: 2, 960: 3 };
+		const shBandsWidths = { 192: 1, 512: 2, 960: 3, 1536: 4 };
 		return shBandsWidths[centroidsWidth] ?? 0;
 	}
 	destroy() {
@@ -228,22 +246,27 @@ class GSplatSogData {
 			"rot_3"
 		];
 		this._patchCodebooks();
-		const { shBands } = this;
+		const { shBands, meta } = this;
+		const restCount = shBands > 3 ? 72 : 45;
 		const { means_l, means_u, quats, scales, sh0, sh_labels, sh_centroids } = this;
 		means_l._levels[0] = await readImageDataAsync(means_l);
 		means_u._levels[0] = await readImageDataAsync(means_u);
-		quats._levels[0] = await readImageDataAsync(quats);
+		if (quats) quats._levels[0] = await readImageDataAsync(quats);
 		scales._levels[0] = await readImageDataAsync(scales);
 		sh0._levels[0] = await readImageDataAsync(sh0);
 		if (shBands > 0) {
 			sh_labels._levels[0] = await readImageDataAsync(sh_labels);
 			sh_centroids._levels[0] = await readImageDataAsync(sh_centroids);
 			const shMembers = [];
-			for (let i = 0; i < 45; ++i) {
+			for (let i = 0; i < restCount; ++i) {
 				shMembers.push(`f_rest_${i}`);
 			}
 			members.splice(members.indexOf("f_dc_0") + 1, 0, ...shMembers);
 		}
+		const hasExcess = meta.version === 3 && (meta.opacity?.max ?? 1) > 1;
+		if (hasExcess) {
+			members.push("opacity_excess");
+		}
 		const data = {};
 		members.forEach((name) => {
 			data[name] = new Float32Array(this.numSplats);
@@ -252,7 +275,7 @@ class GSplatSogData {
 		const r = new Quat();
 		const s = new Vec3();
 		const c = new Vec4();
-		const sh = shBands > 0 ? new Float32Array(45) : null;
+		const sh = shBands > 0 ? new Float32Array(restCount) : null;
 		const iter = this.createIter(p, r, s, c, sh);
 		for (let i = 0; i < this.numSplats; ++i) {
 			iter.read(i);
@@ -270,24 +293,30 @@ class GSplatSogData {
 			data.f_dc_1[i] = (c.y - 0.5) / SH_C0;
 			data.f_dc_2[i] = (c.z - 0.5) / SH_C0;
 			data.opacity[i] = c.w <= 0 ? -40 : c.w >= 1 ? 40 : -Math.log(1 / c.w - 1);
+			if (hasExcess) {
+				data.opacity_excess[i] = c.w > 1 ? c.w - 1 : 0;
+			}
 			if (sh) {
-				for (let c2 = 0; c2 < 45; ++c2) {
+				for (let c2 = 0; c2 < restCount; ++c2) {
 					data[`f_rest_${c2}`][i] = sh[c2];
 				}
 			}
 		}
-		return new GSplatData([{
+		const properties = members.map((name) => {
+			return {
+				name,
+				type: "float",
+				byteSize: 4,
+				storage: data[name]
+			};
+		});
+		const result = new GSplatData([{
 			name: "vertex",
 			count: this.numSplats,
-			properties: members.map((name) => {
-				return {
-					name,
-					type: "float",
-					byteSize: 4,
-					storage: data[name]
-				};
-			})
+			properties
 		}]);
+		result.extras = meta.extras;
+		return result;
 	}
 	async generateCenters() {
 		const { device, width, height } = this.means_l;
@@ -383,7 +412,7 @@ class GSplatSogData {
 		const device = this.means_l?.device;
 		if (this.destroyed || !device || device._destroyed) return;
 		this._patchCodebooks();
-		if (this.meta.version === 2) {
+		if (this.meta.version >= 2) {
 			this._createCodebookTexture();
 		}
 	}

package/build/playcanvas/src/scene/gsplat/gsplat-sog-resource.d.ts

@@ -17,6 +17,14 @@ export class GSplatSogResource extends GSplatResourceBase {
      * @ignore
      */
     constructor(device: GraphicsDevice, gsplatData: GSplatSogData, options?: object);
+    /**
+     * The `SOG_BLIND_<name>` define of each blind field, built once so setting the material
+     * defines on every work buffer update allocates nothing.
+     *
+     * @type {string[]}
+     * @private
+     */
+    private _blindDefines;
     /**
      * Opts each of the owned source textures into releasing its CPU-side ImageBitmap after
      * upload. Called by the gsplat octree, which re-creates these resources from scratch on