@onerjs/core 8.56.4 → 9.0.1

package/Meshes/GaussianSplatting/gaussianPointSplattingController.pure.js

@@ -0,0 +1,1212 @@
+/** This file must only contain pure code and pure imports */
+import { Scene } from "../../scene.pure.js";
+import { Matrix, Quaternion } from "../../Maths/math.vector.pure.js";
+import { Material } from "../../Materials/material.pure.js";
+import { GaussianSplattingMaterial } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.pure.js";
+
+import { Mesh } from "../mesh.pure.js";
+import { VertexData } from "../mesh.vertexData.js";
+import { Logger } from "../../Misc/logger.js";
+import { ToHalfFloat } from "../../Misc/textureTools.js";
+import { GaussianPointSplattingRenderer, _GetPackedShBytesPerSplat, _HasGaussianPointSplattingProjectedDepth } from "./gaussianPointSplattingRenderer.pure.js";
+import { GaussianPointSplattingBlitMaterial } from "../../Materials/GaussianSplatting/gaussianPointSplattingBlitMaterial.pure.js";
+import { GaussianPointSplattingDepthBlitMaterial } from "../../Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.pure.js";
+import { GaussianSplattingDebugMaterialPlugin } from "../../Materials/GaussianSplatting/gaussianSplattingDebugMaterialPlugin.pure.js";
+import { GaussianSplattingSolidColorMaterialPlugin } from "../../Materials/GaussianSplatting/gaussianSplattingSolidColorMaterialPlugin.pure.js";
+import { GaussianSplattingSizeMaterialPlugin } from "../../Materials/GaussianSplatting/gaussianSplattingSizeMaterialPlugin.pure.js";
+import { GaussianSplattingOverdrawMaterialPlugin } from "../../Materials/GaussianSplatting/gaussianSplattingOverdrawMaterialPlugin.pure.js";
+import { RegisterEnginesWebGPUExtensionsEngineComputeShader } from "../../Engines/WebGPU/Extensions/engine.computeShader.pure.js";
+import { _SetGaussianPointSplattingControllerFactory, } from "./gaussianSplattingMesh.pure.js";
+const _BytesPerSplat = 32;
+// Loaded on demand to keep this module side-effect free; the wrapper imports them eagerly.
+let _DependenciesReady = false;
+let _DependenciesPromise = null;
+let _DependenciesFailed = false;
+async function _LoadDependenciesAsync() {
+    try {
+        await Promise.all([
+            import("../../ShadersWGSL/gpsPreprocess.compute.js"),
+            import("../../ShadersWGSL/gpsScanBlocks.compute.js"),
+            import("../../ShadersWGSL/gpsScanSums.compute.js"),
+            import("../../ShadersWGSL/gpsScanAdd.compute.js"),
+            import("../../ShadersWGSL/gpsPartition.compute.js"),
+            import("../../ShadersWGSL/gpsSplat.compute.js"),
+            import("../../ShadersWGSL/gpsResolve.compute.js"),
+            import("../../ShadersWGSL/gpsHiZBuild.compute.js"),
+            import("../../ShadersWGSL/gaussianPointSplattingBlit.vertex.js"),
+            import("../../ShadersWGSL/gaussianPointSplattingBlit.fragment.js"),
+            import("../../ShadersWGSL/gaussianPointSplattingDepthBlit.fragment.js"),
+        ]);
+        _DependenciesReady = true;
+    }
+    catch (error) {
+        _DependenciesFailed = true;
+        _DependenciesPromise = null;
+        Logger.Error(`GaussianSplattingMesh: failed to load point-splatting shaders: ${String(error)}`);
+    }
+}
+function _LoadDependencies() {
+    if (!_DependenciesReady && !_DependenciesPromise) {
+        _DependenciesFailed = false;
+        _DependenciesPromise = _LoadDependenciesAsync();
+    }
+}
+const _F32Scratch = /*#__PURE__*/ new Float32Array(1);
+const _U32Scratch = /*#__PURE__*/ new Uint32Array(_F32Scratch.buffer);
+/**
+ * Packs two floats as half-floats into one u32 (a in the low 16 bits).
+ * @param a value for the low 16 bits
+ * @param b value for the high 16 bits
+ * @returns the packed u32
+ */
+function _Pack2HalfFloat(a, b) {
+    return (ToHalfFloat(a) | (ToHalfFloat(b) << 16)) >>> 0;
+}
+/**
+ * Owns the WebGPU compute point-splatting path of one {@link GaussianSplattingMesh}: decode, dispatch,
+ * auto render scale, and the compositors that blit the result into the scene.
+ *
+ * The mesh never imports this module, so bundles without point splatting do not include it. It is enabled
+ * by {@link RegisterGaussianPointSplattingController}, which the side-effect wrapper calls.
+ */
+export class GaussianPointSplattingController {
+    /**
+     * Creates a point-splatting controller for a Gaussian Splatting mesh.
+     * @param mesh the mesh whose splat data this controller renders
+     */
+    constructor(mesh) {
+        this._colorMode = false;
+        this._depthMode = false;
+        this._projectionClipRange = new Float64Array(2);
+        this._scale = 1;
+        this._renderScale = "auto";
+        this._occlusionCulling = false;
+        // Auto scale: N is measured once per generation, on a non-reset frame (the reset frame has no Hi-Z cull
+        // and over-counts), then frozen so a converged image never mixes two render scales.
+        this._autoN = 2;
+        this._autoMeasuredGeneration = -1;
+        this._lastRenderedGeneration = -1;
+        this._autoRequestId = 0;
+        this._budgetReadPending = false;
+        this._resultReady = false;
+        this._colorHistoryReady = false;
+        this._colorUsesCameraTransform = false;
+        this._cameraFrameId = -1;
+        this._cameraId = -1;
+        /** Whether the latest compute run succeeded; unlike `_resultReady`, not cleared at frame start. */
+        this._progressReady = false;
+        this._computedWidth = 0;
+        this._computedHeight = 0;
+        // Counters of the last dispatch, surfaced by `progress`.
+        this._progressFrameCount = 0;
+        this._progressGeneration = -1;
+        this._progressCycleLength = 0;
+        this._streamingWarned = false;
+        this._sourceWarned = false;
+        this._workloadWarned = false;
+        this._invalidProjectionWarned = false;
+        this._renderer = null;
+        this._blit = null;
+        this._blitMesh = null;
+        this._depthBlit = null;
+        this._depthBlitMesh = null;
+        this._computeObserver = null;
+        this._cameraObserver = null;
+        this._restoreObserver = null;
+        this._splatCount = 0;
+        this._partCount = 1;
+        this._decodedPartCount = 0;
+        this._decodedRevision = -1;
+        this._decodedShDegree = -1;
+        this._partLocalMin = new Float32Array(3);
+        this._partLocalMax = new Float32Array(3);
+        this._partScratch = new Float32Array(40);
+        this._decodedSplatsData = null;
+        this._vpMatrix = new Matrix();
+        this._cameraVpMatrix = new Matrix();
+        this._inverseProjection = new Matrix();
+        this._outputSize = { width: 1, height: 1 };
+        this._depthSpan = [0, 0];
+        this._mesh = mesh;
+        this._scene = mesh.getScene();
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.colorRenderMode} */
+    get colorRenderMode() {
+        return this._colorMode;
+    }
+    set colorRenderMode(value) {
+        if (value === this._colorMode) {
+            return;
+        }
+        if (value && !this._scene.getEngine().isWebGPU) {
+            Logger.Warn("GaussianSplattingMesh: point-splatting render mode requires a WebGPU engine; ignoring.");
+            return;
+        }
+        this._colorMode = value;
+        if (!value) {
+            this._colorHistoryReady = false;
+        }
+        if (value) {
+            this._ensureCompute();
+            this._enableColorBlit();
+        }
+        else {
+            this._blitMesh?.setEnabled(false);
+            this._releaseComputeIfIdle();
+        }
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.depthRenderMode} */
+    get depthRenderMode() {
+        return this._depthMode;
+    }
+    set depthRenderMode(value) {
+        if (value === this._depthMode) {
+            return;
+        }
+        if (value && !this._scene.getEngine().isWebGPU) {
+            Logger.Warn("GaussianSplattingMesh: point-splatting depth render mode requires a WebGPU engine; ignoring.");
+            return;
+        }
+        this._depthMode = value;
+        if (value) {
+            this._ensureCompute();
+            this._enableDepthBlit();
+        }
+        else {
+            this._depthBlitMesh?.setEnabled(false);
+            this._releaseComputeIfIdle();
+        }
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.progress} */
+    get progress() {
+        if (!this._computeActive || !this._progressReady || !this._renderer) {
+            return null;
+        }
+        return {
+            renderedFrameCount: this._progressFrameCount,
+            accumulationVersion: this._progressGeneration,
+            pixelCycleLength: this._progressCycleLength,
+        };
+    }
+    /** True while either point-splatting mode is on, i.e. while the shared compute must run. */
+    get _computeActive() {
+        return (this._colorMode || this._depthMode) && !_DependenciesFailed && !this._mesh._pointStreamingUnsupported && !this._hasUnsupportedSource;
+    }
+    /** GPU-only SOG and standalone streams have no retained splats for the compute decoder. */
+    get _hasUnsupportedSource() {
+        return this._mesh.useSog || (!this._mesh._splatsData && this._mesh.getTotalVertices() > 0);
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.pointScale} */
+    get pointScale() {
+        return this._scale;
+    }
+    set pointScale(value) {
+        if (value === this._scale) {
+            return;
+        }
+        this._scale = value;
+        if (this._renderer) {
+            this._renderer.pointScale = value;
+            this._renderer.resetAccumulation();
+        }
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.occlusionCulling} */
+    get occlusionCulling() {
+        return this._occlusionCulling;
+    }
+    set occlusionCulling(value) {
+        if (value === this._occlusionCulling) {
+            return;
+        }
+        this._occlusionCulling = value;
+        if (this._renderer) {
+            this._renderer.occlusionCulling = value;
+            this._renderer.resetAccumulation();
+        }
+    }
+    /** Lazily builds the compute shared by the color and depth modes. Idempotent. */
+    _ensureCompute() {
+        const engine = this._scene.getEngine();
+        _LoadDependencies();
+        if (!this._renderer) {
+            // ComputeShader creates its compute context on construction, so the engine extension goes first.
+            RegisterEnginesWebGPUExtensionsEngineComputeShader();
+            this._renderer = new GaussianPointSplattingRenderer(engine);
+            this._renderer.pointScale = this._scale;
+            this._renderer.occlusionCulling = this._occlusionCulling;
+            this._decodedSplatsData = null;
+        }
+        if (!this._mesh._pointStreamingUnsupported && !this._hasUnsupportedSource && this._isWorkloadSupported()) {
+            this._syncData();
+        }
+        if (!this._computeObserver) {
+            this._computeObserver = this._scene.onBeforeRenderObservable.add(() => {
+                this._resultReady = false;
+            });
+        }
+        if (!this._cameraObserver) {
+            this._cameraObserver = this._scene.onBeforeCameraRenderObservable.add((camera) => {
+                this._cameraFrameId = this._scene.getFrameId();
+                this._cameraId = camera.uniqueId;
+                this._cameraVpMatrix.copyFrom(this._scene.getTransformMatrix());
+            });
+        }
+        if (!this._restoreObserver) {
+            this._restoreObserver = engine.onContextRestoredObservable.add(() => {
+                // Rebuilt storage buffers are empty, including the image sentinel and cached splat uploads.
+                this._releaseComputeResources();
+                this._releaseBlitResources();
+                this._ensureCompute();
+                if (this._colorMode) {
+                    this._enableColorBlit();
+                }
+                if (this._depthMode) {
+                    this._enableDepthBlit();
+                }
+            });
+        }
+    }
+    /** Tears down the shared compute once neither point-splatting mode needs it anymore. */
+    _releaseComputeIfIdle() {
+        if (this._colorMode || this._depthMode) {
+            return;
+        }
+        if (this._computeObserver) {
+            this._scene.onBeforeRenderObservable.remove(this._computeObserver);
+            this._computeObserver = null;
+        }
+        if (this._cameraObserver) {
+            this._scene.onBeforeCameraRenderObservable.remove(this._cameraObserver);
+            this._cameraObserver = null;
+        }
+        if (this._restoreObserver) {
+            this._scene.getEngine().onContextRestoredObservable.remove(this._restoreObserver);
+            this._restoreObserver = null;
+        }
+        this._releaseComputeResources();
+    }
+    _releaseComputeResources() {
+        this._autoRequestId++;
+        this._renderer?.dispose();
+        this._renderer = null;
+        this._decodedSplatsData = null;
+        this._resultReady = false;
+        this._colorHistoryReady = false;
+        this._cameraFrameId = -1;
+        this._progressReady = false;
+        this._budgetReadPending = false;
+        this._autoN = 2;
+        this._autoMeasuredGeneration = -1;
+        this._lastRenderedGeneration = -1;
+    }
+    _releaseBlitResources() {
+        this._blit?.dispose();
+        this._blitMesh?.dispose();
+        this._depthBlit?.dispose();
+        this._depthBlitMesh?.dispose();
+        this._blit = null;
+        this._blitMesh = null;
+        this._depthBlit = null;
+        this._depthBlitMesh = null;
+    }
+    /** Builds a fullscreen compositor triangle. It is disabled and drawn manually, so its clip-space
+     * geometry never leaks into other geometry passes.
+     * @param name the compositor mesh name
+     * @param material the blit material to render it with
+     * @returns the created compositor mesh
+     */
+    _createBlitMesh(name, material) {
+        const blitMesh = new Mesh(name, this._scene);
+        const vd = new VertexData();
+        vd.positions = [-1, -1, 0, 3, -1, 0, -1, 3, 0];
+        vd.indices = [0, 1, 2];
+        vd.applyToMesh(blitMesh);
+        blitMesh.material = material;
+        blitMesh.doNotSerialize = true;
+        blitMesh.isPickable = false;
+        blitMesh.doNotSyncBoundingInfo = true;
+        blitMesh.setEnabled(false);
+        blitMesh.reservedDataStore = { hidden: true };
+        blitMesh.computeWorldMatrix(true);
+        return blitMesh;
+    }
+    /** Lazily builds the color compositor. */
+    _enableColorBlit() {
+        if (!this._blit) {
+            this._blit = new GaussianPointSplattingBlitMaterial(this._mesh.name + "_blit", this._scene);
+            // Internal compositor bound to storage buffers, which cannot round-trip through serialization.
+            this._blit.doNotSerialize = true;
+        }
+        if (!this._blitMesh) {
+            this._blitMesh = this._createBlitMesh(this._mesh.name + "_blitMesh", this._blit);
+        }
+    }
+    /** Lazily builds the depth compositor. */
+    _enableDepthBlit() {
+        if (!this._depthBlit) {
+            this._depthBlit = new GaussianPointSplattingDepthBlitMaterial(this._mesh.name + "_depthBlit", this._scene);
+            // Internal compositor bound to storage buffers, which cannot round-trip through serialization.
+            this._depthBlit.doNotSerialize = true;
+        }
+        if (!this._depthBlitMesh) {
+            this._depthBlitMesh = this._createBlitMesh(this._mesh.name + "_depthBlitMesh", this._depthBlit);
+        }
+    }
+    /**
+     * Checks the mesh's current data and output size against the device buffer limits, before anything is
+     * decoded or allocated. Warns once when they do not fit.
+     * @returns whether the workload fits
+     */
+    _isWorkloadSupported() {
+        const data = this._mesh._splatsData;
+        const count = data ? (data.byteLength / _BytesPerSplat) | 0 : 0;
+        const shDegree = this._mesh._shData?.length ? this._mesh._shDegree : 0;
+        const { width, height } = this._getOutputSize();
+        if (this._renderer.supportsWorkload(count, shDegree, width, height)) {
+            return true;
+        }
+        if (!this._workloadWarned) {
+            this._workloadWarned = true;
+            Logger.Warn(`GaussianSplattingMesh: point splatting needs storage buffers larger than this device allows (${count} splats at ${width}x${height}); falling back to the classic renderer.`);
+        }
+        return false;
+    }
+    /** Re-decodes the splat data if it changed since the last decode. */
+    _syncData() {
+        // A partially filled atlas would decode unfinished entries as opaque splats at the origin.
+        if (this._mesh._splatDataPending) {
+            return;
+        }
+        const data = this._mesh._splatsData;
+        const vc = data ? (data.byteLength / _BytesPerSplat) | 0 : 0;
+        const pc = this._mesh.isCompound ? this._mesh.partCount : 1;
+        const revision = this._mesh._splatDataRevision;
+        const shDegree = this._mesh._shDegree;
+        if (data === this._decodedSplatsData &&
+            vc === this._splatCount &&
+            pc === this._decodedPartCount &&
+            revision === this._decodedRevision &&
+            shDegree === this._decodedShDegree) {
+            return;
+        }
+        this._decodedSplatsData = data;
+        this._decodedPartCount = pc;
+        this._decodedRevision = revision;
+        this._decodedShDegree = shDegree;
+        if (!data || vc === 0) {
+            this._splatCount = 0;
+            return;
+        }
+        this._decode(data);
+    }
+    /**
+     * Decodes raw `.splat` bytes into local-space per-Gaussian buffers. Mirrors the classic `_makeSplat`,
+     * including the `* 2` on the scale, which `gpsPreprocess` cancels on the projected covariance.
+     * @param splatsData raw `.splat` bytes for this mesh's splats
+     */
+    _decode(splatsData) {
+        const bytes = new Uint8Array(splatsData);
+        const floats = new Float32Array(splatsData);
+        const count = (bytes.length / _BytesPerSplat) | 0;
+        const inputs = this._mesh._getPointDecodeInputs();
+        const positions = inputs.positions;
+        const flipY = inputs.flipY ? -1 : 1;
+        const partIndices = this._mesh.isCompound ? inputs.partIndices : null;
+        let partCount = this._mesh.isCompound ? this._mesh.partCount : 1;
+        if (partIndices) {
+            for (let i = 0; i < count; i++) {
+                if (partIndices[i] + 1 > partCount) {
+                    partCount = partIndices[i] + 1;
+                }
+            }
+        }
+        const means = new Float32Array(count * 4);
+        const cov3d = new Uint32Array(count * 4);
+        const colorOpacity = new Uint32Array(count);
+        const sh = this._packSh(this._mesh._shData ?? undefined, this._mesh._shDegree, count);
+        const quaternion = new Quaternion();
+        const rotation = new Matrix();
+        const scale = new Matrix();
+        const rs = new Matrix();
+        const pMin = new Float32Array(partCount * 3).fill(Infinity);
+        const pMax = new Float32Array(partCount * 3).fill(-Infinity);
+        const activeRanges = inputs.activeRanges;
+        const activeMask = activeRanges ? new Uint8Array(count) : null;
+        if (activeRanges && activeMask) {
+            for (let r = 0; r < activeRanges.length; r += 2) {
+                activeMask.fill(1, activeRanges[r], Math.min(count, activeRanges[r] + activeRanges[r + 1]));
+            }
+        }
+        for (let i = 0; i < count; i++) {
+            const active = !activeMask || activeMask[i] !== 0;
+            // Appended parts may use a different Y convention from the mesh's original updateData.
+            const mx = positions ? positions[4 * i] : floats[8 * i];
+            const my = positions ? positions[4 * i + 1] : floats[8 * i + 1] * flipY;
+            const mz = positions ? positions[4 * i + 2] : floats[8 * i + 2];
+            const qb = _BytesPerSplat * i + 28;
+            quaternion.set((bytes[qb + 1] - 127.5) / 127.5, (bytes[qb + 2] - 127.5) / 127.5, (bytes[qb + 3] - 127.5) / 127.5, -(bytes[qb + 0] - 127.5) / 127.5);
+            quaternion.normalize();
+            quaternion.toRotationMatrix(rotation);
+            Matrix.ScalingToRef(floats[8 * i + 3] * 2, floats[8 * i + 4] * 2, floats[8 * i + 5] * 2, scale);
+            rotation.multiplyToRef(scale, rs);
+            const m = rs.m;
+            const part = partIndices ? partIndices[i] : 0;
+            means[4 * i + 0] = mx;
+            means[4 * i + 1] = my;
+            means[4 * i + 2] = mz;
+            means[4 * i + 3] = part;
+            const b = part * 3;
+            if (active && mx < pMin[b]) {
+                pMin[b] = mx;
+            }
+            if (active && my < pMin[b + 1]) {
+                pMin[b + 1] = my;
+            }
+            if (active && mz < pMin[b + 2]) {
+                pMin[b + 2] = mz;
+            }
+            if (active && mx > pMax[b]) {
+                pMax[b] = mx;
+            }
+            if (active && my > pMax[b + 1]) {
+                pMax[b + 1] = my;
+            }
+            if (active && mz > pMax[b + 2]) {
+                pMax[b + 2] = mz;
+            }
+            // Sigma = (R*S)(R*S)^T, stored as f16 divided by max|component| to keep precision at any scale.
+            const s00 = m[0] * m[0] + m[1] * m[1] + m[2] * m[2];
+            const s01 = m[0] * m[4] + m[1] * m[5] + m[2] * m[6];
+            const s02 = m[0] * m[8] + m[1] * m[9] + m[2] * m[10];
+            const s11 = m[4] * m[4] + m[5] * m[5] + m[6] * m[6];
+            const s12 = m[4] * m[8] + m[5] * m[9] + m[6] * m[10];
+            const s22 = m[8] * m[8] + m[9] * m[9] + m[10] * m[10];
+            let factor = Math.max(Math.abs(s00), Math.abs(s01), Math.abs(s02), Math.abs(s11), Math.abs(s12), Math.abs(s22));
+            if (!(factor > 0)) {
+                factor = 1;
+            }
+            const inv = 1 / factor;
+            cov3d[4 * i + 0] = _Pack2HalfFloat(s00 * inv, s01 * inv);
+            cov3d[4 * i + 1] = _Pack2HalfFloat(s02 * inv, s11 * inv);
+            cov3d[4 * i + 2] = _Pack2HalfFloat(s12 * inv, s22 * inv);
+            _F32Scratch[0] = factor;
+            cov3d[4 * i + 3] = _U32Scratch[0];
+            const cb = _BytesPerSplat * i + 24;
+            colorOpacity[i] = bytes[cb] | (bytes[cb + 1] << 8) | (bytes[cb + 2] << 16) | ((active ? bytes[cb + 3] : 0) << 24);
+        }
+        this._splatCount = count;
+        this._partCount = partCount;
+        this._partLocalMin = pMin;
+        this._partLocalMax = pMax;
+        if (this._partScratch.length !== partCount * 40) {
+            this._partScratch = new Float32Array(partCount * 40);
+        }
+        this._renderer.updateSplats(means, cov3d, colorOpacity, sh, this._mesh._shDegree, count);
+    }
+    /**
+     * Packs the loader's 8-bit SH bytes into u32 words per splat.
+     * @param shData packed per-splat SH textures, one per 16 scalar components, or undefined
+     * @param shDegree spherical-harmonics degree (0-4)
+     * @param count number of splats
+     * @returns u32-packed SH bytes, or null when SH is absent
+     */
+    _packSh(shData, shDegree, count) {
+        if (!shData || shData.length === 0 || shDegree < 1) {
+            return null;
+        }
+        const stride = _GetPackedShBytesPerSplat(shDegree);
+        const scalars = (shDegree === 1 ? 3 : shDegree === 2 ? 8 : shDegree === 3 ? 15 : 24) * 3;
+        const bytes = new Uint8Array(count * stride);
+        for (let i = 0; i < count; i++) {
+            const dst = i * stride;
+            for (let k = 0; k < scalars; k++) {
+                const tex = shData[(k / 16) | 0];
+                bytes[dst + k] = tex[i * 16 + (k % 16)];
+            }
+        }
+        return new Uint32Array(bytes.buffer);
+    }
+    /** Uploads this frame's per-part world matrix, visibility and debug-plugin rows. */
+    _uploadParts() {
+        this._renderer.debugActive = this._packParts() ? 1 : 0;
+        this._renderer.setPartData(this._partScratch, this._partCount);
+    }
+    /**
+     * Packs current part inputs without changing the renderer's accumulation or dispatch buffers.
+     * @returns whether the debug plugin is active
+     */
+    _packParts() {
+        const count = this._partCount;
+        if (this._partScratch.length !== count * 40) {
+            this._partScratch = new Float32Array(count * 40);
+        }
+        const scratch = this._partScratch;
+        const compound = this._mesh.isCompound;
+        // Runs before the scene evaluates world matrices, so transforms changed this frame must be forced.
+        const meshWorld = this._mesh.computeWorldMatrix(true);
+        if (compound) {
+            this._mesh._syncPartProxyWorldMatrices();
+        }
+        // The classic material multiplies every splat's opacity by material.alpha.
+        const alpha = this._mesh.material?.alpha ?? 1;
+        const plugin = this._mesh.material?.pluginManager?.getPlugin("GaussianSplattingDebug");
+        const pluginType = plugin?.constructor;
+        const debugActive = plugin instanceof GaussianSplattingDebugMaterialPlugin && pluginType === GaussianSplattingDebugMaterialPlugin && plugin.isDebugActive;
+        let lut = null;
+        let lutStride = 0;
+        if (plugin && debugActive) {
+            const resolved = plugin.getResolvedPartData(count, this._scene.getEngine());
+            lut = resolved.data;
+            lutStride = resolved.maxPartCount;
+        }
+        for (let i = 0; i < count; i++) {
+            const worldM = (compound ? this._mesh.getWorldMatrixForPart(i) : meshWorld).m;
+            const vis = compound ? this._mesh.getPartVisibility(i) : this._mesh.visibility;
+            const o = i * 40;
+            scratch.set(worldM, o);
+            scratch[o + 16] = vis * alpha;
+            scratch[o + 17] = 0;
+            scratch[o + 18] = 0;
+            scratch[o + 19] = 0;
+            // The LUT is row-major: row r, part i at (stride*r + i)*4.
+            if (lut) {
+                for (let r = 0; r < 5; r++) {
+                    const src = (lutStride * r + i) * 4;
+                    const dst = o + 20 + r * 4;
+                    scratch[dst] = lut[src];
+                    scratch[dst + 1] = lut[src + 1];
+                    scratch[dst + 2] = lut[src + 2];
+                    scratch[dst + 3] = lut[src + 3];
+                }
+            }
+            else {
+                scratch[o + 20] = -1e9;
+                scratch[o + 21] = -1e9;
+                scratch[o + 22] = -1e9;
+                scratch[o + 23] = 1e9;
+                scratch[o + 24] = 1e9;
+                scratch[o + 25] = 1e9;
+                scratch[o + 26] = 0;
+                scratch[o + 27] = 1;
+                scratch[o + 28] = 0;
+                scratch[o + 29] = 1e9;
+                scratch[o + 30] = 1;
+                scratch[o + 31] = 0;
+                scratch[o + 32] = 1;
+                scratch[o + 33] = 1;
+                scratch[o + 34] = 1;
+                scratch[o + 35] = 1;
+                scratch[o + 36] = 1;
+                scratch[o + 37] = 0;
+                scratch[o + 38] = 0;
+                scratch[o + 39] = 0;
+            }
+        }
+        return debugActive;
+    }
+    /**
+     * Protects point-color history from pass-specific inputs while allowing shared camera motion.
+     * @returns whether depth can share the current color inputs without a pass-specific accumulation reset
+     */
+    _depthInputsMatchColorHistory() {
+        const renderer = this._renderer;
+        if (!this._colorHistoryReady || !renderer) {
+            return true;
+        }
+        const material = this._mesh.material;
+        // Camera motion advances both passes; only custom color matrices must match the retained frame.
+        const colorTransform = this._colorUsesCameraTransform ? this._getCameraTransform() : this._vpMatrix;
+        if (this._decodedSplatsData !== this._mesh._splatsData ||
+            this._decodedRevision !== this._mesh._splatDataRevision ||
+            this._decodedShDegree !== this._mesh._shDegree ||
+            !colorTransform?.equalsWithEpsilon(this._scene.getTransformMatrix(), 1e-5) ||
+            renderer.kernelSize !== (material.kernelSize || GaussianSplattingMaterial.KernelSize) ||
+            renderer.minPixelSize !== material.minPixelSize ||
+            renderer.compensation !== material.compensation) {
+            return false;
+        }
+        const debugActive = this._packParts() ? 1 : 0;
+        return renderer.debugActive === debugActive && renderer._matchesPartData(this._partScratch, this._partCount);
+    }
+    /**
+     * Uses the scene's main camera matrix before render targets can refresh the camera's projection cache.
+     * @returns the current camera transform, or null if a different camera owns the render target
+     */
+    _getCameraTransform() {
+        if (this._cameraFrameId === this._scene.getFrameId()) {
+            return this._cameraId === this._scene.activeCamera?.uniqueId ? this._cameraVpMatrix : null;
+        }
+        return this._scene.activeCamera?.getTransformationMatrix() ?? null;
+    }
+    /**
+     * Reads the forward clipping interval of a projection whose depth is independent of x/y.
+     * @param projection the supplied projection matrix
+     * @returns the reused near/far interval (zero far means infinite), or null for unsupported intervals
+     */
+    _getProjectionClipRange(projection) {
+        const engine = this._scene.getEngine();
+        const m = projection.m;
+        const nearDepth = engine.useReverseDepthBuffer ? 1 : engine.isNDCHalfZRange ? 0 : -1;
+        const farDepth = engine.useReverseDepthBuffer ? (engine.isNDCHalfZRange ? 0 : -1) : 1;
+        const sign = this._scene.useRightHandedSystem ? -1 : 1;
+        const near = (sign * (m[14] - nearDepth * m[15])) / (nearDepth * m[11] - m[10]);
+        const farDenominator = farDepth * m[11] - m[10];
+        const far = farDenominator === 0 ? Infinity : (sign * (m[14] - farDepth * m[15])) / farDenominator;
+        if (!Number.isFinite(near) || !(far > near) || !(far > 0)) {
+            return null;
+        }
+        this._projectionClipRange[0] = near;
+        this._projectionClipRange[1] = far === Infinity ? 0 : far;
+        return this._projectionClipRange;
+    }
+    /**
+     * Computes the model's view-depth span from its part AABB corners.
+     * @param viewM column-major view matrix
+     * @param near camera near plane
+     * @param far camera far plane; 0 means infinite
+     * @param clampToCamera whether to clamp the interval to the standard camera near/far planes
+     * @returns the model's [viewZMin, viewZMax] this frame
+     */
+    _viewZSpan(viewM, near, far, clampToCamera = true) {
+        let vzMin = Infinity;
+        let vzMax = -Infinity;
+        const scratch = this._partScratch;
+        for (let p = 0; p < this._partCount; p++) {
+            const wb = p * 40;
+            const lb = p * 3;
+            const minx = this._partLocalMin[lb];
+            if (!isFinite(minx)) {
+                continue;
+            }
+            const miny = this._partLocalMin[lb + 1];
+            const minz = this._partLocalMin[lb + 2];
+            const maxx = this._partLocalMax[lb];
+            const maxy = this._partLocalMax[lb + 1];
+            const maxz = this._partLocalMax[lb + 2];
+            for (let c = 0; c < 8; c++) {
+                const lx = c & 1 ? maxx : minx;
+                const ly = c & 2 ? maxy : miny;
+                const lz = c & 4 ? maxz : minz;
+                const wx = scratch[wb + 0] * lx + scratch[wb + 4] * ly + scratch[wb + 8] * lz + scratch[wb + 12];
+                const wy = scratch[wb + 1] * lx + scratch[wb + 5] * ly + scratch[wb + 9] * lz + scratch[wb + 13];
+                const wz = scratch[wb + 2] * lx + scratch[wb + 6] * ly + scratch[wb + 10] * lz + scratch[wb + 14];
+                // View-space forward depth is positive for both handedness conventions.
+                const viewZ = viewM[2] * wx + viewM[6] * wy + viewM[10] * wz + viewM[14];
+                const vz = this._scene.useRightHandedSystem ? -viewZ : viewZ;
+                if (vz < vzMin) {
+                    vzMin = vz;
+                }
+                if (vz > vzMax) {
+                    vzMax = vz;
+                }
+            }
+        }
+        const minClip = clampToCamera ? near : -Infinity;
+        const maxClip = clampToCamera && far > 0 ? far : Infinity;
+        vzMin = Math.max(minClip, vzMin);
+        vzMax = Math.min(maxClip, vzMax);
+        if (!isFinite(vzMin) || vzMax < vzMin) {
+            // Nothing visible; any finite span works.
+            this._depthSpan[0] = near;
+            this._depthSpan[1] = far > near ? far : near + 1;
+        }
+        else if (vzMax === vzMin) {
+            // Flat or single-splat model: widen a band around the actual depth. Collapsing to [near, ...]
+            // instead would place the surface at the near plane and break the depth test and depth map.
+            const epsilon = Math.max(Math.abs(vzMin) * 1e-3, 1e-4);
+            this._depthSpan[0] = Math.max(minClip, vzMin - epsilon);
+            this._depthSpan[1] = vzMax + epsilon;
+        }
+        else {
+            this._depthSpan[0] = vzMin;
+            this._depthSpan[1] = vzMax;
+        }
+        return this._depthSpan;
+    }
+    /**
+     * Returns a stride coprime to `total` near the golden ratio, so `i*stride % total` is a decorrelated permutation.
+     * @param total the cycle length (number of sub-cells, N*N)
+     * @returns a stride coprime to total
+     */
+    _coprimeStride(total) {
+        if (total <= 2) {
+            return 1;
+        }
+        let s = Math.max(1, Math.round(total * 0.6180339887));
+        let a = s;
+        let b = total;
+        while (b !== 0) {
+            const remainder = a % b;
+            a = b;
+            b = remainder;
+        }
+        while (a !== 1) {
+            s++;
+            a = s;
+            b = total;
+            while (b !== 0) {
+                const remainder = a % b;
+                a = b;
+                b = remainder;
+            }
+        }
+        return s;
+    }
+    /** Per-frame point target for the `"auto"` render scale: desktop 15M, iOS 9M, other mobile 6M.
+     * @returns the target emitted-point count per frame */
+    _budget() {
+        const isMobile = !!this._scene.getEngine().hostInformation?.isMobile;
+        if (!isMobile) {
+            return 15000000;
+        }
+        if (typeof navigator !== "undefined" && navigator.userAgent && /iPad|iPhone|iPod/.test(navigator.userAgent)) {
+            return 9000000;
+        }
+        return 6000000;
+    }
+    /**
+     * Reads back the point count and derives the auto render factor N from the device budget.
+     * @param currentN the render factor N used for the frame being measured
+     * @param generation the accumulation generation the measured frame belongs to
+     * @param freeze whether the measured frame had occlusion culling active, so N may be fixed for `generation`
+     */
+    _updateAutoScale(currentN, generation, freeze) {
+        if (this._budgetReadPending || !this._renderer) {
+            return;
+        }
+        this._budgetReadPending = true;
+        void this._convergeAutoScaleAsync(currentN, generation, freeze, this._autoRequestId);
+    }
+    async _convergeAutoScaleAsync(currentN, generation, freeze, requestId) {
+        const renderer = this._renderer;
+        if (!renderer) {
+            return;
+        }
+        try {
+            const total = await renderer.readPointCountAsync();
+            if (renderer !== this._renderer || !this._computeActive || requestId !== this._autoRequestId || this._renderScale !== "auto") {
+                return;
+            }
+            if (total > 0) {
+                // Points scale as N^-2.
+                const fullPoints = total * currentN * currentN;
+                const target = Math.max(1, Math.min(8, Math.ceil(Math.sqrt(fullPoints / this._budget()))));
+                // Evaluated before the reset below, which would make every sample look stale.
+                const stale = !freeze || renderer.accumulationVersion !== generation;
+                const factorChanged = target !== this._autoN;
+                this._autoN = target;
+                if (factorChanged) {
+                    // N must not change within a generation.
+                    renderer.resetAccumulation();
+                }
+                if (stale) {
+                    return;
+                }
+                // Re-measuring would reproduce this estimate, so at most one corrective reset happens.
+                this._autoMeasuredGeneration = renderer.accumulationVersion;
+            }
+        }
+        catch (error) {
+            if (renderer === this._renderer && this._computeActive) {
+                Logger.Error(`GaussianSplattingMesh: point-splatting budget readback failed: ${String(error)}`);
+            }
+        }
+        finally {
+            if (renderer === this._renderer) {
+                this._budgetReadPending = false;
+            }
+        }
+    }
+    /** Returns the current depth map's size, or the camera's color target size for other passes.
+     * The returned object is reused between calls.
+     * @param colorTarget whether to return color dimensions regardless of the current pass
+     * @returns The current target dimensions in pixels.
+     */
+    _getOutputSize(colorTarget = false) {
+        const engine = this._scene.getEngine();
+        const camera = this._scene.activeCamera;
+        const postProcess = this._scene.postProcessesEnabled ? camera?._getFirstPostProcess() : null;
+        const outputRenderTarget = camera?.outputRenderTarget;
+        let width;
+        let height;
+        const depthMap = this._depthMode && !colorTarget ? this._getCurrentDepthRenderer()?.getDepthMap() : null;
+        if (depthMap) {
+            width = depthMap.getRenderWidth();
+            height = depthMap.getRenderHeight();
+        }
+        else if (postProcess && postProcess.width > 0 && postProcess.height > 0) {
+            width = postProcess.width;
+            height = postProcess.height;
+        }
+        else if (outputRenderTarget) {
+            width = outputRenderTarget.getRenderWidth();
+            height = outputRenderTarget.getRenderHeight();
+        }
+        else {
+            width = engine.getRenderWidth(true);
+            height = engine.getRenderHeight(true);
+        }
+        this._outputSize.width = Math.max(1, width);
+        this._outputSize.height = Math.max(1, height);
+        return this._outputSize;
+    }
+    /** Refreshes inputs baked into the point result, including changes made by per-pass mesh callbacks. */
+    _syncRenderInputs() {
+        this._syncData();
+        if (this._splatCount === 0) {
+            return;
+        }
+        const material = this._mesh.material;
+        const kernelSize = material?.kernelSize || GaussianSplattingMaterial.KernelSize;
+        const minPixelSize = material ? material.minPixelSize : GaussianSplattingMaterial.MinPixelSize;
+        const compensation = material?.compensation ?? GaussianSplattingMaterial.Compensation;
+        const renderer = this._renderer;
+        if (renderer.kernelSize !== kernelSize || renderer.minPixelSize !== minPixelSize || renderer.compensation !== compensation) {
+            renderer.kernelSize = kernelSize;
+            renderer.minPixelSize = minPixelSize;
+            renderer.compensation = compensation;
+            renderer.resetAccumulation();
+        }
+        this._uploadParts();
+    }
+    /** Runs compute immediately before a point compositor and binds the result to both blit materials. */
+    _runCompute() {
+        this._resultReady = false;
+        this._progressReady = false;
+        if ((this._colorMode || this._depthMode) && this._mesh._pointStreamingUnsupported && !this._streamingWarned) {
+            this._streamingWarned = true;
+            Logger.Warn("GaussianSplattingMesh: point splatting does not support streamed parts (their splats are GPU-decoded and never reach the retained CPU splat data); falling back to the classic renderer.");
+        }
+        if ((this._colorMode || this._depthMode) && this._hasUnsupportedSource && !this._sourceWarned) {
+            this._sourceWarned = true;
+            Logger.Warn("GaussianSplattingMesh: point splatting requires retained CPU splat data; GPU-only SOG textures and streams use the classic renderer.");
+        }
+        if (!this._computeActive || !this._mesh.isEnabled() || !this._renderer || !_DependenciesReady || this._hasUnsupportedView()) {
+            return;
+        }
+        if (!this._isWorkloadSupported()) {
+            return;
+        }
+        this._syncRenderInputs();
+        if (this._splatCount === 0) {
+            return;
+        }
+        const camera = this._scene.activeCamera;
+        const engine = this._scene.getEngine();
+        // Render at 1/N resolution and reconstruct full resolution over N^2 jittered frames.
+        const { width: fullW, height: fullH } = this._getOutputSize();
+        const scaleOpt = this._renderScale;
+        const upsampleN = scaleOpt === "auto" ? this._autoN : Math.max(1, Math.min(8, Math.round(1 / Math.max(scaleOpt, 1e-3))));
+        const width = Math.max(1, Math.ceil(fullW / upsampleN));
+        const height = Math.max(1, Math.ceil(fullH / upsampleN));
+        // Driven by the renderer's frame count, which also seeds sampling, so skipped frames cannot desync them.
+        const total = upsampleN * upsampleN;
+        const j = ((this._renderer.renderedFrameCount % total) * this._coprimeStride(total)) % total;
+        const jitterX = j % upsampleN;
+        const jitterY = Math.floor(j / upsampleN);
+        const view = this._scene.getViewMatrix();
+        const projection = this._scene.getProjectionMatrix();
+        const determinant = projection.determinant();
+        if (!Number.isFinite(determinant) || determinant === 0) {
+            if (!this._invalidProjectionWarned) {
+                this._invalidProjectionWarned = true;
+                Logger.Error("GaussianSplattingMesh: the camera projection matrix is not finite and invertible; point splatting skips the mesh.");
+            }
+            return;
+        }
+        this._invalidProjectionWarned = false;
+        projection.invertToRef(this._inverseProjection);
+        this._vpMatrix.copyFrom(this._scene.getTransformMatrix());
+        const focalX = (fullW * projection.m[0]) / (2 * upsampleN);
+        const focalY = (fullH * projection.m[5]) / (2 * upsampleN);
+        const camPos = camera.globalPosition;
+        this._renderer.rightHandedSystem = this._scene.useRightHandedSystem;
+        this._renderer.isOrthographic = Math.abs(projection.m[15] - 1) < 0.001;
+        const gsMaterial = this._mesh.material;
+        const projectedDepth = _HasGaussianPointSplattingProjectedDepth(projection);
+        const clipRange = projectedDepth ? null : this._getProjectionClipRange(projection);
+        const nearZ = clipRange?.[0] ?? camera.minZ;
+        const farZ = clipRange?.[1] ?? (camera.ignoreCameraMaxZ ? 0 : camera.maxZ);
+        const [vzMin, vzMax] = this._viewZSpan(view.m, nearZ, farZ, !projectedDepth);
+        this._renderer.setCamera(view, this._vpMatrix, nearZ, farZ, focalX, focalY, camPos.x, camPos.y, camPos.z, vzMin, vzMax);
+        this._renderer.setProjectionMatrix(projection, this._inverseProjection, engine.useReverseDepthBuffer);
+        if (!this._renderer.renderToBuffer(width, height, fullW, fullH, upsampleN, jitterX, jitterY)) {
+            return;
+        }
+        this._resultReady = true;
+        this._progressReady = true;
+        this._computedWidth = fullW;
+        this._computedHeight = fullH;
+        // Snapshot now: a later reset would pair a new generation with the old cycle length.
+        this._progressFrameCount = this._renderer.renderedFrameCount;
+        this._progressGeneration = this._renderer.accumulationVersion;
+        this._progressCycleLength = this._renderer.pixelCycleLength;
+        const generation = this._renderer.accumulationVersion;
+        const wasMoving = generation !== this._lastRenderedGeneration;
+        this._lastRenderedGeneration = generation;
+        if (scaleOpt === "auto" && this._autoMeasuredGeneration !== generation) {
+            this._updateAutoScale(upsampleN, generation, !wasMoving);
+        }
+        const accum = this._renderer.accumBuffer;
+        const accumDepth = this._renderer.accumDepthBuffer;
+        if (accum && accumDepth) {
+            if (this._colorMode && this._blit) {
+                this._blit.setAccumBuffer(accum);
+                this._blit.setAccumDepthBuffer(accumDepth);
+                this._blit.setResolution(this._renderer.outputWidth, this._renderer.outputHeight);
+                this._blit.setInverseProjection(this._inverseProjection);
+                // Match the classic material's log depth so the composite depth-tests like the classic path.
+                this._blit.setLogarithmicDepthConstant(gsMaterial?.useLogarithmicDepth ? 2.0 / (Math.log(camera.maxZ + 1.0) / Math.LN2) : 0);
+            }
+            if (this._depthMode && this._depthBlit) {
+                this._depthBlit.setAccumBuffer(accum);
+                this._depthBlit.setAccumDepthBuffer(accumDepth);
+                this._depthBlit.setResolution(this._renderer.outputWidth, this._renderer.outputHeight);
+                this._depthBlit.setInverseProjection(this._inverseProjection);
+                // Same normalization as GaussianSplattingMaterial._BindEffectUniforms.
+                let minZ, maxZ;
+                if (camera.mode === 1) {
+                    minZ = !engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : 1;
+                    maxZ = engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : 1;
+                }
+                else {
+                    minZ = engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? camera.minZ : engine.isNDCHalfZRange ? 0 : camera.minZ;
+                    maxZ = engine.useReverseDepthBuffer && engine.isNDCHalfZRange ? 0 : camera.maxZ;
+                }
+                this._depthBlit.setDepthValues(minZ, minZ + maxZ);
+                this._depthBlit.setReverseDepth(engine.useReverseDepthBuffer);
+            }
+        }
+    }
+    /**
+     * True when the frame renders a view the point path cannot reproduce: several active cameras, rig
+     * cameras (stereo, XR, multiview), floating origin, unsupported projection clipping intervals, or scene/material clip planes.
+     * The classic path renders those instead.
+     * @returns whether point splatting must fall back to the classic path this frame
+     */
+    _hasUnsupportedView() {
+        const scene = this._scene;
+        const camera = scene.activeCamera;
+        if (!camera || scene.floatingOriginMode) {
+            return true;
+        }
+        const projection = camera.getProjectionMatrix();
+        if (!_HasGaussianPointSplattingProjectedDepth(projection) && !this._getProjectionClipRange(projection)) {
+            return true;
+        }
+        const material = this._mesh.material;
+        return ((scene.activeCameras?.length ?? 0) > 1 ||
+            camera._rigCameras.length > 0 ||
+            !!(material?.clipPlane || material?.clipPlane2 || material?.clipPlane3 || material?.clipPlane4 || material?.clipPlane5 || material?.clipPlane6) ||
+            !!(scene.clipPlane || scene.clipPlane2 || scene.clipPlane3 || scene.clipPlane4 || scene.clipPlane5 || scene.clipPlane6));
+    }
+    /**
+     * True only for the camera's main forward color pass.
+     * @returns whether the current render pass is the camera's main forward color pass
+     */
+    _isMainColorPass() {
+        const engine = this._scene.getEngine();
+        const cam = this._scene.activeCamera;
+        const mainId = cam?.outputRenderTarget?.renderPassId ?? cam?.renderPassId ?? 0;
+        return engine.currentRenderPassId === mainId && !this._mesh.getMaterialForRenderPass(engine.currentRenderPassId);
+    }
+    /**
+     * The active camera's scene depth renderer while it is rendering; other depth passes use the classic path.
+     * @returns the depth renderer owning the current render pass, or null
+     */
+    _getCurrentDepthRenderer() {
+        const depthRenderers = this._scene._depthRenderer;
+        const camera = this._scene.activeCamera;
+        if (!depthRenderers || !camera) {
+            return null;
+        }
+        const renderer = depthRenderers[camera.uniqueId];
+        if (!renderer || !renderer.enabled) {
+            return null;
+        }
+        return renderer.getDepthMap().renderPassIds.indexOf(this._scene.getEngine().currentRenderPassId) !== -1 ? renderer : null;
+    }
+    /**
+     * True only while rendering the active camera's scene depth renderer.
+     * @returns whether the current render pass is the active camera's depth renderer pass
+     */
+    _isDepthPass() {
+        return !!this._getCurrentDepthRenderer();
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.dispose} */
+    dispose() {
+        if (this._computeObserver) {
+            this._scene.onBeforeRenderObservable.remove(this._computeObserver);
+            this._computeObserver = null;
+        }
+        if (this._cameraObserver) {
+            this._scene.onBeforeCameraRenderObservable.remove(this._cameraObserver);
+            this._cameraObserver = null;
+        }
+        if (this._restoreObserver) {
+            this._scene.getEngine().onContextRestoredObservable.remove(this._restoreObserver);
+            this._restoreObserver = null;
+        }
+        this._releaseComputeResources();
+        this._releaseBlitResources();
+        this._colorMode = false;
+        this._depthMode = false;
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.renderScale} */
+    get renderScale() {
+        return this._renderScale;
+    }
+    set renderScale(value) {
+        if (value === this._renderScale) {
+            return;
+        }
+        this._renderScale = value;
+        this._autoRequestId++;
+        this._autoMeasuredGeneration = -1;
+        this._renderer?.resetAccumulation();
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.invalidateDecodedSplats} */
+    invalidateDecodedSplats() {
+        this._decodedSplatsData = null;
+        this._renderer?.resetAccumulation();
+    }
+    /**
+     * Checks only plugin implementations whose enabled behavior is reproduced, or whose disabled behavior is neutral.
+     * @returns whether the source material's plugins are compatible with point color
+     */
+    _supportsSourceMaterialPlugins() {
+        const plugins = this._mesh.material?.pluginManager?._plugins;
+        if (!plugins) {
+            return true;
+        }
+        for (const plugin of plugins) {
+            const pluginType = plugin.constructor;
+            if ((pluginType === GaussianSplattingDebugMaterialPlugin && plugin instanceof GaussianSplattingDebugMaterialPlugin) ||
+                (pluginType === GaussianSplattingSolidColorMaterialPlugin && plugin instanceof GaussianSplattingSolidColorMaterialPlugin && !plugin.isEnabled) ||
+                (pluginType === GaussianSplattingSizeMaterialPlugin && plugin instanceof GaussianSplattingSizeMaterialPlugin && !plugin.isEnabled) ||
+                (pluginType === GaussianSplattingOverdrawMaterialPlugin && plugin instanceof GaussianSplattingOverdrawMaterialPlugin && !plugin.isEnabled)) {
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    /** {@inheritDoc IGaussianPointSplattingController.handlesCurrentPass} */
+    get handlesCurrentPass() {
+        const passMaterial = this._mesh.getMaterialForRenderPass(this._scene.getEngine().currentRenderPassId);
+        const depthRenderer = this._depthMode ? this._getCurrentDepthRenderer() : null;
+        const viewport = this._scene.activeCamera?.viewport;
+        const fullViewport = !!viewport && viewport.x === 0 && viewport.y === 0 && viewport.width === 1 && viewport.height === 1;
+        let depthPass = !!depthRenderer && (fullViewport || depthRenderer.getDepthMap().ignoreCameraViewport) && !this._scene.forceWireframe && !this._scene.forcePointsCloud;
+        // The depth renderer always installs its own classic GS depth material for its pass; only a
+        // user override set through setMaterialForRendering keeps the classic path.
+        if (passMaterial && !depthRenderer?._isGaussianSplattingDepthMaterial(passMaterial)) {
+            return false;
+        }
+        const fog = this._scene.fogEnabled && this._scene.fogMode !== Scene.FOGMODE_NONE && this._mesh.applyFog && !!this._mesh.material?.fogEnabled;
+        const colorSupported = this._colorMode &&
+            fullViewport &&
+            this._mesh.material?.alphaMode === 2 &&
+            this._mesh.material.needAlphaBlendingForMesh(this._mesh) &&
+            !this._mesh.material.needAlphaTestingForMesh(this._mesh) &&
+            this._mesh._getRenderingFillMode(this._mesh.material.fillMode) === Material.TriangleFillMode &&
+            // Custom source shaders, including subclass overrides and NodeMaterial graphs, are not evaluated by compute.
+            this._mesh.material.constructor === GaussianSplattingMaterial &&
+            this._supportsSourceMaterialPlugins() &&
+            !fog;
+        if (depthPass && depthRenderer && colorSupported) {
+            const depthMap = depthRenderer.getDepthMap();
+            const colorSize = this._getOutputSize(true);
+            // One renderer cannot retain accumulation while alternating incompatible pixel grids.
+            depthPass = depthMap.getRenderWidth() === colorSize.width && depthMap.getRenderHeight() === colorSize.height && this._depthInputsMatchColorHistory();
+        }
+        const colorPass = colorSupported && this._isMainColorPass();
+        return (colorPass || depthPass) && this._computeActive && !this._hasUnsupportedView() && (!this._renderer || this._isWorkloadSupported());
+    }
+    /**
+     * Composites supported camera color or depth passes from the point-splatting result.
+     * The pass waits without drawing classic splats while compute or compositor shaders are compiling.
+     * @param enableAlphaMode whether the color compositor should enable alpha blending
+     * @returns whether the point path handled the current pass, including waiting for shader readiness
+     */
+    drawColorPass(enableAlphaMode) {
+        if (!this.handlesCurrentPass) {
+            if (!this._computeActive) {
+                this._runCompute();
+            }
+            return false;
+        }
+        const colorPass = this._colorMode && this._isMainColorPass();
+        const depthPass = this._depthMode && this._isDepthPass();
+        const { width, height } = this._getOutputSize();
+        if (this._resultReady && this._renderer) {
+            this._syncRenderInputs();
+            if (this._renderer.accumulationVersion !== this._progressGeneration) {
+                this._resultReady = false;
+            }
+        }
+        // Compute only after the pass has established its actual matrices. Matching color/depth passes share it.
+        if (!this._resultReady || !this._vpMatrix.equalsWithEpsilon(this._scene.getTransformMatrix(), 1e-5) || this._computedWidth !== width || this._computedHeight !== height) {
+            this._runCompute();
+        }
+        if (!this._resultReady) {
+            return true;
+        }
+        if (colorPass) {
+            this._colorHistoryReady = true;
+            this._colorUsesCameraTransform = this._getCameraTransform()?.equalsWithEpsilon(this._vpMatrix, 1e-5) ?? false;
+        }
+        if (colorPass && this._blitMesh && this._blitMesh.subMeshes.length > 0 && this._blit?.isReady(this._blitMesh, false, this._blitMesh.subMeshes[0])) {
+            const blitMesh = this._blitMesh;
+            const material = this._mesh.material;
+            if (material) {
+                this._blit.disableColorWrite = material.disableColorWrite;
+                this._blit.disableDepthWrite = material.disableDepthWrite;
+                this._blit.forceDepthWrite = material.forceDepthWrite;
+                this._blit.depthFunction = material.depthFunction;
+                this._blit.zOffset = material.zOffset;
+                this._blit.zOffsetUnits = material.zOffsetUnits;
+                // Copy directly to avoid SerializationHelper allocations in each color draw.
+                const source = material.stencil;
+                const stencil = this._blit.stencil;
+                stencil.enabled = source.enabled;
+                stencil.mask = source.mask;
+                stencil.func = source.func;
+                stencil.funcRef = source.funcRef;
+                stencil.funcMask = source.funcMask;
+                stencil.opStencilFail = source.opStencilFail;
+                stencil.opDepthFail = source.opDepthFail;
+                stencil.opStencilDepthPass = source.opStencilDepthPass;
+                stencil.backFunc = source.backFunc;
+                stencil.backOpStencilFail = source.backOpStencilFail;
+                stencil.backOpDepthFail = source.backOpDepthFail;
+                stencil.backOpStencilDepthPass = source.backOpStencilDepthPass;
+            }
+            // Render in replacement mode so the disabled compositor still draws itself.
+            blitMesh.render(blitMesh.subMeshes[0], enableAlphaMode, blitMesh);
+            return true;
+        }
+        if (depthPass && this._depthBlitMesh) {
+            const depthBlitMesh = this._depthBlitMesh;
+            if (depthBlitMesh.subMeshes.length > 0 && this._depthBlit?.isReady(depthBlitMesh, false, depthBlitMesh.subMeshes[0])) {
+                // The depth renderer may have left alpha blending on.
+                this._scene.getEngine().setAlphaMode(0);
+                depthBlitMesh.render(depthBlitMesh.subMeshes[0], false, depthBlitMesh);
+                return true;
+            }
+        }
+        return true;
+    }
+}
+let _Registered = false;
+/**
+ * Enables the point-splatting properties of {@link GaussianSplattingMesh}. Idempotent.
+ */
+export function RegisterGaussianPointSplattingController() {
+    if (_Registered) {
+        return;
+    }
+    _Registered = true;
+    _SetGaussianPointSplattingControllerFactory((mesh) => new GaussianPointSplattingController(mesh));
+}
+//# sourceMappingURL=gaussianPointSplattingController.pure.js.map