@onerjs/core 8.56.4 → 9.0.1

package/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplattingDepthBlitMaterial.js","sourceRoot":"","sources":["../../../../../dev/core/src/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,gDAAgD,CAAC;AAE/D,OAAO,qDAAqD,CAAC;AAC7D,OAAO,4DAA4D,CAAC","sourcesContent":["/**\n * Re-exports the pure implementation and imports required shaders for their runtime registration.\n * Import gaussianPointSplattingDepthBlitMaterial.pure for tree-shakeable, side-effect-free usage.\n */\nexport * from \"./gaussianPointSplattingDepthBlitMaterial.pure\";\n\nimport \"../../ShadersWGSL/gaussianPointSplattingBlit.vertex\";\nimport \"../../ShadersWGSL/gaussianPointSplattingDepthBlit.fragment\";\n"]}

package/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.pure.d.ts

@@ -0,0 +1,60 @@
+/** This file must only contain pure code and pure imports */
+import { type Scene } from "../../scene.pure.js";
+import { ShaderMaterial } from "../shaderMaterial.pure.js";
+import { type StorageBuffer } from "../../Buffers/storageBuffer.js";
+import { type Matrix } from "../../Maths/math.vector.pure.js";
+/**
+ * Writes resolved Gaussian Point Splatting depth into a DepthRenderer map with a fullscreen triangle.
+ * The depth is opaque nearest-surface depth, not the coverage-weighted `alphaBlendedDepth`. WebGPU only.
+ */
+export declare class GaussianPointSplattingDepthBlitMaterial extends ShaderMaterial {
+    private readonly _resolution;
+    private readonly _projZ;
+    private readonly _depthValues;
+    /**
+     * Creates a new depth blit material.
+     * @param name material name
+     * @param scene hosting scene
+     */
+    constructor(name: string, scene: Scene);
+    /**
+     * Binds the resolved accumulation buffer; only its coverage channel is read, to reject empty pixels.
+     * @param buffer the renderer's accumulation buffer
+     */
+    setAccumBuffer(buffer: StorageBuffer): void;
+    /**
+     * Binds the resolved per-pixel surface depth buffer (NDC z).
+     * @param buffer the renderer's accumulation depth buffer
+     */
+    setAccumDepthBuffer(buffer: StorageBuffer): void;
+    /**
+     * Sets the render resolution used to index the accumulation buffers.
+     * @param width render width in pixels
+     * @param height render height in pixels
+     */
+    setResolution(width: number, height: number): void;
+    /**
+     * Sets the active camera's projection matrix z-row, used to recover clip-space z from the stored NDC z.
+     * @param m10 projection matrix element [10]
+     * @param m11 projection matrix element [11]
+     * @param m14 projection matrix element [14]
+     * @param m15 projection matrix element [15]
+     */
+    setProjectionZ(m10: number, m11: number, m14: number, m15: number): void;
+    /**
+     * Sets the inverse full projection to recover clip-space z for the depth metric.
+     * @param inverseProjection inverse camera projection matrix
+     */
+    setInverseProjection(inverseProjection: Matrix): void;
+    /**
+     * Sets the depth renderer's (minZ, minZ + maxZ) normalization pair.
+     * @param minZ the depth metric offset
+     * @param minZPlusMaxZ the depth metric divisor
+     */
+    setDepthValues(minZ: number, minZPlusMaxZ: number): void;
+    /**
+     * Sets whether the engine uses a reverse depth buffer (negates clip-space z in the metric).
+     * @param reverse true when the engine uses a reverse depth buffer
+     */
+    setReverseDepth(reverse: boolean): void;
+}

package/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.pure.js

@@ -0,0 +1,90 @@
+/** This file must only contain pure code and pure imports */
+import { ShaderMaterial } from "../shaderMaterial.pure.js";
+
+import { Vector2, Vector4 } from "../../Maths/math.vector.pure.js";
+/**
+ * Writes resolved Gaussian Point Splatting depth into a DepthRenderer map with a fullscreen triangle.
+ * The depth is opaque nearest-surface depth, not the coverage-weighted `alphaBlendedDepth`. WebGPU only.
+ */
+export class GaussianPointSplattingDepthBlitMaterial extends ShaderMaterial {
+    /**
+     * Creates a new depth blit material.
+     * @param name material name
+     * @param scene hosting scene
+     */
+    constructor(name, scene) {
+        super(name, scene, { vertex: "gaussianPointSplattingBlit", fragment: "gaussianPointSplattingDepthBlit" }, {
+            attributes: ["position"],
+            uniforms: ["resolution", "depthValues", "projZ", "inverseProjection", "useInverseProjection", "reverseDepth"],
+            storageBuffers: ["accumBuffer", "accumDepth"],
+            shaderLanguage: 1 /* ShaderLanguage.WGSL */,
+            needAlphaBlending: false,
+        });
+        // Reused per-frame uniform values; ShaderMaterial keeps references to them.
+        this._resolution = new Vector2();
+        this._projZ = new Vector4();
+        this._depthValues = new Vector2();
+        // Depth writes stay on so the blit composes against meshes already in the map.
+        this.backFaceCulling = false;
+        this.alphaMode = 0;
+        this.forceDepthWrite = true;
+        this.setFloat("useInverseProjection", 0);
+    }
+    /**
+     * Binds the resolved accumulation buffer; only its coverage channel is read, to reject empty pixels.
+     * @param buffer the renderer's accumulation buffer
+     */
+    setAccumBuffer(buffer) {
+        this.setStorageBuffer("accumBuffer", buffer);
+    }
+    /**
+     * Binds the resolved per-pixel surface depth buffer (NDC z).
+     * @param buffer the renderer's accumulation depth buffer
+     */
+    setAccumDepthBuffer(buffer) {
+        this.setStorageBuffer("accumDepth", buffer);
+    }
+    /**
+     * Sets the render resolution used to index the accumulation buffers.
+     * @param width render width in pixels
+     * @param height render height in pixels
+     */
+    setResolution(width, height) {
+        this.setVector2("resolution", this._resolution.set(width, height));
+    }
+    /**
+     * Sets the active camera's projection matrix z-row, used to recover clip-space z from the stored NDC z.
+     * @param m10 projection matrix element [10]
+     * @param m11 projection matrix element [11]
+     * @param m14 projection matrix element [14]
+     * @param m15 projection matrix element [15]
+     */
+    setProjectionZ(m10, m11, m14, m15) {
+        this.setVector4("projZ", this._projZ.set(m10, m11, m14, m15));
+        this.setFloat("useInverseProjection", 0);
+    }
+    /**
+     * Sets the inverse full projection to recover clip-space z for the depth metric.
+     * @param inverseProjection inverse camera projection matrix
+     */
+    setInverseProjection(inverseProjection) {
+        this.setMatrix("inverseProjection", inverseProjection);
+        this.setFloat("useInverseProjection", 1);
+    }
+    /**
+     * Sets the depth renderer's (minZ, minZ + maxZ) normalization pair.
+     * @param minZ the depth metric offset
+     * @param minZPlusMaxZ the depth metric divisor
+     */
+    setDepthValues(minZ, minZPlusMaxZ) {
+        this.setVector2("depthValues", this._depthValues.set(minZ, minZPlusMaxZ));
+    }
+    /**
+     * Sets whether the engine uses a reverse depth buffer (negates clip-space z in the metric).
+     * @param reverse true when the engine uses a reverse depth buffer
+     */
+    setReverseDepth(reverse) {
+        this.setFloat("reverseDepth", reverse ? 1 : 0);
+    }
+}
+//# sourceMappingURL=gaussianPointSplattingDepthBlitMaterial.pure.js.map

package/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.pure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplattingDepthBlitMaterial.pure.js","sourceRoot":"","sources":["../../../../../dev/core/src/Materials/GaussianSplatting/gaussianPointSplattingDepthBlitMaterial.pure.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAG7D,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAe,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE5E;;;GAGG;AACH,MAAM,OAAO,uCAAwC,SAAQ,cAAc;IAMvE;;;;OAIG;IACH,YAAY,IAAY,EAAE,KAAY;QAClC,KAAK,CACD,IAAI,EACJ,KAAK,EACL,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,iCAAiC,EAAE,EACrF;YACI,UAAU,EAAE,CAAC,UAAU,CAAC;YACxB,QAAQ,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,cAAc,CAAC;YAC7G,cAAc,EAAE,CAAC,aAAa,EAAE,YAAY,CAAC;YAC7C,cAAc,6BAAqB;YACnC,iBAAiB,EAAE,KAAK;SAC3B,CACJ,CAAC;QAtBN,4EAA4E;QAC3D,gBAAW,GAAG,IAAI,OAAO,EAAE,CAAC;QAC5B,WAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QACvB,iBAAY,GAAG,IAAI,OAAO,EAAE,CAAC;QAqB1C,+EAA+E;QAC/E,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,aAAa,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACI,cAAc,CAAC,MAAqB;QACvC,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;IAED;;;OAGG;IACI,mBAAmB,CAAC,MAAqB;QAC5C,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,KAAa,EAAE,MAAc;QAC9C,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;OAMG;IACI,cAAc,CAAC,GAAW,EAAE,GAAW,EAAE,GAAW,EAAE,GAAW;QACpE,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACI,oBAAoB,CAAC,iBAAyB;QACjD,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;QACvD,IAAI,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,IAAY,EAAE,YAAoB;QACpD,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACI,eAAe,CAAC,OAAgB;QACnC,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;CACJ","sourcesContent":["/** This file must only contain pure code and pure imports */\n\nimport { type Scene } from \"core/scene.pure\";\nimport { ShaderMaterial } from \"core/Materials/shaderMaterial.pure\";\nimport { ShaderLanguage } from \"core/Materials/shaderLanguage\";\nimport { Constants } from \"core/Engines/constants\";\nimport { type StorageBuffer } from \"core/Buffers/storageBuffer\";\nimport { type Matrix, Vector2, Vector4 } from \"core/Maths/math.vector.pure\";\n\n/**\n * Writes resolved Gaussian Point Splatting depth into a DepthRenderer map with a fullscreen triangle.\n * The depth is opaque nearest-surface depth, not the coverage-weighted `alphaBlendedDepth`. WebGPU only.\n */\nexport class GaussianPointSplattingDepthBlitMaterial extends ShaderMaterial {\n    // Reused per-frame uniform values; ShaderMaterial keeps references to them.\n    private readonly _resolution = new Vector2();\n    private readonly _projZ = new Vector4();\n    private readonly _depthValues = new Vector2();\n\n    /**\n     * Creates a new depth blit material.\n     * @param name material name\n     * @param scene hosting scene\n     */\n    constructor(name: string, scene: Scene) {\n        super(\n            name,\n            scene,\n            { vertex: \"gaussianPointSplattingBlit\", fragment: \"gaussianPointSplattingDepthBlit\" },\n            {\n                attributes: [\"position\"],\n                uniforms: [\"resolution\", \"depthValues\", \"projZ\", \"inverseProjection\", \"useInverseProjection\", \"reverseDepth\"],\n                storageBuffers: [\"accumBuffer\", \"accumDepth\"],\n                shaderLanguage: ShaderLanguage.WGSL,\n                needAlphaBlending: false,\n            }\n        );\n\n        // Depth writes stay on so the blit composes against meshes already in the map.\n        this.backFaceCulling = false;\n        this.alphaMode = Constants.ALPHA_DISABLE;\n        this.forceDepthWrite = true;\n        this.setFloat(\"useInverseProjection\", 0);\n    }\n\n    /**\n     * Binds the resolved accumulation buffer; only its coverage channel is read, to reject empty pixels.\n     * @param buffer the renderer's accumulation buffer\n     */\n    public setAccumBuffer(buffer: StorageBuffer): void {\n        this.setStorageBuffer(\"accumBuffer\", buffer);\n    }\n\n    /**\n     * Binds the resolved per-pixel surface depth buffer (NDC z).\n     * @param buffer the renderer's accumulation depth buffer\n     */\n    public setAccumDepthBuffer(buffer: StorageBuffer): void {\n        this.setStorageBuffer(\"accumDepth\", buffer);\n    }\n\n    /**\n     * Sets the render resolution used to index the accumulation buffers.\n     * @param width render width in pixels\n     * @param height render height in pixels\n     */\n    public setResolution(width: number, height: number): void {\n        this.setVector2(\"resolution\", this._resolution.set(width, height));\n    }\n\n    /**\n     * Sets the active camera's projection matrix z-row, used to recover clip-space z from the stored NDC z.\n     * @param m10 projection matrix element [10]\n     * @param m11 projection matrix element [11]\n     * @param m14 projection matrix element [14]\n     * @param m15 projection matrix element [15]\n     */\n    public setProjectionZ(m10: number, m11: number, m14: number, m15: number): void {\n        this.setVector4(\"projZ\", this._projZ.set(m10, m11, m14, m15));\n        this.setFloat(\"useInverseProjection\", 0);\n    }\n\n    /**\n     * Sets the inverse full projection to recover clip-space z for the depth metric.\n     * @param inverseProjection inverse camera projection matrix\n     */\n    public setInverseProjection(inverseProjection: Matrix): void {\n        this.setMatrix(\"inverseProjection\", inverseProjection);\n        this.setFloat(\"useInverseProjection\", 1);\n    }\n\n    /**\n     * Sets the depth renderer's (minZ, minZ + maxZ) normalization pair.\n     * @param minZ the depth metric offset\n     * @param minZPlusMaxZ the depth metric divisor\n     */\n    public setDepthValues(minZ: number, minZPlusMaxZ: number): void {\n        this.setVector2(\"depthValues\", this._depthValues.set(minZ, minZPlusMaxZ));\n    }\n\n    /**\n     * Sets whether the engine uses a reverse depth buffer (negates clip-space z in the metric).\n     * @param reverse true when the engine uses a reverse depth buffer\n     */\n    public setReverseDepth(reverse: boolean): void {\n        this.setFloat(\"reverseDepth\", reverse ? 1 : 0);\n    }\n}\n"]}

package/Materials/GaussianSplatting/gaussianSplattingDebugMaterialPlugin.pure.d.ts

@@ -106,11 +106,42 @@ export declare class GaussianSplattingDebugMaterialPlugin extends MaterialPlugin
     private _dbgPartDataTexture;
     private _textureDirty;
     private _maxPartCount;
+    private _resolvedPartData;
+    private _mutableValuesSnapshot;
     /**
      * Creates a new GaussianSplattingDebugMaterialPlugin.
      * @param material The GaussianSplattingMaterial to attach the plugin to.
      */
     constructor(material: GaussianSplattingMaterial);
+    /**
+     * True when any global or per-part debug feature is active.
+     * @returns true when debug work is needed
+     */
+    get isDebugActive(): boolean;
+    /**
+     * Returns resolved per-part debug data in the classic `dbgPartData` layout (5 RGBA rows per part).
+     * @param partCount current mesh part count
+     * @param engine engine used to size the LUT if needed
+     * @returns the resolved LUT floats and its per-row part-count stride
+     */
+    getResolvedPartData(partCount: number, engine: AbstractEngine): {
+        data: Float32Array;
+        maxPartCount: number;
+    };
+    /**
+     * Stores the current values of every externally mutable debug setting and reports whether any changed.
+     * @param partCount current mesh part count
+     * @returns true when at least one value differs from the previous call
+     */
+    private _refreshMutableValuesSnapshot;
+    /**
+     * Writes a value into the snapshot and reports whether it replaced a different one.
+     * @param snapshot the snapshot buffer
+     * @param index the slot index to write
+     * @param value the current value
+     * @returns true when the stored value changed
+     */
+    private _diffMutableValue;
     private _isAnyFeatureActive;
     private _markDirty;
     /**

package/Materials/GaussianSplatting/gaussianSplattingDebugMaterialPlugin.pure.js

@@ -3,7 +3,7 @@ import { MaterialDefines } from "../materialDefines.js";
 import { MaterialPluginBase } from "../materialPluginBase.pure.js";
 import { RegisterClass } from "../../Misc/typeStore.js";
 import { Logger } from "../../Misc/logger.js";
-import { GetGaussianSplattingMaxPartCount } from "./gaussianSplattingMaterial.pure.js";
+import { GetGaussianSplattingMaxPartCount, GetPartIndexVaryingDeclaration } from "./gaussianSplattingMaterial.pure.js";
 import { RawTexture } from "../Textures/rawTexture.js";
 
 /** @internal */
@@ -34,6 +34,8 @@ class GaussianSplattingDebugDefines extends MaterialDefines {
         this.GS_DBG_SH_ORDER4 = 1;
     }
 }
+// Clip box min/max (6) + opacity culling min/max (2) + size culling min/max (2) per snapshot slot.
+const _MutableValuesPerSlot = 10;
 /**
  * Debug plugin for GaussianSplattingMaterial.
  * Provides runtime controls for clipping, opacity/size culling, opacity scaling,
@@ -77,6 +79,8 @@ export class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
         this._dbgPartDataTexture = null;
         this._textureDirty = false;
         this._maxPartCount = 0;
+        this._resolvedPartData = null;
+        this._mutableValuesSnapshot = null;
         this._partArrays = [
             this._partClippingBoxes,
             this._partOpacityCullings,
@@ -90,6 +94,99 @@ export class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
             this._partShOrder4s,
         ];
     }
+    /**
+     * True when any global or per-part debug feature is active.
+     * @returns true when debug work is needed
+     */
+    get isDebugActive() {
+        return this._isAnyFeatureActive();
+    }
+    /**
+     * Returns resolved per-part debug data in the classic `dbgPartData` layout (5 RGBA rows per part).
+     * @param partCount current mesh part count
+     * @param engine engine used to size the LUT if needed
+     * @returns the resolved LUT floats and its per-row part-count stride
+     */
+    getResolvedPartData(partCount, engine) {
+        if (!this._maxPartCount) {
+            this._maxPartCount = GetGaussianSplattingMaxPartCount(engine);
+        }
+        // Clip boxes and culling ranges are handed out by reference, so callers can change their values
+        // without going through a setter. Comparing the values catches that, like the classic non-compound
+        // path which reads them live at bind time.
+        const mutated = this._refreshMutableValuesSnapshot(partCount);
+        if (!this._resolvedPartData || this._resolvedPartData.partCount !== partCount || mutated) {
+            this._resolvedPartData = { partCount, data: this._buildTextureData(partCount), maxPartCount: this._maxPartCount };
+        }
+        return this._resolvedPartData;
+    }
+    /**
+     * Stores the current values of every externally mutable debug setting and reports whether any changed.
+     * @param partCount current mesh part count
+     * @returns true when at least one value differs from the previous call
+     */
+    _refreshMutableValuesSnapshot(partCount) {
+        // One slot per part plus a trailing slot for the parts that resolve to the global settings.
+        const slotCount = partCount + 1;
+        let snapshot = this._mutableValuesSnapshot;
+        let changed = false;
+        if (!snapshot || snapshot.length !== slotCount * _MutableValuesPerSlot) {
+            snapshot = new Float64Array(slotCount * _MutableValuesPerSlot);
+            this._mutableValuesSnapshot = snapshot;
+            changed = true;
+        }
+        for (let i = 0; i < slotCount; i++) {
+            const offset = i * _MutableValuesPerSlot;
+            const box = i < partCount ? (this._partClippingBoxes[i] ?? this._clippingBox) : this._clippingBox;
+            if (this._diffMutableValue(snapshot, offset, box ? box.min.x : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 1, box ? box.min.y : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 2, box ? box.min.z : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 3, box ? box.max.x : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 4, box ? box.max.y : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 5, box ? box.max.z : 0)) {
+                changed = true;
+            }
+            const opacityCulling = i < partCount ? (this._partOpacityCullings[i] ?? this._opacityCulling) : this._opacityCulling;
+            if (this._diffMutableValue(snapshot, offset + 6, opacityCulling ? opacityCulling.min : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 7, opacityCulling ? opacityCulling.max : 0)) {
+                changed = true;
+            }
+            const sizeCulling = i < partCount ? (this._partSizeCullings[i] ?? this._sizeCulling) : this._sizeCulling;
+            if (this._diffMutableValue(snapshot, offset + 8, sizeCulling ? sizeCulling.min : 0)) {
+                changed = true;
+            }
+            if (this._diffMutableValue(snapshot, offset + 9, sizeCulling ? sizeCulling.max : 0)) {
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    /**
+     * Writes a value into the snapshot and reports whether it replaced a different one.
+     * @param snapshot the snapshot buffer
+     * @param index the slot index to write
+     * @param value the current value
+     * @returns true when the stored value changed
+     */
+    _diffMutableValue(snapshot, index, value) {
+        if (snapshot[index] === value) {
+            return false;
+        }
+        snapshot[index] = value;
+        return true;
+    }
     _isAnyFeatureActive() {
         return (this._clippingBox !== null ||
             this._opacityCulling !== null ||
@@ -115,6 +212,7 @@ export class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
     _markDirty() {
         this.markAllDefinesAsDirty();
         this._textureDirty = true;
+        this._resolvedPartData = null;
     }
     // ----- Public API -----
     /**
@@ -392,7 +490,7 @@ uniform float dbgOpacityScale;
 #endif
 #if defined(GS_DBG_ENABLED) && IS_COMPOUND
 uniform sampler2D dbgPartData;
-varying float vPartIndex;
+${GetPartIndexVaryingDeclaration(0 /* ShaderLanguage.GLSL */)}
 #endif
 `,
                 CUSTOM_VERTEX_UPDATE: `
@@ -472,7 +570,7 @@ varying float vPartIndex;
                 CUSTOM_FRAGMENT_DEFINITIONS: `
 #if defined(GS_DBG_ENABLED) && IS_COMPOUND
 uniform sampler2D dbgPartData;
-varying float vPartIndex;
+${GetPartIndexVaryingDeclaration(0 /* ShaderLanguage.GLSL */)}
 #endif
 `,
                 CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `
@@ -507,7 +605,7 @@ uniform dbgOpacityScale: f32;
 #endif
 #if defined(GS_DBG_ENABLED) && IS_COMPOUND
 var dbgPartData: texture_2d<f32>;
-varying vPartIndex: f32;
+${GetPartIndexVaryingDeclaration(1 /* ShaderLanguage.WGSL */)}
 #endif
 `,
                 CUSTOM_VERTEX_UPDATE: `
@@ -587,7 +685,7 @@ varying vPartIndex: f32;
                 CUSTOM_FRAGMENT_DEFINITIONS: `
 #if defined(GS_DBG_ENABLED) && IS_COMPOUND
 var dbgPartData: texture_2d<f32>;
-varying vPartIndex: f32;
+${GetPartIndexVaryingDeclaration(1 /* ShaderLanguage.WGSL */)}
 #endif
 `,
                 CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: `