[slimbuck]

Adds support for SOG v3, proposed in playcanvas/splat-transform#362, and draws gaussians whose opacity is above 1. SOG v2 and v1 files load as before.

SOG v3 loading

• Rotations are stored as a 24-bit exponential map in the alpha channels of means_l, means_u and scales. quats.webp is not fetched for v3.
• Opacity is a fixed byte, A = (b / 204)^2, decoded inline: 0 to 1.5625, with 1 exactly at byte 204. meta.opacity.max is written only when some gaussian's opacity exceeds 1.
• Spherical harmonics support 4 bands (a 1536-pixel-wide palette).
• SH palette labels are 24-bit: shN_labels.b holds bits 16–23, so palettes can exceed 65536 entries. This applies to the GLSL and WGSL SH chunks and the CPU iterator.
• The optional blind.webp is exposed as a resource stream, readable with getBlind() in work-buffer modifiers. The CPU iterator and decompress() output opacity_excess and the blind column.
• The extras of meta.json / lod-meta.json are exposed as resource.extras, and kept by decompress().
• The parsers report an error for unknown SOG versions.

Over-unity opacity

Decimation merges several gaussians into one, and the merged gaussian can carry more mass than a gaussian with opacity 1 can hold. SOG v3 and PLY (opacity_excess column) store that true opacity, up to 1.5625. The unified renderer draws such a gaussian with peak alpha 1 as an opaque core with the plain gaussian's falloff stretched over the rest of its footprint. The drawn mass is quadratic in the core's radius, so the radius that matches the opacity exactly has a closed form, and the footprint is the plain gaussian's.

• Opacity travels in the work buffer's alpha, with no extra streams, defines or settings: the renderer always draws it, and data without opacity above 1 draws as before. The large format stores it as a half float; the compact format and the GPU-sort projection cache in WebXR store it as the SOG v3 byte.
• The vertex shaders derive the core radius from alpha (gsplatPlateauCore), stretch the plain alphaClip trim past the core, and pass 1 + the radius to the fragment shader as alpha. The fragment shader remaps the distance from the centre past the core and evaluates the plain gaussian. Culls, extents, the projector and the shadow cull are unchanged.
• The anti-aliasing factor multiplies alpha before the core radius is chosen, so the quad and GPU-sort paths match and the mass stays exact.
• Overdraw mode draws every gaussian with the plain profile.
• PLY: GSplatResource adds opacity_excess to the sigmoid opacity, capped at 1.5625.

Compact work buffer opacity

The compact format (the default) stored opacity as a linear byte clamped to 1, so it now uses the SOG v3 byte for every scene. Existing scenes render slightly differently in compact mode. Measured against the large format, opacity is more accurate: 57.7 vs 55.1 dB on a low-opacity scene, and unchanged on a typical one. Steps are coarser near 1 and finer at low opacity. Large-format rendering is unchanged.

Testing

• test/scene/gsplat-sog-v3.test.mjs covers v3 decoding. test/scene/gsplat-unified/gsplat-overunity.test.mjs checks that the GLSL and WGSL core-radius constants match, that the radius is 0 at opacity 1, and that each opacity in (1, 1.5625] draws its mass to within 1e-6.
• On WebGL2, a v2 SOG with SH and a PLY render byte-identical to main in the large format.
• Isolated splats at five sizes and four opacities draw the same mass on the WebGL2 and WebGPU quad paths and the GPU-sort path. With anti-aliasing, the AA/non-AA mass ratio matches σ²/(σ² + 0.3) for plain and plateau splats alike.
• An anti-aliased scene decimated six times renders within noise of this PR's earlier versions (64–87 dB against the previous shape fits, with no gap pixels).

[mvaligursky]

A concern about where the plateau is stored. Decimated data will be the norm for large assets (most scenes over ~1M splats), and almost all of them will have some splats with opacity above 1. In our tests the merged opacity reaches about 20. So the plateau path will be on nearly all the time, and these become permanent costs:

• Extra splatPlateau work buffer stream: one more render target in the copy pass, and one more texture read in the quad VS, the projector, the shadow cull and pick.
• 9th projection cache word: entries grow from 32 B to 36 B, so most of them cross a 32-byte sector boundary. That nearly doubles the sectors the hybrid VS reads.
• Runtime detection: _checkOverUnity, the format change, the GSPLAT_OVERUNITY toggles, and the recompile plus work buffer recreation when the first decimated LOD arrives. Once most data is decimated, this mostly just adds a hitch.

The plateau fits in the existing storage instead, with no detection at all.

1. Work buffer: store the plateau in the alpha slot

When the plateau is above 1, the copy pass clamps the stored opacity to exactly 1 (color.w = min(color.w, 1.0) after encodePlateau). So for those splats the alpha slot holds no information, and D' can go there. The copy pass writes color.w = A <= 1 ? A : D', and each format encodes that value. The writeSplat signature doesn't change.

Large format (alpha is a half): the value is written as is, with no loss.

float getOpacity() {
    // ... loads and caches cachedColor as now
    return min(cachedColor.a, 1.0);
}

// call after getOpacity(), reads the same cached data
float getPlateau() {
    return max(cachedColor.a, 1.0);
}

Compact format (alpha is the top byte of dataTransformA.w): split the byte.

• Codes 0–191 are opacity.
• Codes 192–255 are opacity 1, with log2(D') in (0, 2]. That covers D' ≤ 4, so true opacity up to ~31.5; anything above is clamped.

// writeSplat
float a = color.a;
uint alphaBits = a > 1.0 ?
    191u + uint(clamp(log2(a) * 32.0 + 0.5, 1.0, 64.0)) :
    uint(clamp(a, 0.0, 1.0) * 191.0 + 0.5);

// read
float getOpacity() {
    uint code = cachedTransformA.a >> 24u;
    return code > 191u ? 1.0 : float(code) / 191.0;
}

float getPlateau() {
    uint code = cachedTransformA.a >> 24u;
    return code > 191u ? exp2(float(code - 191u) / 32.0) : 1.0;
}

Precision compared with the separate R8 (maximum error, true opacity 1–30):

	Separate R8	Split byte
Plateau mass	±2.2%	±2.9%
Opacity	±0.0020	±0.0026

Both are well under the error compact already has from its 8-bit log scales, up to ±8.6% in area. If low-opacity precision matters, a sqrt mapping over the 192 opacity codes would make faint splats more precise than they are today.

Non-decimated data never produces a plateau above 1, so the decode can always be compiled in. The plateau > 1.0 branch takes the same path for every vertex and fragment of a splat. That removes:

• the splatPlateau stream
• _checkOverUnity, _enableOverUnity and _compensationVersion
• the GSPLAT_OVERUNITY toggles
• the shadow material reconfiguration

compensation = false becomes a clamp in the copy pass. The clamp in the non-unified uncompressed.js stays.

One detail: in the large format, alpha lives in dataColor, which the color-only (SH update) pass rewrites, so that pass needs D' too. Either keep alpha with a color write mask in the color-only pass, or replace the 24-step bisection with a cheaper solve. Compact isn't affected, because its alpha isn't in dataColor.

2. Projection cache: stay at 8 words

The plateau can't share the cached alpha slot. That alpha includes the AA compensation and modifySplatColor, so plateau splats can be below 1 there. But v2 is redundant. The projector writes:

v1 = l1 * dir;
v2 = l2 * vec2f(dir.y, -dir.x);

So v2 is always v1 rotated by 90° and scaled by l2 / l1. Store that ratio and the plateau in v2's word:

// projector
projCache[base + 5u] = pack2x16float(vec2f(l2 / max(l1, 1e-6), plateau));

// hybrid VS
let ratioPlateau = unpack2x16float(projCache[base + 5u]);
let v2 = ratioPlateau.x * vec2f(v1.y, -v1.x);
let plateau = ratioPlateau.y;

The cost is one multiply, and v2 stays exactly perpendicular to v1. The same change applies to XR (word 6) and pick (word 5). Color, alpha and the user varyings stay as they are, and the stride stays at 32 B.

syncWithFormat() fix

I've extracted the syncWithFormat() fix into #9876 so it can land on its own, with a test that adds a stream through addExtraStreams(). It can be dropped from this PR once that merges.

[mvaligursky]

I didn't look at this "Drive over-unity gsplat opacity with a uniform" commit in details, but I think the shader that copies data to work buffer should convert whatever alpha the resource has to over-unity, and then the renderer would be always unified and need to flags.

[mvaligursky]

additionally, we have two formats for work buffer:

• compact - 8 bit alpha, that should store over-opacity in 8bits as currently just remap it
• fullsize - we store alpha in 16bit, and here alpha should be stored as real f16 value directly, no decoding during rendering

[slimbuck]

I didn't look at this "Drive over-unity gsplat opacity with a uniform" commit in details, but I think the shader that copies data to work buffer should convert whatever alpha the resource has to over-unity, and then the renderer would be always unified and need to flags.

yep it works like this now.

[mvaligursky]

Looks good!