@onerjs/core 8.46.1 → 8.46.3

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -1,2155 +1,690 @@
-import { SubMesh } from "../subMesh.js";
-import { Mesh } from "../mesh.js";
-import { VertexData } from "../mesh.vertexData.js";
-import { Matrix, TmpVectors, Vector2, Vector3, Quaternion } from "../../Maths/math.vector.js";
-import { Logger } from "../../Misc/logger.js";
-import { GaussianSplattingMaterial, GetGaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
+import { Quaternion, Vector3 } from "../../Maths/math.vector.js";
+import { GetGaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.js";
+import { GaussianSplattingMeshBase } from "./gaussianSplattingMeshBase.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
 
 import "../thinInstanceMesh.js";
-import { ToHalfFloat } from "../../Misc/textureTools.js";
-import { Scalar } from "../../Maths/math.scalar.js";
-import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "../../Misc/coroutine.js";
-import { EngineStore } from "../../Engines/engineStore.js";
-import { ImportMeshAsync } from "../../Loading/sceneLoader.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.js";
-const IsNative = typeof _native !== "undefined";
-const Native = IsNative ? _native : null;
-// @internal
-const UnpackUnorm = (value, bits) => {
-    const t = (1 << bits) - 1;
-    return (value & t) / t;
-};
-// @internal
-const Unpack111011 = (value, result) => {
-    result.x = UnpackUnorm(value >>> 21, 11);
-    result.y = UnpackUnorm(value >>> 11, 10);
-    result.z = UnpackUnorm(value, 11);
-};
-// @internal
-const Unpack8888 = (value, result) => {
-    result[0] = UnpackUnorm(value >>> 24, 8) * 255;
-    result[1] = UnpackUnorm(value >>> 16, 8) * 255;
-    result[2] = UnpackUnorm(value >>> 8, 8) * 255;
-    result[3] = UnpackUnorm(value, 8) * 255;
-};
-// @internal
-// unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element)
-const UnpackRot = (value, result) => {
-    const norm = 1.0 / (Math.sqrt(2) * 0.5);
-    const a = (UnpackUnorm(value >>> 20, 10) - 0.5) * norm;
-    const b = (UnpackUnorm(value >>> 10, 10) - 0.5) * norm;
-    const c = (UnpackUnorm(value, 10) - 0.5) * norm;
-    const m = Math.sqrt(1.0 - (a * a + b * b + c * c));
-    switch (value >>> 30) {
-        case 0:
-            result.set(m, a, b, c);
-            break;
-        case 1:
-            result.set(a, m, b, c);
-            break;
-        case 2:
-            result.set(a, b, m, c);
-            break;
-        case 3:
-            result.set(a, b, c, m);
-            break;
-    }
-};
-/**
- * Representation of the types
- */
-var PLYType;
-(function (PLYType) {
-    PLYType[PLYType["FLOAT"] = 0] = "FLOAT";
-    PLYType[PLYType["INT"] = 1] = "INT";
-    PLYType[PLYType["UINT"] = 2] = "UINT";
-    PLYType[PLYType["DOUBLE"] = 3] = "DOUBLE";
-    PLYType[PLYType["UCHAR"] = 4] = "UCHAR";
-    PLYType[PLYType["UNDEFINED"] = 5] = "UNDEFINED";
-})(PLYType || (PLYType = {}));
-/**
- * Usage types of the PLY values
- */
-var PLYValue;
-(function (PLYValue) {
-    PLYValue[PLYValue["MIN_X"] = 0] = "MIN_X";
-    PLYValue[PLYValue["MIN_Y"] = 1] = "MIN_Y";
-    PLYValue[PLYValue["MIN_Z"] = 2] = "MIN_Z";
-    PLYValue[PLYValue["MAX_X"] = 3] = "MAX_X";
-    PLYValue[PLYValue["MAX_Y"] = 4] = "MAX_Y";
-    PLYValue[PLYValue["MAX_Z"] = 5] = "MAX_Z";
-    PLYValue[PLYValue["MIN_SCALE_X"] = 6] = "MIN_SCALE_X";
-    PLYValue[PLYValue["MIN_SCALE_Y"] = 7] = "MIN_SCALE_Y";
-    PLYValue[PLYValue["MIN_SCALE_Z"] = 8] = "MIN_SCALE_Z";
-    PLYValue[PLYValue["MAX_SCALE_X"] = 9] = "MAX_SCALE_X";
-    PLYValue[PLYValue["MAX_SCALE_Y"] = 10] = "MAX_SCALE_Y";
-    PLYValue[PLYValue["MAX_SCALE_Z"] = 11] = "MAX_SCALE_Z";
-    PLYValue[PLYValue["PACKED_POSITION"] = 12] = "PACKED_POSITION";
-    PLYValue[PLYValue["PACKED_ROTATION"] = 13] = "PACKED_ROTATION";
-    PLYValue[PLYValue["PACKED_SCALE"] = 14] = "PACKED_SCALE";
-    PLYValue[PLYValue["PACKED_COLOR"] = 15] = "PACKED_COLOR";
-    PLYValue[PLYValue["X"] = 16] = "X";
-    PLYValue[PLYValue["Y"] = 17] = "Y";
-    PLYValue[PLYValue["Z"] = 18] = "Z";
-    PLYValue[PLYValue["SCALE_0"] = 19] = "SCALE_0";
-    PLYValue[PLYValue["SCALE_1"] = 20] = "SCALE_1";
-    PLYValue[PLYValue["SCALE_2"] = 21] = "SCALE_2";
-    PLYValue[PLYValue["DIFFUSE_RED"] = 22] = "DIFFUSE_RED";
-    PLYValue[PLYValue["DIFFUSE_GREEN"] = 23] = "DIFFUSE_GREEN";
-    PLYValue[PLYValue["DIFFUSE_BLUE"] = 24] = "DIFFUSE_BLUE";
-    PLYValue[PLYValue["OPACITY"] = 25] = "OPACITY";
-    PLYValue[PLYValue["F_DC_0"] = 26] = "F_DC_0";
-    PLYValue[PLYValue["F_DC_1"] = 27] = "F_DC_1";
-    PLYValue[PLYValue["F_DC_2"] = 28] = "F_DC_2";
-    PLYValue[PLYValue["F_DC_3"] = 29] = "F_DC_3";
-    PLYValue[PLYValue["ROT_0"] = 30] = "ROT_0";
-    PLYValue[PLYValue["ROT_1"] = 31] = "ROT_1";
-    PLYValue[PLYValue["ROT_2"] = 32] = "ROT_2";
-    PLYValue[PLYValue["ROT_3"] = 33] = "ROT_3";
-    PLYValue[PLYValue["MIN_COLOR_R"] = 34] = "MIN_COLOR_R";
-    PLYValue[PLYValue["MIN_COLOR_G"] = 35] = "MIN_COLOR_G";
-    PLYValue[PLYValue["MIN_COLOR_B"] = 36] = "MIN_COLOR_B";
-    PLYValue[PLYValue["MAX_COLOR_R"] = 37] = "MAX_COLOR_R";
-    PLYValue[PLYValue["MAX_COLOR_G"] = 38] = "MAX_COLOR_G";
-    PLYValue[PLYValue["MAX_COLOR_B"] = 39] = "MAX_COLOR_B";
-    PLYValue[PLYValue["SH_0"] = 40] = "SH_0";
-    PLYValue[PLYValue["SH_1"] = 41] = "SH_1";
-    PLYValue[PLYValue["SH_2"] = 42] = "SH_2";
-    PLYValue[PLYValue["SH_3"] = 43] = "SH_3";
-    PLYValue[PLYValue["SH_4"] = 44] = "SH_4";
-    PLYValue[PLYValue["SH_5"] = 45] = "SH_5";
-    PLYValue[PLYValue["SH_6"] = 46] = "SH_6";
-    PLYValue[PLYValue["SH_7"] = 47] = "SH_7";
-    PLYValue[PLYValue["SH_8"] = 48] = "SH_8";
-    PLYValue[PLYValue["SH_9"] = 49] = "SH_9";
-    PLYValue[PLYValue["SH_10"] = 50] = "SH_10";
-    PLYValue[PLYValue["SH_11"] = 51] = "SH_11";
-    PLYValue[PLYValue["SH_12"] = 52] = "SH_12";
-    PLYValue[PLYValue["SH_13"] = 53] = "SH_13";
-    PLYValue[PLYValue["SH_14"] = 54] = "SH_14";
-    PLYValue[PLYValue["SH_15"] = 55] = "SH_15";
-    PLYValue[PLYValue["SH_16"] = 56] = "SH_16";
-    PLYValue[PLYValue["SH_17"] = 57] = "SH_17";
-    PLYValue[PLYValue["SH_18"] = 58] = "SH_18";
-    PLYValue[PLYValue["SH_19"] = 59] = "SH_19";
-    PLYValue[PLYValue["SH_20"] = 60] = "SH_20";
-    PLYValue[PLYValue["SH_21"] = 61] = "SH_21";
-    PLYValue[PLYValue["SH_22"] = 62] = "SH_22";
-    PLYValue[PLYValue["SH_23"] = 63] = "SH_23";
-    PLYValue[PLYValue["SH_24"] = 64] = "SH_24";
-    PLYValue[PLYValue["SH_25"] = 65] = "SH_25";
-    PLYValue[PLYValue["SH_26"] = 66] = "SH_26";
-    PLYValue[PLYValue["SH_27"] = 67] = "SH_27";
-    PLYValue[PLYValue["SH_28"] = 68] = "SH_28";
-    PLYValue[PLYValue["SH_29"] = 69] = "SH_29";
-    PLYValue[PLYValue["SH_30"] = 70] = "SH_30";
-    PLYValue[PLYValue["SH_31"] = 71] = "SH_31";
-    PLYValue[PLYValue["SH_32"] = 72] = "SH_32";
-    PLYValue[PLYValue["SH_33"] = 73] = "SH_33";
-    PLYValue[PLYValue["SH_34"] = 74] = "SH_34";
-    PLYValue[PLYValue["SH_35"] = 75] = "SH_35";
-    PLYValue[PLYValue["SH_36"] = 76] = "SH_36";
-    PLYValue[PLYValue["SH_37"] = 77] = "SH_37";
-    PLYValue[PLYValue["SH_38"] = 78] = "SH_38";
-    PLYValue[PLYValue["SH_39"] = 79] = "SH_39";
-    PLYValue[PLYValue["SH_40"] = 80] = "SH_40";
-    PLYValue[PLYValue["SH_41"] = 81] = "SH_41";
-    PLYValue[PLYValue["SH_42"] = 82] = "SH_42";
-    PLYValue[PLYValue["SH_43"] = 83] = "SH_43";
-    PLYValue[PLYValue["SH_44"] = 84] = "SH_44";
-    PLYValue[PLYValue["UNDEFINED"] = 85] = "UNDEFINED";
-})(PLYValue || (PLYValue = {}));
 /**
- * Class used to render a gaussian splatting mesh
+ * Class used to render a Gaussian Splatting mesh. Supports both single-cloud and compound
+ * (multi-part) rendering. In compound mode, multiple Gaussian Splatting source meshes are
+ * merged into one draw call while retaining per-part world-matrix control via
+ * addPart/addParts and removePart.
  */
-export class GaussianSplattingMesh extends Mesh {
+export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
     /**
-     * If true, disables depth sorting of the splats (default: false)
+     * Creates a new GaussianSplattingMesh
+     * @param name the name of the mesh
+     * @param url optional URL to load a Gaussian Splatting file from
+     * @param scene the hosting scene
+     * @param keepInRam whether to keep the raw splat data in RAM after uploading to GPU
      */
-    get disableDepthSort() {
-        return this._disableDepthSort;
-    }
-    set disableDepthSort(value) {
-        if (!this._disableDepthSort && value) {
-            this._worker?.terminate();
-            this._worker = null;
-            this._disableDepthSort = true;
-        }
-        else if (this._disableDepthSort && !value) {
-            this._disableDepthSort = false;
-            this._sortIsDirty = true;
-            this._instanciateWorker();
-        }
+    constructor(name, url = null, scene = null, keepInRam = false) {
+        super(name, url, scene, keepInRam);
+        /**
+         * Proxy meshes indexed by part index. Maintained in sync with _partMatrices.
+         */
+        this._partProxies = [];
+        /**
+         * World matrices for each part, indexed by part index.
+         */
+        this._partMatrices = [];
+        /** When true, suppresses the sort trigger inside setWorldMatrixForPart during batch rebuilds. */
+        this._rebuilding = false;
+        /**
+         * Visibility values for each part (0.0 to 1.0), indexed by part index.
+         */
+        this._partVisibility = [];
+        this._partIndicesTexture = null;
+        this._partIndices = null;
+        // Ensure _splatsData is retained once compound mode is entered — addPart/addParts need
+        // the source data for full-texture rebuilds. Set after super() so it is visible to
+        // _updateData when the async load completes.
+        this._alwaysRetainSplatsData = true;
     }
     /**
-     * View direction factor used to compute the SH view direction in the shader.
-     * @deprecated Not used anymore for SH rendering
+     * Returns the class name
+     * @returns "GaussianSplattingMesh"
      */
-    get viewDirectionFactor() {
-        return Vector3.OneReadOnly;
+    getClassName() {
+        return "GaussianSplattingMesh";
     }
     /**
-     * SH degree. 0 = no sh (default). 1 = 3 parameters. 2 = 8 parameters. 3 = 15 parameters.
-     * Value is clamped between 0 and the maximum degree available from loaded data.
+     * Disposes proxy meshes and clears part data in addition to the base class GPU resources.
+     * @param doNotRecurse Set to true to not recurse into each children
      */
-    get shDegree() {
-        return this._shDegree;
-    }
-    set shDegree(value) {
-        const maxDegree = this._shTextures?.length ?? 0;
-        const clamped = Math.max(0, Math.min(Math.round(value), maxDegree));
-        if (this._shDegree === clamped) {
-            return;
+    dispose(doNotRecurse) {
+        for (const proxy of this._partProxies) {
+            proxy.dispose();
         }
-        this._shDegree = clamped;
-        this.material?.resetDrawCache();
-    }
-    /**
-     * Maximum SH degree available from the loaded data.
-     */
-    get maxShDegree() {
-        return this._shTextures?.length ?? 0;
-    }
-    /**
-     * Number of splats in the mesh
-     */
-    get splatCount() {
-        return this._splatIndex?.length;
+        if (this._partIndicesTexture) {
+            this._partIndicesTexture.dispose();
+        }
+        this._partProxies = [];
+        this._partMatrices = [];
+        this._partVisibility = [];
+        this._partIndicesTexture = null;
+        super.dispose(doNotRecurse);
     }
+    // ---------------------------------------------------------------------------
+    // Worker and material hooks
+    // ---------------------------------------------------------------------------
     /**
-     * returns the splats data array buffer that contains in order : postions (3 floats), size (3 floats), color (4 bytes), orientation quaternion (4 bytes)
+     * Posts the initial per-part data to the sort worker after it has been created.
+     * Sends the current part matrices and group index array so the worker can correctly
+     * weight depth values per part.
+     * @param worker the newly created sort worker
      */
-    get splatsData() {
-        return this._splatsData;
+    _onWorkerCreated(worker) {
+        worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
+        worker.postMessage({ partIndices: this._partIndices ? new Uint8Array(this._partIndices) : null });
     }
     /**
-     * returns the SH data arrays
+     * Stores the raw part index array, padded to texture length, so the worker and GPU texture
+     * creation step have access to it.
+     * @param partIndices - the raw part indices array received during a data load
+     * @param textureLength - the padded texture length to allocate into
      */
-    get shData() {
-        return this._shData;
+    _onIndexDataReceived(partIndices, textureLength) {
+        this._partIndices = new Uint8Array(textureLength);
+        this._partIndices.set(partIndices);
     }
     /**
-     * True when this mesh is a compound that regroups multiple Gaussian splatting parts.
+     * Returns `true` when at least one part has been added to this compound mesh.
+     * Returns `false` before any parts are added, so the mesh renders in normal
+     * (non-compound) mode until the first addPart/addParts call. This matches the
+     * old base-class behavior of `this._partMatrices.length > 0` and avoids
+     * binding unset partWorld uniforms (which would cause division-by-zero in the
+     * Gaussian projection Jacobian and produce huge distorted splats).
+     * @internal
      */
     get isCompound() {
         return this._partMatrices.length > 0;
     }
     /**
-     * returns the part indices array
+     * During a removePart rebuild, keep the existing sort worker alive rather than
+     * tearing it down and spinning up a new one. This avoids startup latency and the
+     * transient state window where a stale sort could fire against an incomplete
+     * partMatrices array.
+     * Outside of a rebuild the base-class behaviour is used unchanged.
      */
-    get partIndices() {
-        return this._partIndices;
-    }
-    /**
-     * Gets the part indices texture, if the mesh is a compound
-     */
-    get partIndicesTexture() {
-        return this._partIndicesTexture;
-    }
-    /**
-     * Gets the part visibility array, if the mesh is a compound
-     */
-    get partVisibility() {
-        return this._partVisibility;
-    }
-    /**
-     * Gets the covariancesA texture
-     */
-    get covariancesATexture() {
-        return this._covariancesATexture;
-    }
-    /**
-     * Gets the covariancesB texture
-     */
-    get covariancesBTexture() {
-        return this._covariancesBTexture;
-    }
-    /**
-     * Gets the centers texture
-     */
-    get centersTexture() {
-        return this._centersTexture;
-    }
-    /**
-     * Gets the colors texture
-     */
-    get colorsTexture() {
-        return this._colorsTexture;
-    }
-    /**
-     * Gets the SH textures
-     */
-    get shTextures() {
-        return this._shTextures;
-    }
-    /**
-     * Gets the kernel size
-     * Documentation and mathematical explanations here:
-     * https://github.com/graphdeco-inria/gaussian-splatting/issues/294#issuecomment-1772688093
-     * https://github.com/autonomousvision/mip-splatting/issues/18#issuecomment-1929388931
-     */
-    get kernelSize() {
-        return this._material instanceof GaussianSplattingMaterial ? this._material.kernelSize : 0;
-    }
-    /**
-     * Get the compensation state
-     */
-    get compensation() {
-        return this._material instanceof GaussianSplattingMaterial ? this._material.compensation : false;
-    }
-    /**
-     * set rendering material
-     */
-    set material(value) {
-        this._material = value;
-        this._material.backFaceCulling = false;
-        this._material.cullBackFaces = false;
-        value.resetDrawCache();
-    }
-    /**
-     * get rendering material
-     */
-    get material() {
-        return this._material;
-    }
-    static _MakeSplatGeometryForMesh(mesh) {
-        const vertexData = new VertexData();
-        const originPositions = [-2, -2, 0, 2, -2, 0, 2, 2, 0, -2, 2, 0];
-        const originIndices = [0, 1, 2, 0, 2, 3];
-        const positions = [];
-        const indices = [];
-        for (let i = 0; i < GaussianSplattingMesh._BatchSize; i++) {
-            for (let j = 0; j < 12; j++) {
-                if (j == 2 || j == 5 || j == 8 || j == 11) {
-                    positions.push(i); // local splat index
-                }
-                else {
-                    positions.push(originPositions[j]);
-                }
-            }
-            indices.push(originIndices.map((v) => v + i * 4));
-        }
-        vertexData.positions = positions;
-        vertexData.indices = indices.flat();
-        vertexData.applyToMesh(mesh);
-    }
-    /**
-     * Creates a new gaussian splatting mesh
-     * @param name defines the name of the mesh
-     * @param url defines the url to load from (optional)
-     * @param scene defines the hosting scene (optional)
-     * @param keepInRam keep datas in ram for editing purpose
-     */
-    constructor(name, url = null, scene = null, keepInRam = false) {
-        super(name, scene);
-        this._vertexCount = 0;
-        this._worker = null;
-        this._modelViewProjectionMatrix = Matrix.Identity();
-        this._canPostToWorker = true;
-        this._readyToDisplay = false;
-        this._covariancesATexture = null;
-        this._covariancesBTexture = null;
-        this._centersTexture = null;
-        this._colorsTexture = null;
-        this._splatPositions = null;
-        this._splatIndex = null;
-        this._shTextures = null;
-        this._splatsData = null;
-        this._shData = null;
-        this._partIndicesTexture = null;
-        this._partIndices = null;
-        this._partMatrices = [];
-        this._partVisibility = [];
-        this._partProxies = new Map();
-        this._textureSize = new Vector2(0, 0);
-        this._keepInRam = false;
-        this._delayedTextureUpdate = null;
-        this._useRGBACovariants = false;
-        this._material = null;
-        this._tmpCovariances = [0, 0, 0, 0, 0, 0];
-        this._sortIsDirty = false;
-        this._shDegree = 0;
-        this._cameraViewInfos = new Map();
-        /**
-         * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
-         */
-        this.viewUpdateThreshold = GaussianSplattingMesh._DefaultViewUpdateThreshold;
-        this._disableDepthSort = false;
-        this._loadingPromise = null;
-        this.subMeshes = [];
-        new SubMesh(0, 0, 4 * GaussianSplattingMesh._BatchSize, 0, 6 * GaussianSplattingMesh._BatchSize, this);
-        this.setEnabled(false);
-        // webGL2 and webGPU support for RG texture with float16 is fine. not webGL1
-        this._useRGBACovariants = !this.getEngine().isWebGPU && this.getEngine().version === 1.0;
-        this._keepInRam = keepInRam;
-        if (url) {
-            this._loadingPromise = this.loadFileAsync(url);
+    _instantiateWorker() {
+        if (this._rebuilding && this._worker) {
+            // Worker already exists and is kept alive; just resize the splat-index buffer.
+            this._updateSplatIndexBuffer(this._vertexCount);
+            return;
         }
-        const gaussianSplattingMaterial = new GaussianSplattingMaterial(this.name + "_material", this._scene);
-        gaussianSplattingMaterial.setSourceMesh(this);
-        this._material = gaussianSplattingMaterial;
-        // delete meshes created for cameras on camera removal
-        this._scene.onCameraRemovedObservable.add((camera) => {
-            const cameraId = camera.uniqueId;
-            // delete mesh for this camera
-            if (this._cameraViewInfos.has(cameraId)) {
-                const cameraViewInfos = this._cameraViewInfos.get(cameraId);
-                cameraViewInfos?.mesh.dispose();
-                this._cameraViewInfos.delete(cameraId);
-            }
-        });
+        super._instantiateWorker();
     }
     /**
-     * Get the loading promise when loading the mesh from a URL in the constructor
-     * @returns constructor loading promise or null if no URL was provided
+     * Ensures the part-index GPU texture exists at the start of an incremental update.
+     * Called before the sub-texture upload so the correct texture is available for the first batch.
+     * @param textureSize - current texture dimensions
      */
-    getLoadingPromise() {
-        return this._loadingPromise;
+    _onIncrementalUpdateStart(textureSize) {
+        this._ensurePartIndicesTexture(textureSize, this._partIndices ?? undefined);
     }
     /**
-     * Returns the class name
-     * @returns "GaussianSplattingMesh"
+     * Posts positions (via super) and then additionally posts the current part-index array
+     * to the sort worker so it can associate each splat with its part.
      */
-    getClassName() {
-        return "GaussianSplattingMesh";
-    }
-    /**
-     * Returns the total number of vertices (splats) within the mesh
-     * @returns the total number of vertices
-     */
-    getTotalVertices() {
-        return this._vertexCount;
-    }
-    /**
-     * Is this node ready to be used/rendered
-     * @param completeCheck defines if a complete check (including materials and lights) has to be done (false by default)
-     * @returns true when ready
-     */
-    isReady(completeCheck = false) {
-        if (!super.isReady(completeCheck, true)) {
-            return false;
-        }
-        if (!this._readyToDisplay) {
-            // mesh is ready when worker has done at least 1 sorting
-            this._postToWorker(true);
-            return false;
-        }
-        return true;
-    }
-    _getCameraDirection(camera) {
-        const cameraViewMatrix = camera.getViewMatrix();
-        const cameraProjectionMatrix = camera.getProjectionMatrix();
-        const cameraViewProjectionMatrix = TmpVectors.Matrix[0];
-        cameraViewMatrix.multiplyToRef(cameraProjectionMatrix, cameraViewProjectionMatrix);
-        const modelMatrix = this.getWorldMatrix();
-        const modelViewMatrix = TmpVectors.Matrix[1];
-        modelMatrix.multiplyToRef(cameraViewMatrix, modelViewMatrix);
-        modelMatrix.multiplyToRef(cameraViewProjectionMatrix, this._modelViewProjectionMatrix);
-        // return vector used to compute distance to camera
-        const localDirection = TmpVectors.Vector3[1];
-        localDirection.set(modelViewMatrix.m[2], modelViewMatrix.m[6], modelViewMatrix.m[10]);
-        localDirection.normalize();
-        return localDirection;
-    }
-    /** @internal */
-    _postToWorker(forced = false) {
-        const scene = this._scene;
-        const frameId = scene.getFrameId();
-        // force update or at least frame update for camera is outdated
-        let outdated = false;
-        this._cameraViewInfos.forEach((cameraViewInfos) => {
-            if (cameraViewInfos.frameIdLastUpdate !== frameId) {
-                outdated = true;
-            }
-        });
-        // array of cameras used for rendering
-        const cameras = this._scene.activeCameras?.length ? this._scene.activeCameras : [this._scene.activeCamera];
-        // list view infos for active cameras
-        const activeViewInfos = [];
-        cameras.forEach((camera) => {
-            if (!camera) {
-                return;
-            }
-            const cameraId = camera.uniqueId;
-            const cameraViewInfos = this._cameraViewInfos.get(cameraId);
-            if (cameraViewInfos) {
-                activeViewInfos.push(cameraViewInfos);
-            }
-            else {
-                // mesh doesn't exist yet for this camera
-                const cameraMesh = new Mesh(this.name + "_cameraMesh_" + cameraId, this._scene);
-                // not visible with inspector or the scene graph
-                cameraMesh.reservedDataStore = { hidden: true };
-                cameraMesh.setEnabled(false);
-                cameraMesh.material = this.material;
-                if (cameraMesh.material && cameraMesh.material instanceof GaussianSplattingMaterial) {
-                    const gsMaterial = cameraMesh.material;
-                    // GaussianSplattingMaterial source mesh may not have been set yet.
-                    // This happens for cloned resources from asset containers for instance,
-                    // where material is cloned before mesh.
-                    if (!gsMaterial.getSourceMesh()) {
-                        gsMaterial.setSourceMesh(this);
-                    }
-                }
-                GaussianSplattingMesh._MakeSplatGeometryForMesh(cameraMesh);
-                const newViewInfos = {
-                    camera: camera,
-                    cameraDirection: new Vector3(0, 0, 0),
-                    mesh: cameraMesh,
-                    frameIdLastUpdate: frameId,
-                    splatIndexBufferSet: false,
-                };
-                activeViewInfos.push(newViewInfos);
-                this._cameraViewInfos.set(cameraId, newViewInfos);
-            }
-        });
-        // sort view infos by last updated frame id: first item is the least recently updated
-        activeViewInfos.sort((a, b) => a.frameIdLastUpdate - b.frameIdLastUpdate);
-        const hasSortFunction = this._worker || Native?.sortSplats || this._disableDepthSort;
-        if ((forced || outdated) && hasSortFunction && (this._scene.activeCameras?.length || this._scene.activeCamera) && this._canPostToWorker) {
-            // view infos sorted by least recent updated frame id
-            activeViewInfos.forEach((cameraViewInfos) => {
-                const camera = cameraViewInfos.camera;
-                const cameraDirection = this._getCameraDirection(camera);
-                const previousCameraDirection = cameraViewInfos.cameraDirection;
-                const dot = Vector3.Dot(cameraDirection, previousCameraDirection);
-                if ((forced || Math.abs(dot - 1) >= this.viewUpdateThreshold) && this._canPostToWorker) {
-                    cameraViewInfos.cameraDirection.copyFrom(cameraDirection);
-                    cameraViewInfos.frameIdLastUpdate = frameId;
-                    this._canPostToWorker = false;
-                    if (this._worker) {
-                        const cameraViewMatrix = camera.getViewMatrix();
-                        this._worker.postMessage({
-                            worldMatrix: this.getWorldMatrix().m,
-                            cameraForward: [cameraViewMatrix.m[2], cameraViewMatrix.m[6], cameraViewMatrix.m[10]],
-                            cameraPosition: [camera.globalPosition.x, camera.globalPosition.y, camera.globalPosition.z],
-                            depthMix: this._depthMix,
-                            cameraId: camera.uniqueId,
-                        }, [this._depthMix.buffer]);
-                    }
-                    else if (Native?.sortSplats) {
-                        Native.sortSplats(this._modelViewProjectionMatrix, this._splatPositions, this._splatIndex, this._scene.useRightHandedSystem);
-                        if (cameraViewInfos.splatIndexBufferSet) {
-                            cameraViewInfos.mesh.thinInstanceBufferUpdated("splatIndex");
-                        }
-                        else {
-                            cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
-                            cameraViewInfos.splatIndexBufferSet = true;
-                        }
-                        this._canPostToWorker = true;
-                        this._readyToDisplay = true;
-                    }
-                }
-            });
-        }
-        else if (this._disableDepthSort) {
-            activeViewInfos.forEach((cameraViewInfos) => {
-                if (!cameraViewInfos.splatIndexBufferSet) {
-                    cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
-                    cameraViewInfos.splatIndexBufferSet = true;
-                }
-            });
-            this._canPostToWorker = true;
-            this._readyToDisplay = true;
+    _notifyWorkerNewData() {
+        super._notifyWorkerNewData();
+        if (this._worker) {
+            this._worker.postMessage({ partIndices: this._partIndices ?? null });
         }
     }
     /**
-     * Triggers the draw call for the mesh. Usually, you don't need to call this method by your own because the mesh rendering is handled by the scene rendering manager
-     * @param subMesh defines the subMesh to render
-     * @param enableAlphaMode defines if alpha mode can be changed
-     * @param effectiveMeshReplacement defines an optional mesh used to provide info for the rendering
-     * @returns the current mesh
+     * Binds all compound-specific shader uniforms: the group index texture, per-part world
+     * matrices, and per-part visibility values.
+     * @param effect the shader effect that is being bound
+     * @internal
      */
-    render(subMesh, enableAlphaMode, effectiveMeshReplacement) {
-        this._postToWorker();
-        // geometry used for shadows, bind the first found in the camera view infos
-        if (!this._geometry && this._cameraViewInfos.size) {
-            this._geometry = this._cameraViewInfos.values().next().value.mesh.geometry;
-        }
-        const cameraId = this._scene.activeCamera.uniqueId;
-        const cameraViewInfos = this._cameraViewInfos.get(cameraId);
-        if (!cameraViewInfos || !cameraViewInfos.splatIndexBufferSet) {
-            return this;
-        }
-        if (this.onBeforeRenderObservable) {
-            this.onBeforeRenderObservable.notifyObservers(this);
-        }
-        const mesh = cameraViewInfos.mesh;
-        mesh.getWorldMatrix().copyFrom(this.getWorldMatrix());
-        // Propagate render pass material overrides (e.g., GPU picking) to the inner camera mesh.
-        // When this mesh is rendered into a RenderTargetTexture with a material override (via setMaterialForRendering),
-        // the override is set on this proxy mesh but needs to be applied to the actual camera mesh that does the rendering.
-        const engine = this._scene.getEngine();
-        const renderPassId = engine.currentRenderPassId;
-        const renderPassMaterial = this.getMaterialForRenderPass(renderPassId);
-        if (renderPassMaterial) {
-            mesh.setMaterialForRenderPass(renderPassId, renderPassMaterial);
-        }
-        const ret = mesh.render(subMesh, enableAlphaMode, effectiveMeshReplacement);
-        // Clean up the temporary override to avoid affecting other render passes
-        if (renderPassMaterial) {
-            mesh.setMaterialForRenderPass(renderPassId, undefined);
-        }
-        if (this.onAfterRenderObservable) {
-            this.onAfterRenderObservable.notifyObservers(this);
+    bindExtraEffectUniforms(effect) {
+        if (!this._partIndicesTexture) {
+            return;
         }
-        return ret;
-    }
-    static _TypeNameToEnum(name) {
-        switch (name) {
-            case "float":
-                return 0 /* PLYType.FLOAT */;
-            case "int":
-                return 1 /* PLYType.INT */;
-            case "uint":
-                return 2 /* PLYType.UINT */;
-            case "double":
-                return 3 /* PLYType.DOUBLE */;
-            case "uchar":
-                return 4 /* PLYType.UCHAR */;
+        effect.setTexture("partIndicesTexture", this._partIndicesTexture);
+        const partWorldData = new Float32Array(this.partCount * 16);
+        for (let i = 0; i < this.partCount; i++) {
+            this._partMatrices[i].toArray(partWorldData, i * 16);
         }
-        return 5 /* PLYType.UNDEFINED */;
-    }
-    static _ValueNameToEnum(name) {
-        switch (name) {
-            case "min_x":
-                return 0 /* PLYValue.MIN_X */;
-            case "min_y":
-                return 1 /* PLYValue.MIN_Y */;
-            case "min_z":
-                return 2 /* PLYValue.MIN_Z */;
-            case "max_x":
-                return 3 /* PLYValue.MAX_X */;
-            case "max_y":
-                return 4 /* PLYValue.MAX_Y */;
-            case "max_z":
-                return 5 /* PLYValue.MAX_Z */;
-            case "min_scale_x":
-                return 6 /* PLYValue.MIN_SCALE_X */;
-            case "min_scale_y":
-                return 7 /* PLYValue.MIN_SCALE_Y */;
-            case "min_scale_z":
-                return 8 /* PLYValue.MIN_SCALE_Z */;
-            case "max_scale_x":
-                return 9 /* PLYValue.MAX_SCALE_X */;
-            case "max_scale_y":
-                return 10 /* PLYValue.MAX_SCALE_Y */;
-            case "max_scale_z":
-                return 11 /* PLYValue.MAX_SCALE_Z */;
-            case "packed_position":
-                return 12 /* PLYValue.PACKED_POSITION */;
-            case "packed_rotation":
-                return 13 /* PLYValue.PACKED_ROTATION */;
-            case "packed_scale":
-                return 14 /* PLYValue.PACKED_SCALE */;
-            case "packed_color":
-                return 15 /* PLYValue.PACKED_COLOR */;
-            case "x":
-                return 16 /* PLYValue.X */;
-            case "y":
-                return 17 /* PLYValue.Y */;
-            case "z":
-                return 18 /* PLYValue.Z */;
-            case "scale_0":
-                return 19 /* PLYValue.SCALE_0 */;
-            case "scale_1":
-                return 20 /* PLYValue.SCALE_1 */;
-            case "scale_2":
-                return 21 /* PLYValue.SCALE_2 */;
-            case "diffuse_red":
-            case "red":
-                return 22 /* PLYValue.DIFFUSE_RED */;
-            case "diffuse_green":
-            case "green":
-                return 23 /* PLYValue.DIFFUSE_GREEN */;
-            case "diffuse_blue":
-            case "blue":
-                return 24 /* PLYValue.DIFFUSE_BLUE */;
-            case "f_dc_0":
-                return 26 /* PLYValue.F_DC_0 */;
-            case "f_dc_1":
-                return 27 /* PLYValue.F_DC_1 */;
-            case "f_dc_2":
-                return 28 /* PLYValue.F_DC_2 */;
-            case "f_dc_3":
-                return 29 /* PLYValue.F_DC_3 */;
-            case "opacity":
-                return 25 /* PLYValue.OPACITY */;
-            case "rot_0":
-                return 30 /* PLYValue.ROT_0 */;
-            case "rot_1":
-                return 31 /* PLYValue.ROT_1 */;
-            case "rot_2":
-                return 32 /* PLYValue.ROT_2 */;
-            case "rot_3":
-                return 33 /* PLYValue.ROT_3 */;
-            case "min_r":
-                return 34 /* PLYValue.MIN_COLOR_R */;
-            case "min_g":
-                return 35 /* PLYValue.MIN_COLOR_G */;
-            case "min_b":
-                return 36 /* PLYValue.MIN_COLOR_B */;
-            case "max_r":
-                return 37 /* PLYValue.MAX_COLOR_R */;
-            case "max_g":
-                return 38 /* PLYValue.MAX_COLOR_G */;
-            case "max_b":
-                return 39 /* PLYValue.MAX_COLOR_B */;
-            case "f_rest_0":
-                return 40 /* PLYValue.SH_0 */;
-            case "f_rest_1":
-                return 41 /* PLYValue.SH_1 */;
-            case "f_rest_2":
-                return 42 /* PLYValue.SH_2 */;
-            case "f_rest_3":
-                return 43 /* PLYValue.SH_3 */;
-            case "f_rest_4":
-                return 44 /* PLYValue.SH_4 */;
-            case "f_rest_5":
-                return 45 /* PLYValue.SH_5 */;
-            case "f_rest_6":
-                return 46 /* PLYValue.SH_6 */;
-            case "f_rest_7":
-                return 47 /* PLYValue.SH_7 */;
-            case "f_rest_8":
-                return 48 /* PLYValue.SH_8 */;
-            case "f_rest_9":
-                return 49 /* PLYValue.SH_9 */;
-            case "f_rest_10":
-                return 50 /* PLYValue.SH_10 */;
-            case "f_rest_11":
-                return 51 /* PLYValue.SH_11 */;
-            case "f_rest_12":
-                return 52 /* PLYValue.SH_12 */;
-            case "f_rest_13":
-                return 53 /* PLYValue.SH_13 */;
-            case "f_rest_14":
-                return 54 /* PLYValue.SH_14 */;
-            case "f_rest_15":
-                return 55 /* PLYValue.SH_15 */;
-            case "f_rest_16":
-                return 56 /* PLYValue.SH_16 */;
-            case "f_rest_17":
-                return 57 /* PLYValue.SH_17 */;
-            case "f_rest_18":
-                return 58 /* PLYValue.SH_18 */;
-            case "f_rest_19":
-                return 59 /* PLYValue.SH_19 */;
-            case "f_rest_20":
-                return 60 /* PLYValue.SH_20 */;
-            case "f_rest_21":
-                return 61 /* PLYValue.SH_21 */;
-            case "f_rest_22":
-                return 62 /* PLYValue.SH_22 */;
-            case "f_rest_23":
-                return 63 /* PLYValue.SH_23 */;
-            case "f_rest_24":
-                return 64 /* PLYValue.SH_24 */;
-            case "f_rest_25":
-                return 65 /* PLYValue.SH_25 */;
-            case "f_rest_26":
-                return 66 /* PLYValue.SH_26 */;
-            case "f_rest_27":
-                return 67 /* PLYValue.SH_27 */;
-            case "f_rest_28":
-                return 68 /* PLYValue.SH_28 */;
-            case "f_rest_29":
-                return 69 /* PLYValue.SH_29 */;
-            case "f_rest_30":
-                return 70 /* PLYValue.SH_30 */;
-            case "f_rest_31":
-                return 71 /* PLYValue.SH_31 */;
-            case "f_rest_32":
-                return 72 /* PLYValue.SH_32 */;
-            case "f_rest_33":
-                return 73 /* PLYValue.SH_33 */;
-            case "f_rest_34":
-                return 74 /* PLYValue.SH_34 */;
-            case "f_rest_35":
-                return 75 /* PLYValue.SH_35 */;
-            case "f_rest_36":
-                return 76 /* PLYValue.SH_36 */;
-            case "f_rest_37":
-                return 77 /* PLYValue.SH_37 */;
-            case "f_rest_38":
-                return 78 /* PLYValue.SH_38 */;
-            case "f_rest_39":
-                return 79 /* PLYValue.SH_39 */;
-            case "f_rest_40":
-                return 80 /* PLYValue.SH_40 */;
-            case "f_rest_41":
-                return 81 /* PLYValue.SH_41 */;
-            case "f_rest_42":
-                return 82 /* PLYValue.SH_42 */;
-            case "f_rest_43":
-                return 83 /* PLYValue.SH_43 */;
-            case "f_rest_44":
-                return 84 /* PLYValue.SH_44 */;
+        effect.setMatrices("partWorld", partWorldData);
+        const partVisibilityData = [];
+        for (let i = 0; i < this.partCount; i++) {
+            partVisibilityData.push(this._partVisibility[i] ?? 1.0);
         }
-        return 85 /* PLYValue.UNDEFINED */;
+        effect.setArray("partVisibility", partVisibilityData);
     }
+    // ---------------------------------------------------------------------------
+    // Part matrix / visibility management
+    // ---------------------------------------------------------------------------
     /**
-     * Parse a PLY file header and returns metas infos on splats and chunks
-     * @param data the loaded buffer
-     * @returns a PLYHeader
+     * Gets the number of parts in the compound.
      */
-    static ParseHeader(data) {
-        const ubuf = new Uint8Array(data);
-        const header = new TextDecoder().decode(ubuf.slice(0, 1024 * 10));
-        const headerEnd = "end_header\n";
-        const headerEndIndex = header.indexOf(headerEnd);
-        if (headerEndIndex < 0 || !header) {
-            // standard splat
-            return null;
-        }
-        const vertexCount = parseInt(/element vertex (\d+)\n/.exec(header)[1]);
-        const chunkElement = /element chunk (\d+)\n/.exec(header);
-        let chunkCount = 0;
-        if (chunkElement) {
-            chunkCount = parseInt(chunkElement[1]);
-        }
-        let rowVertexOffset = 0;
-        let rowChunkOffset = 0;
-        const offsets = {
-            double: 8,
-            int: 4,
-            uint: 4,
-            float: 4,
-            short: 2,
-            ushort: 2,
-            uchar: 1,
-            list: 0,
-        };
-        let ElementMode;
-        (function (ElementMode) {
-            ElementMode[ElementMode["Vertex"] = 0] = "Vertex";
-            ElementMode[ElementMode["Chunk"] = 1] = "Chunk";
-            ElementMode[ElementMode["SH"] = 2] = "SH";
-            ElementMode[ElementMode["Unused"] = 3] = "Unused";
-        })(ElementMode || (ElementMode = {}));
-        let chunkMode = 1 /* ElementMode.Chunk */;
-        const vertexProperties = [];
-        const chunkProperties = [];
-        const filtered = header.slice(0, headerEndIndex).split("\n");
-        let shDegree = 0;
-        for (const prop of filtered) {
-            if (prop.startsWith("property ")) {
-                const [, typeName, name] = prop.split(" ");
-                const value = GaussianSplattingMesh._ValueNameToEnum(name);
-                if (value != 85 /* PLYValue.UNDEFINED */) {
-                    // SH degree 1,2 or 3 for 9, 24 or 45 values
-                    if (value >= 84 /* PLYValue.SH_44 */) {
-                        shDegree = 3;
-                    }
-                    else if (value >= 64 /* PLYValue.SH_24 */) {
-                        shDegree = Math.max(shDegree, 2);
-                    }
-                    else if (value >= 48 /* PLYValue.SH_8 */) {
-                        shDegree = Math.max(shDegree, 1);
-                    }
-                }
-                const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
-                if (chunkMode == 1 /* ElementMode.Chunk */) {
-                    chunkProperties.push({ value, type, offset: rowChunkOffset });
-                    rowChunkOffset += offsets[typeName];
-                }
-                else if (chunkMode == 0 /* ElementMode.Vertex */) {
-                    vertexProperties.push({ value, type, offset: rowVertexOffset });
-                    rowVertexOffset += offsets[typeName];
-                }
-                else if (chunkMode == 2 /* ElementMode.SH */) {
-                    // SH doesn't count for vertex row size but its properties are used to retrieve SH
-                    vertexProperties.push({ value, type, offset: rowVertexOffset });
-                }
-                if (!offsets[typeName]) {
-                    Logger.Warn(`Unsupported property type: ${typeName}.`);
-                }
-            }
-            else if (prop.startsWith("element ")) {
-                const [, type] = prop.split(" ");
-                if (type == "chunk") {
-                    chunkMode = 1 /* ElementMode.Chunk */;
-                }
-                else if (type == "vertex") {
-                    chunkMode = 0 /* ElementMode.Vertex */;
-                }
-                else if (type == "sh") {
-                    chunkMode = 2 /* ElementMode.SH */;
-                }
-                else {
-                    chunkMode = 3 /* ElementMode.Unused */;
-                }
-            }
-        }
-        const dataView = new DataView(data, headerEndIndex + headerEnd.length);
-        const buffer = new ArrayBuffer(GaussianSplattingMesh._RowOutputLength * vertexCount);
-        let shBuffer = null;
-        let shCoefficientCount = 0;
-        if (shDegree) {
-            const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;
-            shCoefficientCount = shVectorCount * 3;
-            shBuffer = new ArrayBuffer(shCoefficientCount * vertexCount);
-        }
-        return {
-            vertexCount: vertexCount,
-            chunkCount: chunkCount,
-            rowVertexLength: rowVertexOffset,
-            rowChunkLength: rowChunkOffset,
-            vertexProperties: vertexProperties,
-            chunkProperties: chunkProperties,
-            dataView: dataView,
-            buffer: buffer,
-            shDegree: shDegree,
-            shCoefficientCount: shCoefficientCount,
-            shBuffer: shBuffer,
-        };
-    }
-    static _GetCompressedChunks(header, offset) {
-        if (!header.chunkCount) {
-            return null;
-        }
-        const dataView = header.dataView;
-        const compressedChunks = new Array(header.chunkCount);
-        for (let i = 0; i < header.chunkCount; i++) {
-            const currentChunk = {
-                min: new Vector3(),
-                max: new Vector3(),
-                minScale: new Vector3(),
-                maxScale: new Vector3(),
-                minColor: new Vector3(0, 0, 0),
-                maxColor: new Vector3(1, 1, 1),
-            };
-            compressedChunks[i] = currentChunk;
-            for (let propertyIndex = 0; propertyIndex < header.chunkProperties.length; propertyIndex++) {
-                const property = header.chunkProperties[propertyIndex];
-                let value;
-                switch (property.type) {
-                    case 0 /* PLYType.FLOAT */:
-                        value = dataView.getFloat32(property.offset + offset.value, true);
-                        break;
-                    default:
-                        continue;
-                }
-                switch (property.value) {
-                    case 0 /* PLYValue.MIN_X */:
-                        currentChunk.min.x = value;
-                        break;
-                    case 1 /* PLYValue.MIN_Y */:
-                        currentChunk.min.y = value;
-                        break;
-                    case 2 /* PLYValue.MIN_Z */:
-                        currentChunk.min.z = value;
-                        break;
-                    case 3 /* PLYValue.MAX_X */:
-                        currentChunk.max.x = value;
-                        break;
-                    case 4 /* PLYValue.MAX_Y */:
-                        currentChunk.max.y = value;
-                        break;
-                    case 5 /* PLYValue.MAX_Z */:
-                        currentChunk.max.z = value;
-                        break;
-                    case 6 /* PLYValue.MIN_SCALE_X */:
-                        currentChunk.minScale.x = value;
-                        break;
-                    case 7 /* PLYValue.MIN_SCALE_Y */:
-                        currentChunk.minScale.y = value;
-                        break;
-                    case 8 /* PLYValue.MIN_SCALE_Z */:
-                        currentChunk.minScale.z = value;
-                        break;
-                    case 9 /* PLYValue.MAX_SCALE_X */:
-                        currentChunk.maxScale.x = value;
-                        break;
-                    case 10 /* PLYValue.MAX_SCALE_Y */:
-                        currentChunk.maxScale.y = value;
-                        break;
-                    case 11 /* PLYValue.MAX_SCALE_Z */:
-                        currentChunk.maxScale.z = value;
-                        break;
-                    case 34 /* PLYValue.MIN_COLOR_R */:
-                        currentChunk.minColor.x = value;
-                        break;
-                    case 35 /* PLYValue.MIN_COLOR_G */:
-                        currentChunk.minColor.y = value;
-                        break;
-                    case 36 /* PLYValue.MIN_COLOR_B */:
-                        currentChunk.minColor.z = value;
-                        break;
-                    case 37 /* PLYValue.MAX_COLOR_R */:
-                        currentChunk.maxColor.x = value;
-                        break;
-                    case 38 /* PLYValue.MAX_COLOR_G */:
-                        currentChunk.maxColor.y = value;
-                        break;
-                    case 39 /* PLYValue.MAX_COLOR_B */:
-                        currentChunk.maxColor.z = value;
-                        break;
-                }
-            }
-            offset.value += header.rowChunkLength;
-        }
-        return compressedChunks;
-    }
-    static _GetSplat(header, index, compressedChunks, offset) {
-        const q = TmpVectors.Quaternion[0];
-        const temp3 = TmpVectors.Vector3[0];
-        const rowOutputLength = GaussianSplattingMesh._RowOutputLength;
-        const buffer = header.buffer;
-        const dataView = header.dataView;
-        const position = new Float32Array(buffer, index * rowOutputLength, 3);
-        const scale = new Float32Array(buffer, index * rowOutputLength + 12, 3);
-        const rgba = new Uint8ClampedArray(buffer, index * rowOutputLength + 24, 4);
-        const rot = new Uint8ClampedArray(buffer, index * rowOutputLength + 28, 4);
-        let sh = null;
-        if (header.shBuffer) {
-            sh = new Uint8ClampedArray(header.shBuffer, index * header.shCoefficientCount, header.shCoefficientCount);
-        }
-        const chunkIndex = index >> 8;
-        let r0 = 255;
-        let r1 = 0;
-        let r2 = 0;
-        let r3 = 0;
-        const plySH = [];
-        for (let propertyIndex = 0; propertyIndex < header.vertexProperties.length; propertyIndex++) {
-            const property = header.vertexProperties[propertyIndex];
-            let value;
-            switch (property.type) {
-                case 0 /* PLYType.FLOAT */:
-                    value = dataView.getFloat32(offset.value + property.offset, true);
-                    break;
-                case 1 /* PLYType.INT */:
-                    value = dataView.getInt32(offset.value + property.offset, true);
-                    break;
-                case 2 /* PLYType.UINT */:
-                    value = dataView.getUint32(offset.value + property.offset, true);
-                    break;
-                case 3 /* PLYType.DOUBLE */:
-                    value = dataView.getFloat64(offset.value + property.offset, true);
-                    break;
-                case 4 /* PLYType.UCHAR */:
-                    value = dataView.getUint8(offset.value + property.offset);
-                    break;
-                default:
-                    continue;
-            }
-            switch (property.value) {
-                case 12 /* PLYValue.PACKED_POSITION */:
-                    {
-                        const compressedChunk = compressedChunks[chunkIndex];
-                        Unpack111011(value, temp3);
-                        position[0] = Scalar.Lerp(compressedChunk.min.x, compressedChunk.max.x, temp3.x);
-                        position[1] = Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
-                        position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
-                    }
-                    break;
-                case 13 /* PLYValue.PACKED_ROTATION */:
-                    {
-                        UnpackRot(value, q);
-                        r0 = q.x;
-                        r1 = q.y;
-                        r2 = q.z;
-                        r3 = q.w;
-                    }
-                    break;
-                case 14 /* PLYValue.PACKED_SCALE */:
-                    {
-                        const compressedChunk = compressedChunks[chunkIndex];
-                        Unpack111011(value, temp3);
-                        scale[0] = Math.exp(Scalar.Lerp(compressedChunk.minScale.x, compressedChunk.maxScale.x, temp3.x));
-                        scale[1] = Math.exp(Scalar.Lerp(compressedChunk.minScale.y, compressedChunk.maxScale.y, temp3.y));
-                        scale[2] = Math.exp(Scalar.Lerp(compressedChunk.minScale.z, compressedChunk.maxScale.z, temp3.z));
-                    }
-                    break;
-                case 15 /* PLYValue.PACKED_COLOR */:
-                    {
-                        const compressedChunk = compressedChunks[chunkIndex];
-                        Unpack8888(value, rgba);
-                        rgba[0] = Scalar.Lerp(compressedChunk.minColor.x, compressedChunk.maxColor.x, rgba[0] / 255) * 255;
-                        rgba[1] = Scalar.Lerp(compressedChunk.minColor.y, compressedChunk.maxColor.y, rgba[1] / 255) * 255;
-                        rgba[2] = Scalar.Lerp(compressedChunk.minColor.z, compressedChunk.maxColor.z, rgba[2] / 255) * 255;
-                    }
-                    break;
-                case 16 /* PLYValue.X */:
-                    position[0] = value;
-                    break;
-                case 17 /* PLYValue.Y */:
-                    position[1] = value;
-                    break;
-                case 18 /* PLYValue.Z */:
-                    position[2] = value;
-                    break;
-                case 19 /* PLYValue.SCALE_0 */:
-                    scale[0] = Math.exp(value);
-                    break;
-                case 20 /* PLYValue.SCALE_1 */:
-                    scale[1] = Math.exp(value);
-                    break;
-                case 21 /* PLYValue.SCALE_2 */:
-                    scale[2] = Math.exp(value);
-                    break;
-                case 22 /* PLYValue.DIFFUSE_RED */:
-                    rgba[0] = value;
-                    break;
-                case 23 /* PLYValue.DIFFUSE_GREEN */:
-                    rgba[1] = value;
-                    break;
-                case 24 /* PLYValue.DIFFUSE_BLUE */:
-                    rgba[2] = value;
-                    break;
-                case 26 /* PLYValue.F_DC_0 */:
-                    rgba[0] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 27 /* PLYValue.F_DC_1 */:
-                    rgba[1] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 28 /* PLYValue.F_DC_2 */:
-                    rgba[2] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 29 /* PLYValue.F_DC_3 */:
-                    rgba[3] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 25 /* PLYValue.OPACITY */:
-                    rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
-                    break;
-                case 30 /* PLYValue.ROT_0 */:
-                    r0 = value;
-                    break;
-                case 31 /* PLYValue.ROT_1 */:
-                    r1 = value;
-                    break;
-                case 32 /* PLYValue.ROT_2 */:
-                    r2 = value;
-                    break;
-                case 33 /* PLYValue.ROT_3 */:
-                    r3 = value;
-                    break;
-            }
-            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
-                const shIndex = property.value - 40 /* PLYValue.SH_0 */;
-                if (property.type == 4 /* PLYType.UCHAR */ && header.chunkCount) {
-                    // compressed ply. dataView points to beginning of vertex
-                    // could be improved with a direct copy instead of a per SH index computation + copy
-                    const compressedValue = dataView.getUint8(header.rowChunkLength * header.chunkCount + header.vertexCount * header.rowVertexLength + index * header.shCoefficientCount + shIndex);
-                    // compressed .ply SH import : https://github.com/playcanvas/engine/blob/fda3f0368b45d7381f0b5a1722bd2056128eaebe/src/scene/gsplat/gsplat-compressed-data.js#L88C81-L88C98
-                    plySH[shIndex] = (compressedValue * (8 / 255) - 4) * 127.5 + 127.5;
-                }
-                else {
-                    const clampedValue = Scalar.Clamp(value * 127.5 + 127.5, 0, 255);
-                    plySH[shIndex] = clampedValue;
-                }
-            }
-        }
-        if (sh) {
-            const shDim = header.shDegree == 1 ? 3 : header.shDegree == 2 ? 8 : 15;
-            for (let j = 0; j < shDim; j++) {
-                sh[j * 3 + 0] = plySH[j];
-                sh[j * 3 + 1] = plySH[j + shDim];
-                sh[j * 3 + 2] = plySH[j + shDim * 2];
-            }
-        }
-        q.set(r1, r2, r3, r0);
-        q.normalize();
-        rot[0] = q.w * 127.5 + 127.5;
-        rot[1] = q.x * 127.5 + 127.5;
-        rot[2] = q.y * 127.5 + 127.5;
-        rot[3] = q.z * 127.5 + 127.5;
-        offset.value += header.rowVertexLength;
+    get partCount() {
+        return this._partMatrices.length;
     }
     /**
-     * Converts a .ply data with SH coefficients splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @param useCoroutine use coroutine and yield
-     * @returns the loaded splat buffer and optional array of sh coefficients
+     * Gets the part visibility array.
      */
-    static *ConvertPLYWithSHToSplat(data, useCoroutine = false) {
-        const header = GaussianSplattingMesh.ParseHeader(data);
-        if (!header) {
-            return { buffer: data };
-        }
-        const offset = { value: 0 };
-        const compressedChunks = GaussianSplattingMesh._GetCompressedChunks(header, offset);
-        for (let i = 0; i < header.vertexCount; i++) {
-            GaussianSplattingMesh._GetSplat(header, i, compressedChunks, offset);
-            if (i % GaussianSplattingMesh._PlyConversionBatchSize === 0 && useCoroutine) {
-                yield;
-            }
-        }
-        let sh = null;
-        // make SH texture buffers
-        if (header.shDegree && header.shBuffer) {
-            const textureCount = Math.ceil(header.shCoefficientCount / 16); // 4 components can be stored per texture, 4 sh per component
-            let shIndexRead = 0;
-            const ubuf = new Uint8Array(header.shBuffer);
-            // sh is an array of uint8array that will be used to create sh textures
-            sh = [];
-            const splatCount = header.vertexCount;
-            const engine = EngineStore.LastCreatedEngine;
-            if (engine) {
-                const width = engine.getCaps().maxTextureSize;
-                const height = Math.ceil(splatCount / width);
-                // create array for the number of textures needed.
-                for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
-                    const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
-                    sh.push(texture);
-                }
-                for (let i = 0; i < splatCount; i++) {
-                    for (let shIndexWrite = 0; shIndexWrite < header.shCoefficientCount; shIndexWrite++) {
-                        const shValue = ubuf[shIndexRead++];
-                        const textureIndex = Math.floor(shIndexWrite / 16);
-                        const shArray = sh[textureIndex];
-                        const byteIndexInTexture = shIndexWrite % 16; // [0..15]
-                        const offsetPerSplat = i * 16; // 16 sh values per texture per splat.
-                        shArray[byteIndexInTexture + offsetPerSplat] = shValue;
-                    }
-                }
-            }
-        }
-        return { buffer: header.buffer, sh: sh };
+    get partVisibility() {
+        return this._partVisibility;
     }
     /**
-     * Converts a .ply data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @param useCoroutine use coroutine and yield
-     * @returns the loaded splat buffer without SH coefficient, whether ply contains or not SH.
+     * Sets the world matrix for a specific part of the compound.
+     * This will trigger a re-sort of the mesh.
+     * The `_partMatrices` array is automatically extended when `partIndex >= partCount`.
+     * @param partIndex index of the part
+     * @param worldMatrix the world matrix to set
      */
-    static *ConvertPLYToSplat(data, useCoroutine = false) {
-        const header = GaussianSplattingMesh.ParseHeader(data);
-        if (!header) {
-            return data;
+    setWorldMatrixForPart(partIndex, worldMatrix) {
+        if (this._partMatrices.length <= partIndex) {
+            this.computeWorldMatrix(true);
+            const defaultMatrix = this.getWorldMatrix();
+            while (this._partMatrices.length <= partIndex) {
+                this._partMatrices.push(defaultMatrix.clone());
+                this._partVisibility.push(1.0);
+            }
         }
-        const offset = { value: 0 };
-        const compressedChunks = GaussianSplattingMesh._GetCompressedChunks(header, offset);
-        for (let i = 0; i < header.vertexCount; i++) {
-            GaussianSplattingMesh._GetSplat(header, i, compressedChunks, offset);
-            if (i % GaussianSplattingMesh._PlyConversionBatchSize === 0 && useCoroutine) {
-                yield;
+        this._partMatrices[partIndex].copyFrom(worldMatrix);
+        // During a batch rebuild suppress intermediate posts — the final correct set is posted
+        // once the full rebuild completes (at the end of removePart).
+        if (!this._rebuilding) {
+            if (this._worker) {
+                this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
             }
+            this._postToWorker(true);
         }
-        return header.buffer;
-    }
-    /**
-     * Converts a .ply data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @returns the loaded splat buffer
-     */
-    static async ConvertPLYToSplatAsync(data) {
-        return await runCoroutineAsync(GaussianSplattingMesh.ConvertPLYToSplat(data, true), createYieldingScheduler());
-    }
-    /**
-     * Converts a .ply with SH data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @returns the loaded splat buffer with SH
-     */
-    static async ConvertPLYWithSHToSplatAsync(data) {
-        return await runCoroutineAsync(GaussianSplattingMesh.ConvertPLYWithSHToSplat(data, true), createYieldingScheduler());
     }
     /**
-     * Loads a .splat Gaussian Splatting array buffer asynchronously
-     * @param data arraybuffer containing splat file
-     * @returns a promise that resolves when the operation is complete
+     * Gets the world matrix for a specific part of the compound.
+     * @param partIndex index of the part, that must be between 0 and partCount - 1
+     * @returns the world matrix for the part, or the current world matrix of the mesh if the part is not found
      */
-    async loadDataAsync(data) {
-        return await this.updateDataAsync(data);
+    getWorldMatrixForPart(partIndex) {
+        return this._partMatrices[partIndex] ?? this.getWorldMatrix();
     }
     /**
-     * Loads a Gaussian or Splatting file asynchronously
-     * @param url path to the splat file to load
-     * @param scene optional scene it belongs to
-     * @returns a promise that resolves when the operation is complete
-     * @deprecated Please use SceneLoader.ImportMeshAsync instead
+     * Gets the visibility for a specific part of the compound.
+     * @param partIndex index of the part, that must be between 0 and partCount - 1
+     * @returns the visibility value (0.0 to 1.0) for the part
      */
-    async loadFileAsync(url, scene) {
-        await ImportMeshAsync(url, (scene || EngineStore.LastCreatedScene), { pluginOptions: { splat: { gaussianSplattingMesh: this } } });
+    getPartVisibility(partIndex) {
+        return this._partVisibility[partIndex] ?? 1.0;
     }
     /**
-     * Releases resources associated with this mesh.
-     * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+     * Sets the visibility for a specific part of the compound.
+     * @param partIndex index of the part, that must be between 0 and partCount - 1
+     * @param value the visibility value (0.0 to 1.0) to set
      */
-    dispose(doNotRecurse) {
-        this._covariancesATexture?.dispose();
-        this._covariancesBTexture?.dispose();
-        this._centersTexture?.dispose();
-        this._colorsTexture?.dispose();
-        if (this._shTextures) {
-            for (const shTexture of this._shTextures) {
-                shTexture.dispose();
-            }
-        }
-        if (this._partIndicesTexture) {
-            this._partIndicesTexture.dispose();
-        }
-        this._covariancesATexture = null;
-        this._covariancesBTexture = null;
-        this._centersTexture = null;
-        this._colorsTexture = null;
-        this._shTextures = null;
-        this._partIndicesTexture = null;
-        this._partMatrices = [];
-        this._worker?.terminate();
-        this._worker = null;
-        // delete meshes created for each camera
-        this._cameraViewInfos.forEach((cameraViewInfo) => {
-            cameraViewInfo.mesh.dispose();
-        });
-        // dispose all proxy meshes
-        this._partProxies.forEach((proxy) => {
-            proxy.dispose();
-        });
-        this._partProxies.clear();
-        super.dispose(doNotRecurse, true);
+    setPartVisibility(partIndex, value) {
+        this._partVisibility[partIndex] = Math.max(0.0, Math.min(1.0, value));
     }
     _copyTextures(source) {
-        this._covariancesATexture = source.covariancesATexture?.clone();
-        this._covariancesBTexture = source.covariancesBTexture?.clone();
-        this._centersTexture = source.centersTexture?.clone();
-        this._colorsTexture = source.colorsTexture?.clone();
+        super._copyTextures(source);
         this._partIndicesTexture = source._partIndicesTexture?.clone();
-        if (source._shTextures) {
-            this._shTextures = [];
-            for (const shTexture of source._shTextures) {
-                this._shTextures?.push(shTexture.clone());
-            }
-        }
-    }
-    /**
-     * Returns a new Mesh object generated from the current mesh properties.
-     * @param name is a string, the name given to the new mesh
-     * @returns a new Gaussian Splatting Mesh
-     */
-    clone(name = "") {
-        const newGS = new GaussianSplattingMesh(name, undefined, this.getScene());
-        newGS._copySource(this);
-        newGS.makeGeometryUnique();
-        newGS._vertexCount = this._vertexCount;
-        newGS._copyTextures(this);
-        newGS._modelViewProjectionMatrix = Matrix.Identity();
-        newGS._splatPositions = this._splatPositions;
-        newGS._readyToDisplay = false;
-        newGS._disableDepthSort = this._disableDepthSort;
-        newGS._partMatrices = this._partMatrices.map((m) => m.clone());
-        newGS._instanciateWorker();
-        const binfo = this.getBoundingInfo();
-        newGS.getBoundingInfo().reConstruct(binfo.minimum, binfo.maximum, this.getWorldMatrix());
-        newGS.forcedInstanceCount = this.forcedInstanceCount;
-        newGS.setEnabled(true);
-        return newGS;
-    }
-    _makeEmptySplat(index, covA, covB, colorArray) {
-        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
-        this._splatPositions[4 * index + 0] = 0;
-        this._splatPositions[4 * index + 1] = 0;
-        this._splatPositions[4 * index + 2] = 0;
-        covA[index * 4 + 0] = ToHalfFloat(0);
-        covA[index * 4 + 1] = ToHalfFloat(0);
-        covA[index * 4 + 2] = ToHalfFloat(0);
-        covA[index * 4 + 3] = ToHalfFloat(0);
-        covB[index * covBSItemSize + 0] = ToHalfFloat(0);
-        covB[index * covBSItemSize + 1] = ToHalfFloat(0);
-        colorArray[index * 4 + 3] = 0;
-    }
-    _makeSplat(index, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options) {
-        const matrixRotation = TmpVectors.Matrix[0];
-        const matrixScale = TmpVectors.Matrix[1];
-        const quaternion = TmpVectors.Quaternion[0];
-        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
-        const x = fBuffer[8 * index + 0];
-        const y = fBuffer[8 * index + 1] * (options.flipY ? -1 : 1);
-        const z = fBuffer[8 * index + 2];
-        this._splatPositions[4 * index + 0] = x;
-        this._splatPositions[4 * index + 1] = y;
-        this._splatPositions[4 * index + 2] = z;
-        minimum.minimizeInPlaceFromFloats(x, y, z);
-        maximum.maximizeInPlaceFromFloats(x, y, z);
-        quaternion.set((uBuffer[32 * index + 28 + 1] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 2] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 3] - 127.5) / 127.5, -(uBuffer[32 * index + 28 + 0] - 127.5) / 127.5);
-        quaternion.normalize();
-        quaternion.toRotationMatrix(matrixRotation);
-        Matrix.ScalingToRef(fBuffer[8 * index + 3 + 0] * 2, fBuffer[8 * index + 3 + 1] * 2, fBuffer[8 * index + 3 + 2] * 2, matrixScale);
-        const m = matrixRotation.multiplyToRef(matrixScale, TmpVectors.Matrix[0]).m;
-        const covariances = this._tmpCovariances;
-        covariances[0] = m[0] * m[0] + m[1] * m[1] + m[2] * m[2];
-        covariances[1] = m[0] * m[4] + m[1] * m[5] + m[2] * m[6];
-        covariances[2] = m[0] * m[8] + m[1] * m[9] + m[2] * m[10];
-        covariances[3] = m[4] * m[4] + m[5] * m[5] + m[6] * m[6];
-        covariances[4] = m[4] * m[8] + m[5] * m[9] + m[6] * m[10];
-        covariances[5] = m[8] * m[8] + m[9] * m[9] + m[10] * m[10];
-        // normalize covA, covB
-        let factor = -10000;
-        for (let covIndex = 0; covIndex < 6; covIndex++) {
-            factor = Math.max(factor, Math.abs(covariances[covIndex]));
-        }
-        this._splatPositions[4 * index + 3] = factor;
-        const transform = factor;
-        covA[index * 4 + 0] = ToHalfFloat(covariances[0] / transform);
-        covA[index * 4 + 1] = ToHalfFloat(covariances[1] / transform);
-        covA[index * 4 + 2] = ToHalfFloat(covariances[2] / transform);
-        covA[index * 4 + 3] = ToHalfFloat(covariances[3] / transform);
-        covB[index * covBSItemSize + 0] = ToHalfFloat(covariances[4] / transform);
-        covB[index * covBSItemSize + 1] = ToHalfFloat(covariances[5] / transform);
-        // colors
-        colorArray[index * 4 + 0] = uBuffer[32 * index + 24 + 0];
-        colorArray[index * 4 + 1] = uBuffer[32 * index + 24 + 1];
-        colorArray[index * 4 + 2] = uBuffer[32 * index + 24 + 2];
-        colorArray[index * 4 + 3] = uBuffer[32 * index + 24 + 3];
     }
-    // NB: partIndices is assumed to be padded to a round texture size
-    _updateTextures(covA, covB, colorArray, sh, partIndices) {
-        const textureSize = this._getTextureSize(this._vertexCount);
-        // Update the textures
-        const createTextureFromData = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 2, 1);
-        };
+    _onUpdateTextures(textureSize) {
         const createTextureFromDataU8 = (data, width, height, format) => {
             return new RawTexture(data, width, height, format, this._scene, false, false, 2, 0);
         };
-        const createTextureFromDataU32 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 7);
-        };
-        const createTextureFromDataF16 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 2, 2);
-        };
-        const firstTime = this._covariancesATexture === null;
-        const textureSizeChanged = this._textureSize.y != textureSize.y;
-        if (!firstTime && !textureSizeChanged) {
-            this._delayedTextureUpdate = { covA, covB, colors: colorArray, centers: this._splatPositions, sh, partIndices };
-            const positions = Float32Array.from(this._splatPositions);
-            const vertexCount = this._vertexCount;
-            if (this._worker) {
-                this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
-            }
-            // Handle SH textures in update path - create if they don't exist
-            if (sh && !this._shTextures) {
-                this._shTextures = [];
-                for (const shData of sh) {
-                    const buffer = new Uint32Array(shData.buffer);
-                    const shTexture = createTextureFromDataU32(buffer, textureSize.x, textureSize.y, 11);
-                    shTexture.wrapU = 0;
-                    shTexture.wrapV = 0;
-                    this._shTextures.push(shTexture);
-                }
-            }
-            // Handle compound data, if any
-            if (partIndices && !this._partIndicesTexture) {
-                const buffer = new Uint8Array(partIndices);
+        // Keep the part indices texture in sync with _partIndices whenever textures are rebuilt.
+        // The old "only create if absent" logic left the texture stale after a second addPart/addParts
+        // call that doesn't change the texture dimensions: all new splats kept reading partIndex=0
+        // (the first part), causing wrong positions, broken GPU picking, and shared movement.
+        if (this._partIndices) {
+            const buffer = new Uint8Array(this._partIndices);
+            if (!this._partIndicesTexture) {
                 this._partIndicesTexture = createTextureFromDataU8(buffer, textureSize.x, textureSize.y, 6);
                 this._partIndicesTexture.wrapU = 0;
                 this._partIndicesTexture.wrapV = 0;
             }
-            if (this._worker) {
-                this._worker.postMessage({ partIndices: partIndices ?? null });
-            }
-            this._postToWorker(true);
-        }
-        else {
-            this._textureSize = textureSize;
-            this._covariancesATexture = createTextureFromDataF16(covA, textureSize.x, textureSize.y, 5);
-            this._covariancesBTexture = createTextureFromDataF16(covB, textureSize.x, textureSize.y, this._useRGBACovariants ? 5 : 7);
-            this._centersTexture = createTextureFromData(this._splatPositions, textureSize.x, textureSize.y, 5);
-            this._colorsTexture = createTextureFromDataU8(colorArray, textureSize.x, textureSize.y, 5);
-            if (sh) {
-                this._shTextures = [];
-                for (const shData of sh) {
-                    const buffer = new Uint32Array(shData.buffer);
-                    const shTexture = createTextureFromDataU32(buffer, textureSize.x, textureSize.y, 11);
-                    shTexture.wrapU = 0;
-                    shTexture.wrapV = 0;
-                    this._shTextures.push(shTexture);
-                }
-            }
-            if (partIndices) {
-                const buffer = new Uint8Array(partIndices);
-                this._partIndicesTexture = createTextureFromDataU8(buffer, textureSize.x, textureSize.y, 6);
-                this._partIndicesTexture.wrapU = 0;
-                this._partIndicesTexture.wrapV = 0;
-            }
-            if (firstTime) {
-                this._instanciateWorker();
-            }
             else {
-                if (this._worker) {
-                    const positions = Float32Array.from(this._splatPositions);
-                    const vertexCount = this._vertexCount;
-                    this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
-                    this._worker.postMessage({ partIndices: partIndices ?? null });
+                const existingSize = this._partIndicesTexture.getSize();
+                if (existingSize.width !== textureSize.x || existingSize.height !== textureSize.y) {
+                    // Dimensions changed — dispose and recreate at the new size.
+                    this._partIndicesTexture.dispose();
+                    this._partIndicesTexture = createTextureFromDataU8(buffer, textureSize.x, textureSize.y, 6);
+                    this._partIndicesTexture.wrapU = 0;
+                    this._partIndicesTexture.wrapV = 0;
+                }
+                else {
+                    // Same size — update data in-place (e.g. second addParts fitting in existing dims).
+                    this._updateTextureFromData(this._partIndicesTexture, buffer, textureSize.x, 0, textureSize.y);
                 }
-                this._postToWorker(true);
             }
         }
     }
-    *_updateData(data, isAsync, sh, partIndices, options = { flipY: false }) {
-        // if a covariance texture is present, then it's not a creation but an update
-        if (!this._covariancesATexture) {
-            this._readyToDisplay = false;
-        }
-        // Parse the data
-        const uBuffer = new Uint8Array(data);
-        const fBuffer = new Float32Array(uBuffer.buffer);
-        if (this._keepInRam) {
-            this._splatsData = data;
-            this._shData = sh ? sh.map((arr) => new Uint8Array(arr)) : null;
-        }
-        const vertexCount = uBuffer.length / GaussianSplattingMesh._RowOutputLength;
-        if (vertexCount != this._vertexCount) {
-            this._updateSplatIndexBuffer(vertexCount);
-        }
-        this._vertexCount = vertexCount;
-        // degree == 1 for 1 texture (3 terms), 2 for 2 textures(8 terms) and 3 for 3 textures (15 terms)
-        this._shDegree = sh ? sh.length : 0;
-        const textureSize = this._getTextureSize(vertexCount);
-        const textureLength = textureSize.x * textureSize.y;
-        const lineCountUpdate = GaussianSplattingMesh.ProgressiveUpdateAmount ?? textureSize.y;
-        const textureLengthPerUpdate = textureSize.x * lineCountUpdate;
-        this._splatPositions = new Float32Array(4 * textureLength);
-        const covA = new Uint16Array(textureLength * 4);
-        const covB = new Uint16Array((this._useRGBACovariants ? 4 : 2) * textureLength);
-        const colorArray = new Uint8Array(textureLength * 4);
-        // Ensure that partMatrices.length is at least the maximum part index + 1
-        if (partIndices) {
-            // We always keep part indices in RAM because they are needed for sorting
-            this._partIndices = new Uint8Array(textureLength);
-            this._partIndices.set(partIndices);
-            let maxPartIndex = -1;
-            for (let i = 0; i < partIndices.length; i++) {
-                maxPartIndex = Math.max(maxPartIndex, partIndices[i]);
-            }
-            this._ensureMinimumPartMatricesLength(maxPartIndex + 1);
-        }
-        const minimum = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        const maximum = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-        if (GaussianSplattingMesh.ProgressiveUpdateAmount) {
-            // create textures with not filled-yet array, then update directly portions of it
-            this._updateTextures(covA, covB, colorArray, sh, this._partIndices ? this._partIndices : undefined);
-            this.setEnabled(true);
-            const partCount = Math.ceil(textureSize.y / lineCountUpdate);
-            for (let partIndex = 0; partIndex < partCount; partIndex++) {
-                const updateLine = partIndex * lineCountUpdate;
-                const splatIndexBase = updateLine * textureSize.x;
-                for (let i = 0; i < textureLengthPerUpdate; i++) {
-                    this._makeSplat(splatIndexBase + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options);
-                }
-                this._updateSubTextures(this._splatPositions, covA, covB, colorArray, updateLine, Math.min(lineCountUpdate, textureSize.y - updateLine));
-                // Update the binfo
-                this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
-                if (isAsync) {
-                    yield;
-                }
-            }
-            // sort will be dirty here as just finished filled positions will not be sorted
-            const positions = Float32Array.from(this._splatPositions);
-            const vertexCount = this._vertexCount;
+    _updateSubTextures(splatPositions, covA, covB, colorArray, lineStart, lineCount, sh, partIndices) {
+        super._updateSubTextures(splatPositions, covA, covB, colorArray, lineStart, lineCount, sh);
+        if (partIndices && this._partIndicesTexture) {
+            const textureSize = this._getTextureSize(this._vertexCount);
+            const texelStart = lineStart * textureSize.x;
+            const texelCount = lineCount * textureSize.x;
+            const partIndicesView = new Uint8Array(partIndices.buffer, texelStart, texelCount);
+            this._updateTextureFromData(this._partIndicesTexture, partIndicesView, textureSize.x, lineStart, lineCount);
             if (this._worker) {
-                this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
-                this._worker.postMessage({ partIndices });
-            }
-            this._sortIsDirty = true;
-        }
-        else {
-            const paddedVertexCount = (vertexCount + 15) & ~0xf;
-            for (let i = 0; i < vertexCount; i++) {
-                this._makeSplat(i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum, options);
-                if (isAsync && i % GaussianSplattingMesh._SplatBatchSize === 0) {
-                    yield;
-                }
+                this._worker.postMessage({ partIndices: partIndices });
             }
-            // pad the rest
-            for (let i = vertexCount; i < paddedVertexCount; i++) {
-                this._makeEmptySplat(i, covA, covB, colorArray);
-            }
-            // textures
-            this._updateTextures(covA, covB, colorArray, sh, this._partIndices ? this._partIndices : undefined);
-            // Update the binfo
-            this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
-            this.setEnabled(true);
-            this._sortIsDirty = true;
         }
-        this._postToWorker(true);
-    }
-    /**
-     * Update asynchronously the buffer
-     * @param data array buffer containing center, color, orientation and scale of splats
-     * @param sh optional array of uint8 array for SH data
-     * @param partIndices optional array of uint8 for rig node indices
-     * @returns a promise
-     */
-    async updateDataAsync(data, sh, partIndices) {
-        return await runCoroutineAsync(this._updateData(data, true, sh, partIndices), createYieldingScheduler());
     }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
     /**
-     * @experimental
-     * Update data from GS (position, orientation, color, scaling)
-     * @param data array that contain all the datas
-     * @param sh optional array of uint8 array for SH data
-     * @param options optional informations on how to treat data (needs to be 3rd for backward compatibility)
-     * @param partIndices optional array of uint8 for rig node indices
+     * Creates the part indices GPU texture the first time an incremental addPart introduces
+     * compound data. Has no effect if the texture already exists or no partIndices are provided.
+     * @param textureSize - Current texture dimensions
+     * @param partIndices - Part index data; if undefined the method is a no-op
      */
-    updateData(data, sh, options = { flipY: true }, partIndices) {
-        runCoroutineSync(this._updateData(data, false, sh, partIndices, options));
+    _ensurePartIndicesTexture(textureSize, partIndices) {
+        if (!partIndices || this._partIndicesTexture) {
+            return;
+        }
+        const buffer = new Uint8Array(this._partIndices);
+        this._partIndicesTexture = new RawTexture(buffer, textureSize.x, textureSize.y, 6, this._scene, false, false, 2, 0);
+        this._partIndicesTexture.wrapU = 0;
+        this._partIndicesTexture.wrapV = 0;
+        if (this._worker) {
+            this._worker.postMessage({ partIndices: partIndices ?? null });
+        }
     }
     /**
-     * Refreshes the bounding info, taking into account all the thin instances defined
-     * @returns the current Gaussian Splatting
+     * Core implementation for adding one or more external GaussianSplattingMesh objects as new
+     * parts. Writes directly into texture-sized CPU arrays and uploads in one pass — no merged
+     * CPU splat buffer is ever constructed.
+     *
+     * @param others - Source meshes to append (must each be non-compound and fully loaded)
+     * @param disposeOthers - Dispose source meshes after appending
+     * @returns Proxy meshes and their assigned part indices
      */
-    refreshBoundingInfo() {
-        this.thinInstanceRefreshBoundingInfo(false);
-        return this;
-    }
-    // in case size is different
-    _updateSplatIndexBuffer(vertexCount) {
-        const paddedVertexCount = (vertexCount + 15) & ~0xf;
-        if (!this._splatIndex || vertexCount != this._splatIndex.length) {
-            this._splatIndex = new Float32Array(paddedVertexCount);
-            for (let i = 0; i < paddedVertexCount; i++) {
-                this._splatIndex[i] = i;
-            }
-            // update meshes for knowns cameras
-            this._cameraViewInfos.forEach((cameraViewInfos) => {
-                cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
-            });
+    _addPartsInternal(others, disposeOthers) {
+        if (others.length === 0) {
+            return { proxyMeshes: [], assignedPartIndices: [] };
         }
-        // Update depthMix
-        if ((!this._depthMix || vertexCount != this._depthMix.length) && !IsNative) {
-            this._depthMix = new BigInt64Array(paddedVertexCount);
+        // Validate
+        for (const other of others) {
+            if (!other._splatsData) {
+                throw new Error(`To call addPart()/addParts(), each source mesh must be fully loaded`);
+            }
+            if (other.isCompound) {
+                throw new Error(`To call addPart()/addParts(), each source mesh must not be a compound`);
+            }
         }
-        this.forcedInstanceCount = Math.max(paddedVertexCount >> 4, 1);
-    }
-    _updateSubTextures(centers, covA, covB, colors, lineStart, lineCount, sh, partIndices) {
-        const updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
-            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
-        };
-        const textureSize = this._getTextureSize(this._vertexCount);
+        const splatCountA = this._vertexCount;
+        const totalOtherCount = others.reduce((s, o) => s + o._vertexCount, 0);
+        const totalCount = splatCountA + totalOtherCount;
+        const textureSize = this._getTextureSize(totalCount);
+        const textureLength = textureSize.x * textureSize.y;
         const covBSItemSize = this._useRGBACovariants ? 4 : 2;
-        const texelStart = lineStart * textureSize.x;
-        const texelCount = lineCount * textureSize.x;
-        const covAView = new Uint16Array(covA.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
-        const covBView = new Uint16Array(covB.buffer, texelStart * covBSItemSize * Uint16Array.BYTES_PER_ELEMENT, texelCount * covBSItemSize);
-        const colorsView = new Uint8Array(colors.buffer, texelStart * 4, texelCount * 4);
-        const centersView = new Float32Array(centers.buffer, texelStart * 4 * Float32Array.BYTES_PER_ELEMENT, texelCount * 4);
-        updateTextureFromData(this._covariancesATexture, covAView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._covariancesBTexture, covBView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._centersTexture, centersView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._colorsTexture, colorsView, textureSize.x, lineStart, lineCount);
-        if (sh) {
-            for (let i = 0; i < sh.length; i++) {
-                const componentCount = 4;
-                const shView = new Uint32Array(sh[i].buffer, texelStart * componentCount * 4, texelCount * componentCount);
-                updateTextureFromData(this._shTextures[i], shView, textureSize.x, lineStart, lineCount);
+        // Allocate destination arrays for the full new texture
+        const covA = new Uint16Array(textureLength * 4);
+        const covB = new Uint16Array(covBSItemSize * textureLength);
+        const colorArray = new Uint8Array(textureLength * 4);
+        // Determine merged SH degree
+        const hasSH = this._shData !== null && others.every((o) => o._shData !== null);
+        const shDegreeNew = hasSH ? Math.max(this._shDegree, ...others.map((o) => o._shDegree)) : 0;
+        let sh = undefined;
+        if (hasSH && shDegreeNew > 0) {
+            const bytesPerTexel = 16;
+            sh = [];
+            for (let i = 0; i < shDegreeNew; i++) {
+                sh.push(new Uint8Array(textureLength * bytesPerTexel));
             }
         }
-        if (partIndices && this._partIndicesTexture) {
-            const partIndicesView = new Uint8Array(partIndices.buffer, texelStart, texelCount);
-            updateTextureFromData(this._partIndicesTexture, partIndicesView, textureSize.x, lineStart, lineCount);
-        }
-    }
-    _instanciateWorker() {
-        if (!this._vertexCount) {
-            return;
-        }
-        if (this._disableDepthSort) {
-            return;
+        // --- Incremental path: can we reuse the already-committed GPU region? ---
+        const incremental = this._canReuseCachedData(splatCountA, totalCount);
+        const firstNewLine = incremental ? Math.floor(splatCountA / textureSize.x) : 0;
+        const minimum = incremental ? this._cachedBoundingMin.clone() : new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+        const maximum = incremental ? this._cachedBoundingMax.clone() : new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+        // Preserve existing processed positions in the new array
+        const oldPositions = this._splatPositions;
+        this._splatPositions = new Float32Array(4 * textureLength);
+        if (incremental && oldPositions) {
+            this._splatPositions.set(oldPositions.subarray(0, splatCountA * 4));
         }
-        this._updateSplatIndexBuffer(this._vertexCount);
-        // no worker in native
-        if (IsNative) {
-            return;
+        // --- Build part indices ---
+        let nextPartIndex = this.partCount;
+        let partIndicesA = this._partIndices;
+        if (!partIndicesA) {
+            // First addPart on a plain mesh: assign its splats to part 0
+            partIndicesA = new Uint8Array(splatCountA);
+            nextPartIndex = splatCountA > 0 ? 1 : 0;
         }
-        // Start the worker thread
-        this._worker?.terminate();
-        this._worker = new Worker(URL.createObjectURL(new Blob(["(", GaussianSplattingMesh._CreateWorker.toString(), ")(self)"], {
-            type: "application/javascript",
-        })));
-        const positions = Float32Array.from(this._splatPositions);
-        const partIndices = this._partIndices ? new Uint8Array(this._partIndices) : null;
-        const partMatrices = this._partMatrices.map((matrix) => new Float32Array(matrix.m));
-        this._worker.postMessage({ positions }, [positions.buffer]);
-        this._worker.postMessage({ partIndices });
-        this._worker.postMessage({ partMatrices });
-        this._worker.onmessage = (e) => {
-            // Recompute vertexCountPadded in case _vertexCount has changed since the last update
-            const vertexCountPadded = (this._vertexCount + 15) & ~0xf;
-            // If the vertex count changed, we discard this result and trigger a new sort
-            if (e.data.depthMix.length != vertexCountPadded) {
-                this._canPostToWorker = true;
-                this._postToWorker(true);
-                this._sortIsDirty = false;
-                return;
-            }
-            this._depthMix = e.data.depthMix;
-            const cameraId = e.data.cameraId;
-            const indexMix = new Uint32Array(e.data.depthMix.buffer);
-            if (this._splatIndex) {
-                for (let j = 0; j < vertexCountPadded; j++) {
-                    this._splatIndex[j] = indexMix[2 * j];
+        this._partIndices = new Uint8Array(textureLength);
+        this._partIndices.set(partIndicesA.subarray(0, splatCountA));
+        const assignedPartIndices = [];
+        let dstOffset = splatCountA;
+        const maxPartCount = GetGaussianSplattingMaxPartCount(this._scene.getEngine());
+        for (const other of others) {
+            if (nextPartIndex >= maxPartCount) {
+                throw new Error(`Cannot add part, as the maximum part count (${maxPartCount}) has been reached`);
+            }
+            const newPartIndex = nextPartIndex++;
+            assignedPartIndices.push(newPartIndex);
+            this._partIndices.fill(newPartIndex, dstOffset, dstOffset + other._vertexCount);
+            dstOffset += other._vertexCount;
+        }
+        // --- Process source data ---
+        if (!incremental) {
+            // Full rebuild path — only reached when the GPU texture must be reallocated
+            // (either the texture height needs to grow to fit the new total, or this is
+            // the very first addPart onto a mesh with no GPU textures yet). In the common
+            // case where the texture height is unchanged, `incremental` is true and this
+            // entire block is skipped. The `splatCountA > 0` guard avoids redundant work
+            // on the first-ever addPart when the compound mesh starts empty.
+            if (splatCountA > 0) {
+                if (this._partProxies.length > 0) {
+                    // Already compound: rebuild every existing part from its stored source data.
+                    //
+                    // DESIGN NOTE: The intended use of GaussianSplattingMesh / GaussianSplattingCompoundMesh
+                    // in compound mode is to start EMPTY and compose parts exclusively via addPart/addParts.
+                    // In a future major version this will be the only supported path and the "own data"
+                    // legacy branch below will be removed.
+                    //
+                    // Until then, two layouts are possible:
+                    //   A) LEGACY — compound loaded its own splat data (via URL or updateData) before
+                    //      any addPart call. _partProxies[0] is undefined; the mesh's own splat data
+                    //      is treated as an implicit "part 0" in this._splatsData. Proxied parts occupy
+                    //      indices 1+. This layout will be deprecated in the next major version.
+                    //   B) PREFERRED — compound started empty; first addPart assigned partIndex=0.
+                    //      _partProxies[0] is set; this._splatsData is null; all parts are proxied.
+                    let rebuildOffset = 0;
+                    // Rebuild the compound's legacy "own" data at part 0 (scenario A only).
+                    // Skipped in the preferred empty-composer path (scenario B).
+                    if (!this._partProxies[0] && this._splatsData) {
+                        const proxyVertexCount = this._partProxies.reduce((sum, proxy) => sum + (proxy ? proxy.proxiedMesh._vertexCount : 0), 0);
+                        const part0Count = splatCountA - proxyVertexCount;
+                        if (part0Count > 0) {
+                            const uBufA = new Uint8Array(this._splatsData);
+                            const fBufA = new Float32Array(this._splatsData);
+                            for (let i = 0; i < part0Count; i++) {
+                                this._makeSplat(i, fBufA, uBufA, covA, covB, colorArray, minimum, maximum, false);
+                            }
+                            if (sh && this._shData) {
+                                const bytesPerTexel = 16;
+                                for (let texIdx = 0; texIdx < sh.length; texIdx++) {
+                                    if (texIdx < this._shData.length) {
+                                        sh[texIdx].set(this._shData[texIdx].subarray(0, part0Count * bytesPerTexel), 0);
+                                    }
+                                }
+                            }
+                            rebuildOffset += part0Count;
+                        }
+                    }
+                    // Rebuild all proxied parts. Loop from index 0 because in the preferred
+                    // scenario B, part 0 is itself a proxied part with no implicit "own" data.
+                    for (let partIndex = 0; partIndex < this._partProxies.length; partIndex++) {
+                        const proxy = this._partProxies[partIndex];
+                        if (!proxy || !proxy.proxiedMesh) {
+                            continue;
+                        }
+                        this._appendSourceToArrays(proxy.proxiedMesh, rebuildOffset, covA, covB, colorArray, sh, minimum, maximum);
+                        rebuildOffset += proxy.proxiedMesh._vertexCount;
+                    }
+                }
+                else {
+                    // No proxies yet: this is the very first addPart call on a mesh that loaded
+                    // its own splat data (scenario A legacy path). Re-process that own data so
+                    // it occupies the start of the new texture before the incoming part is appended.
+                    // In the preferred scenario B (empty composer) splatCountA is 0 and this
+                    // entire branch is skipped by the outer `if (splatCountA > 0)` guard.
+                    if (this._splatsData) {
+                        const uBufA = new Uint8Array(this._splatsData);
+                        const fBufA = new Float32Array(this._splatsData);
+                        for (let i = 0; i < splatCountA; i++) {
+                            this._makeSplat(i, fBufA, uBufA, covA, covB, colorArray, minimum, maximum, false);
+                        }
+                        if (sh && this._shData) {
+                            const bytesPerTexel = 16;
+                            for (let texIdx = 0; texIdx < sh.length; texIdx++) {
+                                if (texIdx < this._shData.length) {
+                                    sh[texIdx].set(this._shData[texIdx].subarray(0, splatCountA * bytesPerTexel), 0);
+                                }
+                            }
+                        }
+                    }
                 }
             }
-            if (this._delayedTextureUpdate) {
-                const textureSize = this._getTextureSize(vertexCountPadded);
-                this._updateSubTextures(this._delayedTextureUpdate.centers, this._delayedTextureUpdate.covA, this._delayedTextureUpdate.covB, this._delayedTextureUpdate.colors, 0, textureSize.y, this._delayedTextureUpdate.sh, this._delayedTextureUpdate.partIndices);
-                this._delayedTextureUpdate = null;
-            }
-            // get mesh for camera and update its instance buffer
-            const cameraViewInfos = this._cameraViewInfos.get(cameraId);
-            if (cameraViewInfos) {
-                if (cameraViewInfos.splatIndexBufferSet) {
-                    cameraViewInfos.mesh.thinInstanceBufferUpdated("splatIndex");
+        }
+        // Incremental path: rebuild the partial first row (indices firstNewTexel to splatCountA-1)
+        // so _updateSubTextures does not upload stale zeros over those already-committed texels.
+        // The base-class _updateData always re-processes from firstNewTexel for the same reason;
+        // the compound path must do the same.
+        if (incremental) {
+            const firstNewTexel = firstNewLine * textureSize.x;
+            if (firstNewTexel < splatCountA) {
+                if (this._partProxies.length === 0) {
+                    // No proxies: the mesh loaded its own splat data and this is the first
+                    // addPart call (scenario A legacy path). Re-process the partial boundary
+                    // row so it is not clobbered by stale zeros during the sub-texture upload.
+                    if (this._splatsData) {
+                        const uBufA = new Uint8Array(this._splatsData);
+                        const fBufA = new Float32Array(this._splatsData);
+                        for (let i = firstNewTexel; i < splatCountA; i++) {
+                            this._makeSplat(i, fBufA, uBufA, covA, covB, colorArray, minimum, maximum, false, i);
+                        }
+                    }
                 }
                 else {
-                    cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
-                    cameraViewInfos.splatIndexBufferSet = true;
+                    // Already compound: build a per-partIndex source lookup so each splat in the
+                    // partial boundary row can be re-processed from its original source buffer.
+                    //
+                    // Handles both layouts (see full-rebuild comment above):
+                    //   A) LEGACY: _partProxies[0] absent → seed lookup[0] with this._splatsData
+                    //   B) PREFERRED: _partProxies[0] present → all entries filled from proxies
+                    const proxyTotal = this._partProxies.reduce((s, p) => s + (p ? p.proxiedMesh._vertexCount : 0), 0);
+                    const part0Count = splatCountA - proxyTotal; // > 0 only in legacy scenario A
+                    const srcUBufs = new Array(this._partProxies.length).fill(null);
+                    const srcFBufs = new Array(this._partProxies.length).fill(null);
+                    const partStarts = new Array(this._partProxies.length).fill(0);
+                    // Legacy scenario A: part 0 is the mesh's own loaded data.
+                    if (!this._partProxies[0] && this._splatsData && part0Count > 0) {
+                        srcUBufs[0] = new Uint8Array(this._splatsData);
+                        srcFBufs[0] = new Float32Array(this._splatsData);
+                        partStarts[0] = 0;
+                    }
+                    // All proxied parts — start from pi=0 to cover preferred scenario B.
+                    let cumOffset = part0Count;
+                    for (let pi = 0; pi < this._partProxies.length; pi++) {
+                        const proxy = this._partProxies[pi];
+                        if (!proxy?.proxiedMesh) {
+                            continue;
+                        }
+                        const srcData = proxy.proxiedMesh._splatsData ?? null;
+                        srcUBufs[pi] = srcData ? new Uint8Array(srcData) : null;
+                        srcFBufs[pi] = srcData ? new Float32Array(srcData) : null;
+                        partStarts[pi] = cumOffset;
+                        cumOffset += proxy.proxiedMesh._vertexCount;
+                    }
+                    for (let splatIdx = firstNewTexel; splatIdx < splatCountA; splatIdx++) {
+                        const partIdx = this._partIndices ? this._partIndices[splatIdx] : 0;
+                        const uBuf = partIdx < srcUBufs.length ? srcUBufs[partIdx] : null;
+                        const fBuf = partIdx < srcFBufs.length ? srcFBufs[partIdx] : null;
+                        if (uBuf && fBuf) {
+                            this._makeSplat(splatIdx, fBuf, uBuf, covA, covB, colorArray, minimum, maximum, false, splatIdx - (partStarts[partIdx] ?? 0));
+                        }
+                    }
                 }
             }
-            this._canPostToWorker = true;
-            this._readyToDisplay = true;
-            // sort is dirty when GS is visible for progressive update with a this message arriving but positions were partially filled
-            // another update needs to be kicked. The kick can't happen just when the position buffer is ready because _canPostToWorker might be false.
-            if (this._sortIsDirty) {
-                this._postToWorker(true);
-                this._sortIsDirty = false;
-            }
-        };
-    }
-    _getTextureSize(length) {
-        const engine = this._scene.getEngine();
-        const width = engine.getCaps().maxTextureSize;
-        let height = 1;
-        if (engine.version === 1 && !engine.isWebGPU) {
-            while (width * height < length) {
-                height *= 2;
-            }
         }
-        else {
-            height = Math.ceil(length / width);
-        }
-        if (height > width) {
-            Logger.Error("GaussianSplatting texture size: (" + width + ", " + height + "), maxTextureSize: " + width);
-            height = width;
-        }
-        return new Vector2(width, height);
-    }
-    /**
-     * Gets the number of parts in the compound
-     * @returns the number of parts in the compound, or 0 if the mesh is not a compound
-     */
-    get partCount() {
-        return this._partMatrices.length;
-    }
-    /**
-     * Sets the world matrix for a specific part of the compound (if this mesh is a compound).
-     * This will trigger a re-sort of the mesh.
-     * @param partIndex index of the part, that must be between 0 and partCount - 1
-     * @param worldMatrix the world matrix to set
-     */
-    setWorldMatrixForPart(partIndex, worldMatrix) {
-        this._partMatrices[partIndex].copyFrom(worldMatrix);
-        if (this._worker) {
-            this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
+        // Append each new source
+        dstOffset = splatCountA;
+        for (const other of others) {
+            this._appendSourceToArrays(other, dstOffset, covA, covB, colorArray, sh, minimum, maximum);
+            dstOffset += other._vertexCount;
         }
-        this._postToWorker(true);
-    }
-    /**
-     * Gets the world matrix for a specific part of the compound (if this mesh is a compound).
-     * @param partIndex index of the part, that must be between 0 and partCount - 1
-     * @returns the world matrix for the part, or the current world matrix of the mesh if the mesh is not a compound
-     */
-    getWorldMatrixForPart(partIndex) {
-        return this._partMatrices[partIndex] ?? this.getWorldMatrix();
-    }
-    /**
-     * Gets the visibility for a specific part of the compound (if this mesh is a compound).
-     * @param partIndex index of the part, that must be between 0 and partCount - 1
-     * @returns the visibility value (0.0 to 1.0) for the part
-     */
-    getPartVisibility(partIndex) {
-        return this._partVisibility[partIndex] ?? 1.0;
-    }
-    /**
-     * Sets the visibility for a specific part of the compound (if this mesh is a compound).
-     * @param partIndex index of the part, that must be between 0 and partCount - 1
-     * @param value the visibility value (0.0 to 1.0) to set
-     */
-    setPartVisibility(partIndex, value) {
-        this._partVisibility[partIndex] = Math.max(0.0, Math.min(1.0, value));
-    }
-    /**
-     * Ensure that the part world matrix array is at least the given length.
-     * NB: This length is used as reference for the number of parts in the compound.
-     * Newly inserted parts are initialized with the current world matrix of the mesh.
-     * @param length - The minimum length to ensure
-     */
-    _ensureMinimumPartMatricesLength(length) {
-        if (this._partMatrices.length < length) {
-            this._resizePartMatrices(length);
+        // Pad empty splats to texture boundary
+        const paddedEnd = (totalCount + 15) & ~0xf;
+        for (let i = totalCount; i < paddedEnd; i++) {
+            this._makeEmptySplat(i, covA, covB, colorArray);
         }
-    }
-    /**
-     * This sets the number of parts in the compound.
-     * Warning: This must be consistent with the indices used in the partIndices texture.
-     * Newly inserted parts are initialized with the current world matrix of the mesh.
-     * @param length - The length to resize to
-     */
-    _resizePartMatrices(length) {
-        if (this._partMatrices.length == length) {
-            return;
+        // --- Update vertex count / index buffer ---
+        if (totalCount !== this._vertexCount) {
+            this._updateSplatIndexBuffer(totalCount);
         }
-        else if (this._partMatrices.length > length) {
-            this._partMatrices = this._partMatrices.slice(0, length);
-            this._partVisibility = this._partVisibility.slice(0, length);
+        this._vertexCount = totalCount;
+        this._shDegree = shDegreeNew;
+        // --- Upload to GPU ---
+        if (incremental) {
+            // Update the part-indices texture (handles both create and update-in-place).
+            // _ensurePartIndicesTexture is a no-op when the texture already exists, so on the
+            // second+ addPart the partIndices would be stale without this call.
+            this._onUpdateTextures(textureSize);
+            this._updateSubTextures(this._splatPositions, covA, covB, colorArray, firstNewLine, textureSize.y - firstNewLine, sh);
         }
         else {
-            this.computeWorldMatrix(true);
-            const defaultMatrix = this.getWorldMatrix();
-            while (this._partMatrices.length < length) {
-                this._partMatrices.push(defaultMatrix.clone());
-                this._partVisibility.push(1.0);
-            }
-        }
-        if (this._worker) {
-            this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
-        }
-        this._postToWorker(true);
-    }
+            this._updateTextures(covA, covB, colorArray, sh);
+        }
+        this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+        this.setEnabled(true);
+        this._cachedBoundingMin = minimum.clone();
+        this._cachedBoundingMax = maximum.clone();
+        this._notifyWorkerNewData();
+        // --- Create proxy meshes ---
+        const proxyMeshes = [];
+        for (let i = 0; i < others.length; i++) {
+            const other = others[i];
+            const newPartIndex = assignedPartIndices[i];
+            const partWorldMatrix = other.getWorldMatrix();
+            this.setWorldMatrixForPart(newPartIndex, partWorldMatrix);
+            const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, other, newPartIndex);
+            if (disposeOthers) {
+                other.dispose();
+            }
+            const quaternion = new Quaternion();
+            partWorldMatrix.decompose(proxyMesh.scaling, quaternion, proxyMesh.position);
+            proxyMesh.rotationQuaternion = quaternion;
+            proxyMesh.computeWorldMatrix(true);
+            this._partProxies[newPartIndex] = proxyMesh;
+            proxyMeshes.push(proxyMesh);
+        }
+        return { proxyMeshes, assignedPartIndices };
+    }
+    // ---------------------------------------------------------------------------
+    // Public compound API
+    // ---------------------------------------------------------------------------
     /**
      * Add another mesh to this mesh, as a new part. This makes the current mesh a compound, if not already.
-     * NB: The current mesh needs to be loaded with keepInRam: true.
-     * @param other - The other mesh to add. This must be loaded with keepInRam: true.
+     * The source mesh's splat data is read directly — no merged CPU buffer is constructed.
+     * @param other - The other mesh to add. Must be fully loaded before calling this method.
      * @param disposeOther - Whether to dispose the other mesh after adding it to the current mesh.
      * @returns a placeholder mesh that can be used to manipulate the part transform
+     * @deprecated Use {@link GaussianSplattingCompoundMesh.addPart} instead.
      */
     addPart(other, disposeOther = true) {
-        const maxPartCount = GetGaussianSplattingMaxPartCount(this._scene.getEngine());
-        if (this.partCount >= maxPartCount) {
-            throw new Error(`Cannot add part, as the maximum part count (${maxPartCount}) has been reached`);
-        }
-        const splatCountA = this._vertexCount;
-        const splatsDataA = splatCountA == 0 ? new ArrayBuffer(0) : this.splatsData;
-        const shDataA = this.shData;
-        const splatCountB = other._vertexCount;
-        const splatsDataB = other.splatsData;
-        const shDataB = other.shData;
-        const mergedShDataLength = Math.max(shDataA?.length || 0, shDataB?.length || 0);
-        const hasMergedShData = shDataA !== null && shDataB !== null;
-        // Sanity checks
-        if (!splatsDataA) {
-            throw new Error(`To call addPart(), the current mesh must be loaded with keepInRam: true`);
-        }
-        const expectedSplatsDataSizeA = splatCountA * GaussianSplattingMesh._RowOutputLength;
-        if (splatsDataA.byteLength !== expectedSplatsDataSizeA) {
-            throw new Error(`splatsDataA size (${splatsDataA.byteLength}) does not match expected size (${expectedSplatsDataSizeA})`);
-        }
-        if (!splatsDataB) {
-            throw new Error(`To call addPart(), the other mesh must be loaded with keepInRam: true`);
-        }
-        const expectedSplatsDataSizeB = splatCountB * GaussianSplattingMesh._RowOutputLength;
-        if (splatsDataB.byteLength !== expectedSplatsDataSizeB) {
-            throw new Error(`splatsDataB size (${splatsDataB.byteLength}) does not match expected size (${expectedSplatsDataSizeB})`);
-        }
-        if (other.partIndices) {
-            throw new Error(`To call addPart(), the other mesh must not be a compound`);
-        }
-        // Concatenate splatsData (ArrayBuffer)
-        const mergedSplatsData = new Uint8Array(splatsDataA.byteLength + splatsDataB.byteLength);
-        mergedSplatsData.set(new Uint8Array(splatsDataA), 0);
-        mergedSplatsData.set(new Uint8Array(splatsDataB), splatsDataA.byteLength);
-        let mergedShData = undefined;
-        if (hasMergedShData) {
-            // Note: We need to calculate the texture size and pad accordingly
-            // Each SH texture texel stores 16 bytes (4 RGBA uint32 components)
-            const bytesPerTexel = 16;
-            const totalSplatCount = splatCountA + splatCountB;
-            mergedShData = [];
-            for (let i = 0; i < mergedShDataLength; i++) {
-                const mergedShDataItem = new Uint8Array(totalSplatCount * bytesPerTexel);
-                if (i < (shDataA?.length ?? 0)) {
-                    mergedShDataItem.set(shDataA[i], 0);
-                }
-                if (i < (shDataB?.length ?? 0)) {
-                    const byteOffset = bytesPerTexel * splatCountA;
-                    mergedShDataItem.set(shDataB[i], byteOffset);
-                }
-                mergedShData.push(mergedShDataItem);
-            }
-        }
-        // Concatenate partIndices (Uint8Array)
-        let newPartIndex = this.partCount;
-        let partIndicesA = this.partIndices;
-        if (!partIndicesA) {
-            partIndicesA = new Uint8Array(splatCountA);
-            newPartIndex = splatCountA > 0 ? 1 : 0;
-            //newPartIndex = 1;
-        }
-        if (partIndicesA.length < splatCountA) {
-            throw new Error(`partIndices length (${partIndicesA.length}) should be at least vertexCount (${splatCountA}) in the current mesh`);
-        }
-        const partIndicesB = new Uint8Array(splatCountB).fill(newPartIndex);
-        const mergedPartIndices = new Uint8Array(splatCountA + splatCountB);
-        mergedPartIndices.set(partIndicesA.slice(0, splatCountA), 0);
-        mergedPartIndices.set(partIndicesB, splatCountA);
-        this.updateData(mergedSplatsData.buffer, mergedShData, { flipY: false }, mergedPartIndices);
-        // Merge part matrices (TODO)
-        const partWorldMatrix = other.getWorldMatrix();
-        this.setWorldMatrixForPart(newPartIndex, partWorldMatrix);
-        // Create a proxy mesh to manipulate the part transform
-        const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, other, newPartIndex);
-        if (disposeOther) {
-            other.dispose();
-        }
-        // Set the initial world matrix
-        const quaternion = new Quaternion();
-        partWorldMatrix.decompose(proxyMesh.scaling, quaternion, proxyMesh.position);
-        proxyMesh.rotationQuaternion = quaternion;
-        proxyMesh.computeWorldMatrix(true);
-        // Store the proxy in the map
-        this._partProxies.set(newPartIndex, proxyMesh);
-        return proxyMesh;
+        const { proxyMeshes } = this._addPartsInternal([other], disposeOther);
+        return proxyMeshes[0];
     }
     /**
      * Remove a part from this compound mesh.
+     * The remaining parts are rebuilt directly from their stored source mesh references —
+     * no merged CPU splat buffer is read back. The current mesh is reset to a plain (single-part)
+     * state and then each remaining source is re-added via addParts.
      * @param index - The index of the part to remove
+     * @deprecated Use {@link GaussianSplattingCompoundMesh.removePart} instead.
      */
     removePart(index) {
         if (index < 0 || index >= this.partCount) {
             throw new Error(`Part index ${index} is out of range [0, ${this.partCount})`);
         }
-        // Get the current data
-        const splatsData = this.splatsData;
-        const shData = this.shData;
-        const partIndices = this.partIndices;
-        if (!splatsData || !partIndices) {
-            throw new Error("Cannot remove part from a non-compound mesh or mesh without keepInRam");
-        }
-        const splatCount = this._vertexCount;
-        const rowLength = GaussianSplattingMesh._RowOutputLength;
-        // Count splats that will remain (not in the removed part)
-        let newSplatCount = 0;
-        for (let i = 0; i < splatCount; i++) {
-            if (partIndices[i] !== index) {
-                newSplatCount++;
+        // Collect surviving proxy objects (sorted by current part index so part 0 is added first)
+        const survivors = [];
+        for (let proxyIndex = 0; proxyIndex < this._partProxies.length; proxyIndex++) {
+            const proxy = this._partProxies[proxyIndex];
+            if (proxy && proxyIndex !== index) {
+                survivors.push({ proxyMesh: proxy, oldIndex: proxyIndex, worldMatrix: proxy.getWorldMatrix().clone(), visibility: this._partVisibility[proxyIndex] ?? 1.0 });
             }
         }
-        // Build new splats data excluding the removed part
-        const newSplatsData = new Uint8Array(newSplatCount * rowLength);
-        const newPartIndices = new Uint8Array(newSplatCount);
-        let newShData = undefined;
-        if (shData) {
-            const bytesPerTexel = 16;
-            newShData = [];
-            for (let i = 0; i < shData.length; i++) {
-                newShData.push(new Uint8Array(newSplatCount * bytesPerTexel));
+        survivors.sort((a, b) => a.oldIndex - b.oldIndex);
+        // Validate every survivor still has its source data. If even one is missing we cannot rebuild.
+        for (const { proxyMesh } of survivors) {
+            if (!proxyMesh.proxiedMesh._splatsData) {
+                throw new Error(`Cannot remove part: the source mesh for part "${proxyMesh.name}" no longer has its splat data available.`);
             }
         }
-        let writeIndex = 0;
-        for (let readIndex = 0; readIndex < splatCount; readIndex++) {
-            const currentPartIndex = partIndices[readIndex];
-            if (currentPartIndex === index) {
-                // Skip splats from the removed part
-                continue;
-            }
-            // Copy splat data
-            const srcOffset = readIndex * rowLength;
-            const dstOffset = writeIndex * rowLength;
-            newSplatsData.set(new Uint8Array(splatsData, srcOffset, rowLength), dstOffset);
-            // Renumber part indices: indices > removed index get decremented
-            newPartIndices[writeIndex] = currentPartIndex > index ? currentPartIndex - 1 : currentPartIndex;
-            // Copy SH data if present
-            if (shData && newShData) {
-                const bytesPerTexel = 16;
-                for (let shIndex = 0; shIndex < shData.length; shIndex++) {
-                    const srcShOffset = readIndex * bytesPerTexel;
-                    const dstShOffset = writeIndex * bytesPerTexel;
-                    newShData[shIndex].set(new Uint8Array(shData[shIndex].buffer, srcShOffset, bytesPerTexel), dstShOffset);
-                }
-            }
-            writeIndex++;
-        }
-        // Remove the part matrix and visibility
-        this._partMatrices.splice(index, 1);
-        this._partVisibility.splice(index, 1);
-        // Update worker with new part matrices
+        // --- Reset this mesh to an empty state ---
+        // Terminate the sort worker before zeroing _vertexCount. The worker's onmessage handler
+        // compares depthMix.length against (_vertexCount + 15) & ~0xf; with _vertexCount = 0 that
+        // becomes 16, which causes a forced re-sort loop on stale data and resets _canPostToWorker
+        // to true, defeating the gate below. The worker will be re-instantiated naturally after
+        // the rebuild via the first _postToWorker call.
         if (this._worker) {
-            this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
-        }
-        // Update the mesh with the new data
-        this.updateData(newSplatsData.buffer, newShData, { flipY: false }, newPartIndices);
-        // Dispose and remove the proxy for the removed part
-        const proxyToRemove = this._partProxies.get(index);
-        if (proxyToRemove) {
-            proxyToRemove.dispose();
-            this._partProxies.delete(index);
+            this._worker.terminate();
+            this._worker = null;
         }
-        // Update the proxy map: renumber proxies with index > removed index
-        const proxiesToUpdate = [];
-        this._partProxies.forEach((proxy, proxyIndex) => {
-            if (proxyIndex > index) {
-                proxiesToUpdate.push([proxyIndex, proxy]);
+        // Dispose and null GPU textures so _updateTextures sees firstTime=true and creates
+        // fresh GPU textures.
+        this._covariancesATexture?.dispose();
+        this._covariancesBTexture?.dispose();
+        this._centersTexture?.dispose();
+        this._colorsTexture?.dispose();
+        this._covariancesATexture = null;
+        this._covariancesBTexture = null;
+        this._centersTexture = null;
+        this._colorsTexture = null;
+        if (this._shTextures) {
+            for (const t of this._shTextures) {
+                t.dispose();
             }
-        });
-        // Remove and re-add with updated indices
-        for (const [oldIndex, proxy] of proxiesToUpdate) {
-            this._partProxies.delete(oldIndex);
-            // Update the proxy's internal partIndex
-            proxy.updatePartIndex(oldIndex - 1);
-            this._partProxies.set(oldIndex - 1, proxy);
+            this._shTextures = null;
         }
-    }
-    /**
-     * Modifies the splats according to the passed transformation matrix.
-     * @param transform defines the transform matrix to use
-     * @returns the current mesh
-     */
-    bakeTransformIntoVertices(transform) {
-        const arrayBuffer = this.splatsData;
-        if (!arrayBuffer) {
-            Logger.Error("Cannot bake transform into vertices if splatsData is not kept in RAM");
-            return this;
+        if (this._partIndicesTexture) {
+            this._partIndicesTexture.dispose();
+            this._partIndicesTexture = null;
         }
-        // Check for uniform scaling
-        const m = transform.m;
-        const scaleX = Math.sqrt(m[0] * m[0] + m[1] * m[1] + m[2] * m[2]);
-        const scaleY = Math.sqrt(m[4] * m[4] + m[5] * m[5] + m[6] * m[6]);
-        const scaleZ = Math.sqrt(m[8] * m[8] + m[9] * m[9] + m[10] * m[10]);
-        const epsilon = 0.001;
-        if (Math.abs(scaleX - scaleY) > epsilon || Math.abs(scaleX - scaleZ) > epsilon) {
-            Logger.Error("Gaussian Splatting bakeTransformIntoVertices does not support non-uniform scaling");
-            return this;
+        this._vertexCount = 0;
+        this._splatPositions = null;
+        this._partIndices = null;
+        this._partMatrices = [];
+        this._partVisibility = [];
+        this._cachedBoundingMin = null;
+        this._cachedBoundingMax = null;
+        // Remove the proxy for the removed part and dispose it
+        const proxyToRemove = this._partProxies[index];
+        if (proxyToRemove) {
+            proxyToRemove.dispose();
         }
-        const uBuffer = new Uint8Array(arrayBuffer);
-        const fBuffer = new Float32Array(arrayBuffer);
-        const temp = TmpVectors.Vector3[0];
-        let index;
-        const quaternion = TmpVectors.Quaternion[0];
-        const transformedQuaternion = TmpVectors.Quaternion[1];
-        transform.decompose(temp, transformedQuaternion, temp);
-        for (index = 0; index < this._vertexCount; index++) {
-            const floatIndex = index * 8; // 8 floats per splat (center.x, center.y, center.z, scale.x, scale.y, scale.z, ...)
-            Vector3.TransformCoordinatesFromFloatsToRef(fBuffer[floatIndex], fBuffer[floatIndex + 1], fBuffer[floatIndex + 2], transform, temp);
-            fBuffer[floatIndex] = temp.x;
-            fBuffer[floatIndex + 1] = temp.y;
-            fBuffer[floatIndex + 2] = temp.z;
-            // Apply uniform scaling to splat scales
-            fBuffer[floatIndex + 3] *= scaleX;
-            fBuffer[floatIndex + 4] *= scaleX;
-            fBuffer[floatIndex + 5] *= scaleX;
-            // Unpack quaternion from uint8array (matching _GetSplat packing convention)
-            quaternion.set((uBuffer[32 * index + 28 + 1] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 2] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 3] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 0] - 127.5) / 127.5);
-            quaternion.normalize();
-            // If there is a negative scaling, we need to flip the quaternion to keep the correct handedness
-            if (this.scaling.x < 0) {
-                quaternion.x = -quaternion.x;
-                quaternion.w = -quaternion.w;
-            }
-            if (this.scaling.y < 0) {
-                quaternion.y = -quaternion.y;
-                quaternion.w = -quaternion.w;
-            }
-            if (this.scaling.z < 0) {
-                quaternion.z = -quaternion.z;
-                quaternion.w = -quaternion.w;
-            }
-            // Transform the quaternion
-            transformedQuaternion.multiplyToRef(quaternion, quaternion);
-            quaternion.normalize();
-            // Pack quaternion back to uint8array (matching _GetSplat packing convention)
-            uBuffer[32 * index + 28 + 0] = Math.round(quaternion.w * 127.5 + 127.5);
-            uBuffer[32 * index + 28 + 1] = Math.round(quaternion.x * 127.5 + 127.5);
-            uBuffer[32 * index + 28 + 2] = Math.round(quaternion.y * 127.5 + 127.5);
-            uBuffer[32 * index + 28 + 3] = Math.round(quaternion.z * 127.5 + 127.5);
+        this._partProxies = [];
+        // Rebuild from surviving sources. _addPartsInternal assigns part indices in order 0, 1, 2, …
+        // so the new index for each survivor is simply its position in the survivors array.
+        if (survivors.length === 0) {
+            // Nothing left — leave the mesh empty.
+            this.setEnabled(false);
+            return;
         }
-        this.updateData(arrayBuffer, this.shData ?? undefined, { flipY: false });
-        return this;
+        // Gate the sort worker: suppress any sort request until the full rebuild is committed.
+        this._rebuilding = true;
+        this._canPostToWorker = false;
+        const sources = survivors.map((s) => s.proxyMesh.proxiedMesh);
+        const { proxyMeshes: newProxies } = this._addPartsInternal(sources, false);
+        // Restore world matrices and re-map proxies
+        for (let i = 0; i < survivors.length; i++) {
+            const oldProxy = survivors[i].proxyMesh;
+            const newProxy = newProxies[i];
+            const newPartIndex = newProxy.partIndex;
+            // Restore the world matrix and visibility the user had set on the old proxy
+            this.setWorldMatrixForPart(newPartIndex, survivors[i].worldMatrix);
+            this.setPartVisibility(newPartIndex, survivors[i].visibility);
+            const quaternion = new Quaternion();
+            survivors[i].worldMatrix.decompose(newProxy.scaling, quaternion, newProxy.position);
+            newProxy.rotationQuaternion = quaternion;
+            newProxy.computeWorldMatrix(true);
+            // Update the old proxy's index so any existing user references still work
+            oldProxy.updatePartIndex(newPartIndex);
+            this._partProxies[newPartIndex] = oldProxy;
+            // newProxy is redundant — it was created inside _addPartsInternal; dispose it
+            newProxy.dispose();
+        }
+        // Rebuild is complete: all partMatrices are now set correctly.
+        // Post the final complete set and fire one sort.
+        this._rebuilding = false;
+        // Break TypeScript's flow narrowing — _addPartsInternal may have reinstantiated _worker.
+        const workerAfterRebuild = this._worker;
+        workerAfterRebuild?.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
+        this._canPostToWorker = true;
+        this._postToWorker(true);
     }
 }
-GaussianSplattingMesh._RowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
-GaussianSplattingMesh._SH_C0 = 0.28209479177387814;
-// batch size between 2 yield calls. This value is a tradeoff between updates overhead and framerate hiccups
-// This step is faster the PLY conversion. So batch size can be bigger
-GaussianSplattingMesh._SplatBatchSize = 327680;
-// batch size between 2 yield calls during the PLY to splat conversion.
-GaussianSplattingMesh._PlyConversionBatchSize = 32768;
-GaussianSplattingMesh._BatchSize = 16; // 16 splats per instance
-GaussianSplattingMesh._DefaultViewUpdateThreshold = 1e-4;
-/**
- * Set the number of batch (a batch is 16384 splats) after which a display update is performed
- * A value of 0 (default) means display update will not happens before splat is ready.
- */
-GaussianSplattingMesh.ProgressiveUpdateAmount = 0;
-GaussianSplattingMesh._CreateWorker = function (self) {
-    let positions;
-    let depthMix;
-    let indices;
-    let floatMix;
-    let partIndices;
-    let partMatrices;
-    self.onmessage = (e) => {
-        // updated on init
-        if (e.data.positions) {
-            positions = e.data.positions;
-        }
-        // update on rig node changed
-        else if (e.data.partMatrices) {
-            partMatrices = e.data.partMatrices;
-        }
-        // update on rig node indices changed
-        else if (e.data.partIndices !== undefined) {
-            partIndices = e.data.partIndices;
-        }
-        // update on view changed
-        else {
-            const cameraId = e.data.cameraId;
-            const globalWorldMatrix = e.data.worldMatrix;
-            const cameraForward = e.data.cameraForward;
-            const cameraPosition = e.data.cameraPosition;
-            const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
-            if (!positions || !cameraForward) {
-                // Sanity check, it shouldn't happen!
-                throw new Error("positions or camera info is not defined!");
-            }
-            depthMix = e.data.depthMix;
-            indices = new Uint32Array(depthMix.buffer);
-            floatMix = new Float32Array(depthMix.buffer);
-            // Sort
-            for (let j = 0; j < vertexCountPadded; j++) {
-                indices[2 * j] = j;
-            }
-            // depth = dot(cameraForward, worldPos - cameraPos)
-            const camDot = cameraForward[0] * cameraPosition[0] + cameraForward[1] * cameraPosition[1] + cameraForward[2] * cameraPosition[2];
-            const computeDepthCoeffs = (m) => {
-                return [
-                    cameraForward[0] * m[0] + cameraForward[1] * m[1] + cameraForward[2] * m[2],
-                    cameraForward[0] * m[4] + cameraForward[1] * m[5] + cameraForward[2] * m[6],
-                    cameraForward[0] * m[8] + cameraForward[1] * m[9] + cameraForward[2] * m[10],
-                    cameraForward[0] * m[12] + cameraForward[1] * m[13] + cameraForward[2] * m[14] - camDot,
-                ];
-            };
-            if (partMatrices && partIndices) {
-                // Precompute depth coefficients for each rig node
-                const depthCoeffs = partMatrices.map((m) => computeDepthCoeffs(m));
-                // NB: For performance reasons, we assume that part indices are valid
-                const length = partIndices.length;
-                for (let j = 0; j < vertexCountPadded; j++) {
-                    // NB: We need this 'min' because vertex array is padded, not partIndices
-                    const partIndex = partIndices[Math.min(j, length - 1)];
-                    const coeff = depthCoeffs[partIndex];
-                    floatMix[2 * j + 1] = coeff[0] * positions[4 * j + 0] + coeff[1] * positions[4 * j + 1] + coeff[2] * positions[4 * j + 2] + coeff[3];
-                    // instead of using minus to sort back to front, we use bitwise not operator to invert the order of indices
-                    // might not be faster but a minus sign implies a reference value that may not be enough and will decrease floatting precision
-                    indices[2 * j + 1] = ~indices[2 * j + 1];
-                }
-            }
-            else {
-                // Compute depth coefficients from global world matrix
-                const [a, b, c, d] = computeDepthCoeffs(globalWorldMatrix);
-                for (let j = 0; j < vertexCountPadded; j++) {
-                    floatMix[2 * j + 1] = a * positions[4 * j + 0] + b * positions[4 * j + 1] + c * positions[4 * j + 2] + d;
-                    indices[2 * j + 1] = ~indices[2 * j + 1];
-                }
-            }
-            depthMix.sort();
-            self.postMessage({ depthMix, cameraId }, [depthMix.buffer]);
-        }
-    };
-};
 //# sourceMappingURL=gaussianSplattingMesh.js.map