@babylonjs/core 9.9.1 → 9.10.0

package/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.pure.d.ts

@@ -19,8 +19,9 @@ export declare class GaussianSplattingCompoundMesh extends GaussianSplattingMesh
      * @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
+     * @param needsRotationScaleTextures generate rotation and scale matrix textures required for voxel-based IBL shadows
      */
-    constructor(name: string, url?: Nullable<string>, scene?: Nullable<Scene>, keepInRam?: boolean);
+    constructor(name: string, url?: Nullable<string>, scene?: Nullable<Scene>, keepInRam?: boolean, needsRotationScaleTextures?: boolean);
     /**
      * Add another mesh to this compound mesh as a new part.
      * The source mesh's splat data is read directly and copied into the compound's retained source buffers.

package/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.pure.js

@@ -17,9 +17,10 @@ export class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {
      * @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
+     * @param needsRotationScaleTextures generate rotation and scale matrix textures required for voxel-based IBL shadows
      */
-    constructor(name, url = null, scene = null, keepInRam = false) {
-        super(name, url, scene, keepInRam);
+    constructor(name, url = null, scene = null, keepInRam = false, needsRotationScaleTextures = false) {
+        super(name, url, scene, keepInRam, needsRotationScaleTextures);
     }
     /**
      * Add another mesh to this compound mesh as a new part.

package/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.pure.js.map

@@ -1 +1 @@
-{"version":3,"file":"gaussianSplattingCompoundMesh.pure.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.pure.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAI7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,OAAO,6BAA8B,SAAQ,qBAAqB;IACpE;;;;;;OAMG;IACH,YAAY,IAAY,EAAE,MAAwB,IAAI,EAAE,QAAyB,IAAI,EAAE,YAAqB,KAAK;QAC7G,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;OAMG;IACa,OAAO,CAAC,KAA4B,EAAE,eAAwB,IAAI;QAC9E,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,MAA+B,EAAE,gBAAyB,IAAI;QAC1E,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,EAAE,CAAC;QACd,CAAC;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QACtE,OAAO,WAAW,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACa,UAAU,CAAC,KAAa;QACpC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACa,SAAS,CAAC,sBAA2B,EAAE,EAAE,WAAmB,QAAQ;QAChF,mBAAmB,GAAG,KAAK,CAAC,SAAS,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC;QACrE,mDAAmD;QACnD,2FAA2F;QAC3F,6EAA6E;QAC7E,mBAAmB,CAAC,WAAW,GAAG,IAAI,CAAC;QACvC,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAU,KAAK,CAAC,UAAe,EAAE,KAAY;QACtD,OAAO,qBAAqB,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,EAAE,6BAA6B,CAAC,CAAC;IAClG,CAAC;CACJ;AAED,IAAI,WAAW,GAAG,KAAK,CAAC;AACxB;;;GAGG;AACH,MAAM,UAAU,qCAAqC;IACjD,IAAI,WAAW,EAAE,CAAC;QACd,OAAO;IACX,CAAC;IACD,WAAW,GAAG,IAAI,CAAC;IAEnB,IAAI,CAAC,oCAAoC,GAAG,6BAA6B,CAAC,KAAK,CAAC;AACpF,CAAC","sourcesContent":["/** This file must only contain pure code and pure imports */\r\n\r\nimport { type Nullable } from \"core/types\";\r\nimport { type Scene } from \"core/scene.pure\";\r\nimport { GaussianSplattingMesh } from \"./gaussianSplattingMesh.pure\";\r\nimport { type GaussianSplattingPartProxyMesh } from \"./gaussianSplattingPartProxyMesh.pure\";\r\nimport { Mesh } from \"../mesh.pure\";\r\n\r\n/**\r\n * Class used to compose multiple Gaussian Splatting meshes into a single draw call,\r\n * with per-part world-matrix and visibility control via addPart/addParts/removePart.\r\n *\r\n * This is the recommended class for multi-part Gaussian Splatting use cases.\r\n *\r\n * Next major version: the compound mesh API (addPart/addParts/removePart) will\r\n * move exclusively to this class and will be removed from GaussianSplattingMesh.\r\n */\r\nexport class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {\r\n    /**\r\n     * Creates a new GaussianSplattingCompoundMesh\r\n     * @param name the name of the mesh\r\n     * @param url optional URL to load a Gaussian Splatting file from\r\n     * @param scene the hosting scene\r\n     * @param keepInRam whether to keep the raw splat data in RAM after uploading to GPU\r\n     */\r\n    constructor(name: string, url: Nullable<string> = null, scene: Nullable<Scene> = null, keepInRam: boolean = false) {\r\n        super(name, url, scene, keepInRam);\r\n    }\r\n\r\n    /**\r\n     * Add another mesh to this compound mesh as a new part.\r\n     * The source mesh's splat data is read directly and copied into the compound's retained source buffers.\r\n     * @param other - The other mesh to add. Must be fully loaded before calling this method.\r\n     * @param disposeOther - Whether to dispose the other mesh after adding it.\r\n     * @returns a placeholder mesh that can be used to manipulate the part transform\r\n     */\r\n    public override addPart(other: GaussianSplattingMesh, disposeOther: boolean = true): GaussianSplattingPartProxyMesh {\r\n        return super.addPart(other, disposeOther);\r\n    }\r\n\r\n    /**\r\n     * Add multiple meshes to this compound mesh as new parts in a single operation.\r\n     * Splat data is written into texture arrays while the compound refreshes its retained merged source buffers.\r\n     * @param others - The meshes to add. Each must be fully loaded and must not be a compound.\r\n     * @param disposeOthers - Whether to dispose the other meshes after adding them.\r\n     * @returns an array of placeholder meshes that can be used to manipulate the part transforms\r\n     */\r\n    public addParts(others: GaussianSplattingMesh[], disposeOthers: boolean = true): GaussianSplattingPartProxyMesh[] {\r\n        if (others.length === 0) {\r\n            return [];\r\n        }\r\n        const { proxyMeshes } = this._addPartsInternal(others, disposeOthers);\r\n        return proxyMeshes;\r\n    }\r\n\r\n    /**\r\n     * Remove a part from this compound mesh.\r\n     * The remaining parts are rebuilt directly from the compound mesh's retained source buffers.\r\n     * @param index - The index of the part to remove\r\n     */\r\n    public override removePart(index: number): void {\r\n        super.removePart(index);\r\n    }\r\n\r\n    /**\r\n     * Serialize current GaussianSplattingMesh\r\n     * @param serializationObject defines the object which will receive the serialization data\r\n     * @param encoding the encoding of binary data, defaults to base64 for json serialize,\r\n     * kept for future internal use like cloning where base64 encoding wastes cycles and memory\r\n     * @returns the serialized object\r\n     */\r\n    public override serialize(serializationObject: any = {}, encoding: string = \"base64\"): any {\r\n        serializationObject = super.serialize(serializationObject, encoding);\r\n        // Note here, the getClassName() is not overridden,\r\n        // as a lot of code currently depend on `getClassName() === \"GaussianSplattingMesh\"` check,\r\n        // to not break those code, serialization uses `_isCompound` to mark the type\r\n        serializationObject._isCompound = true;\r\n        return serializationObject;\r\n    }\r\n\r\n    /**\r\n     * Parses a serialized GaussianSplattingCompoundMesh\r\n     * @param parsedMesh the serialized mesh\r\n     * @param scene the scene to create the GaussianSplattingCompoundMesh in\r\n     * @returns the created GaussianSplattingCompoundMesh\r\n     */\r\n    public static override Parse(parsedMesh: any, scene: Scene): GaussianSplattingCompoundMesh {\r\n        return GaussianSplattingMesh._ParseInternal(parsedMesh, scene, GaussianSplattingCompoundMesh);\r\n    }\r\n}\r\n\r\nlet _Registered = false;\r\n/**\r\n * Register side effects for gaussianSplattingCompoundMesh.\r\n * Safe to call multiple times; only the first call has an effect.\r\n */\r\nexport function RegisterGaussianSplattingCompoundMesh(): void {\r\n    if (_Registered) {\r\n        return;\r\n    }\r\n    _Registered = true;\r\n\r\n    Mesh._GaussianSplattingCompoundMeshParser = GaussianSplattingCompoundMesh.Parse;\r\n}\r\n"]}
+{"version":3,"file":"gaussianSplattingCompoundMesh.pure.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.pure.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAI7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,OAAO,6BAA8B,SAAQ,qBAAqB;IACpE;;;;;;;OAOG;IACH,YAAY,IAAY,EAAE,MAAwB,IAAI,EAAE,QAAyB,IAAI,EAAE,YAAqB,KAAK,EAAE,6BAAsC,KAAK;QAC1J,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,0BAA0B,CAAC,CAAC;IACnE,CAAC;IAED;;;;;;OAMG;IACa,OAAO,CAAC,KAA4B,EAAE,eAAwB,IAAI;QAC9E,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,MAA+B,EAAE,gBAAyB,IAAI;QAC1E,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,EAAE,CAAC;QACd,CAAC;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QACtE,OAAO,WAAW,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACa,UAAU,CAAC,KAAa;QACpC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;;OAMG;IACa,SAAS,CAAC,sBAA2B,EAAE,EAAE,WAAmB,QAAQ;QAChF,mBAAmB,GAAG,KAAK,CAAC,SAAS,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC;QACrE,mDAAmD;QACnD,2FAA2F;QAC3F,6EAA6E;QAC7E,mBAAmB,CAAC,WAAW,GAAG,IAAI,CAAC;QACvC,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAU,KAAK,CAAC,UAAe,EAAE,KAAY;QACtD,OAAO,qBAAqB,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,EAAE,6BAA6B,CAAC,CAAC;IAClG,CAAC;CACJ;AAED,IAAI,WAAW,GAAG,KAAK,CAAC;AACxB;;;GAGG;AACH,MAAM,UAAU,qCAAqC;IACjD,IAAI,WAAW,EAAE,CAAC;QACd,OAAO;IACX,CAAC;IACD,WAAW,GAAG,IAAI,CAAC;IAEnB,IAAI,CAAC,oCAAoC,GAAG,6BAA6B,CAAC,KAAK,CAAC;AACpF,CAAC","sourcesContent":["/** This file must only contain pure code and pure imports */\r\n\r\nimport { type Nullable } from \"core/types\";\r\nimport { type Scene } from \"core/scene.pure\";\r\nimport { GaussianSplattingMesh } from \"./gaussianSplattingMesh.pure\";\r\nimport { type GaussianSplattingPartProxyMesh } from \"./gaussianSplattingPartProxyMesh.pure\";\r\nimport { Mesh } from \"../mesh.pure\";\r\n\r\n/**\r\n * Class used to compose multiple Gaussian Splatting meshes into a single draw call,\r\n * with per-part world-matrix and visibility control via addPart/addParts/removePart.\r\n *\r\n * This is the recommended class for multi-part Gaussian Splatting use cases.\r\n *\r\n * Next major version: the compound mesh API (addPart/addParts/removePart) will\r\n * move exclusively to this class and will be removed from GaussianSplattingMesh.\r\n */\r\nexport class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {\r\n    /**\r\n     * Creates a new GaussianSplattingCompoundMesh\r\n     * @param name the name of the mesh\r\n     * @param url optional URL to load a Gaussian Splatting file from\r\n     * @param scene the hosting scene\r\n     * @param keepInRam whether to keep the raw splat data in RAM after uploading to GPU\r\n     * @param needsRotationScaleTextures generate rotation and scale matrix textures required for voxel-based IBL shadows\r\n     */\r\n    constructor(name: string, url: Nullable<string> = null, scene: Nullable<Scene> = null, keepInRam: boolean = false, needsRotationScaleTextures: boolean = false) {\r\n        super(name, url, scene, keepInRam, needsRotationScaleTextures);\r\n    }\r\n\r\n    /**\r\n     * Add another mesh to this compound mesh as a new part.\r\n     * The source mesh's splat data is read directly and copied into the compound's retained source buffers.\r\n     * @param other - The other mesh to add. Must be fully loaded before calling this method.\r\n     * @param disposeOther - Whether to dispose the other mesh after adding it.\r\n     * @returns a placeholder mesh that can be used to manipulate the part transform\r\n     */\r\n    public override addPart(other: GaussianSplattingMesh, disposeOther: boolean = true): GaussianSplattingPartProxyMesh {\r\n        return super.addPart(other, disposeOther);\r\n    }\r\n\r\n    /**\r\n     * Add multiple meshes to this compound mesh as new parts in a single operation.\r\n     * Splat data is written into texture arrays while the compound refreshes its retained merged source buffers.\r\n     * @param others - The meshes to add. Each must be fully loaded and must not be a compound.\r\n     * @param disposeOthers - Whether to dispose the other meshes after adding them.\r\n     * @returns an array of placeholder meshes that can be used to manipulate the part transforms\r\n     */\r\n    public addParts(others: GaussianSplattingMesh[], disposeOthers: boolean = true): GaussianSplattingPartProxyMesh[] {\r\n        if (others.length === 0) {\r\n            return [];\r\n        }\r\n        const { proxyMeshes } = this._addPartsInternal(others, disposeOthers);\r\n        return proxyMeshes;\r\n    }\r\n\r\n    /**\r\n     * Remove a part from this compound mesh.\r\n     * The remaining parts are rebuilt directly from the compound mesh's retained source buffers.\r\n     * @param index - The index of the part to remove\r\n     */\r\n    public override removePart(index: number): void {\r\n        super.removePart(index);\r\n    }\r\n\r\n    /**\r\n     * Serialize current GaussianSplattingMesh\r\n     * @param serializationObject defines the object which will receive the serialization data\r\n     * @param encoding the encoding of binary data, defaults to base64 for json serialize,\r\n     * kept for future internal use like cloning where base64 encoding wastes cycles and memory\r\n     * @returns the serialized object\r\n     */\r\n    public override serialize(serializationObject: any = {}, encoding: string = \"base64\"): any {\r\n        serializationObject = super.serialize(serializationObject, encoding);\r\n        // Note here, the getClassName() is not overridden,\r\n        // as a lot of code currently depend on `getClassName() === \"GaussianSplattingMesh\"` check,\r\n        // to not break those code, serialization uses `_isCompound` to mark the type\r\n        serializationObject._isCompound = true;\r\n        return serializationObject;\r\n    }\r\n\r\n    /**\r\n     * Parses a serialized GaussianSplattingCompoundMesh\r\n     * @param parsedMesh the serialized mesh\r\n     * @param scene the scene to create the GaussianSplattingCompoundMesh in\r\n     * @returns the created GaussianSplattingCompoundMesh\r\n     */\r\n    public static override Parse(parsedMesh: any, scene: Scene): GaussianSplattingCompoundMesh {\r\n        return GaussianSplattingMesh._ParseInternal(parsedMesh, scene, GaussianSplattingCompoundMesh);\r\n    }\r\n}\r\n\r\nlet _Registered = false;\r\n/**\r\n * Register side effects for gaussianSplattingCompoundMesh.\r\n * Safe to call multiple times; only the first call has an effect.\r\n */\r\nexport function RegisterGaussianSplattingCompoundMesh(): void {\r\n    if (_Registered) {\r\n        return;\r\n    }\r\n    _Registered = true;\r\n\r\n    Mesh._GaussianSplattingCompoundMeshParser = GaussianSplattingCompoundMesh.Parse;\r\n}\r\n"]}

package/Meshes/GaussianSplatting/gaussianSplattingMesh.pure.d.ts

@@ -1,12 +1,14 @@
 /** This file must only contain pure code and pure imports */
 import { type Nullable } from "../../types.js";
 import { type Scene } from "../../scene.pure.js";
-import { type Matrix, type Vector2 } from "../../Maths/math.vector.js";
+import { Matrix, Vector3 } from "../../Maths/math.vector.pure.js";
+import { type Vector2 } from "../../Maths/math.vector.js";
 import { type Effect } from "../../Materials/effect.pure.js";
 import { GaussianSplattingMeshBase } from "./gaussianSplattingMeshBase.pure.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.pure.js";
-import { type BoundingInfo } from "../../Culling/boundingInfo.js";
+import { BoundingInfo } from "../../Culling/boundingInfo.js";
 import { type BaseTexture } from "../../Materials/Textures/baseTexture.pure.js";
+import { type AbstractMesh } from "../abstractMesh.pure.js";
 interface IGaussianSplattingPartSource {
     name: string;
     _vertexCount: number;
@@ -29,6 +31,9 @@ export declare class GaussianSplattingMesh extends GaussianSplattingMeshBase {
      * Proxy meshes indexed by part index. Maintained in sync with _partMatrices.
      */
     private _partProxies;
+    /** Part 0 local-space AABB when owned directly (not proxied). Set on first addPart, cleared on dispose/reset. */
+    private _part0LocalMin;
+    private _part0LocalMax;
     /**
      * World matrices for each part, indexed by part index.
      */
@@ -70,6 +75,31 @@ export declare class GaussianSplattingMesh extends GaussianSplattingMeshBase {
      * @returns true when ready
      */
     isReady(completeCheck?: boolean): boolean;
+    /**
+     * Recomputes compound local-space bounds from part 0's stored AABB (if unproxied) plus all
+     * proxy world AABBs inverse-transformed to compound-local space. All 8 corners of each proxy
+     * AABB are transformed so the result is correct under non-identity compound rotation/scale.
+     */
+    private _updateBoundingInfoFromProxies;
+    /**
+     * Override for compound meshes: recomputes bounds from proxy world extents instead of
+     * local bounds × world matrix, which is wrong for proxied parts with independent transforms.
+     * @returns this mesh
+     */
+    _updateBoundingInfo(): AbstractMesh;
+    /**
+     * Replaces the base hierarchy bounds computation for compound meshes: computes world bounds
+     * from scratch by iterating part 0's local AABB and all proxy meshes, rather than delegating
+     * to the base _children traversal which never reaches proxies (they are not parented to the
+     * compound). Visibility per-part is respected; invisible parts are excluded.
+     * @param includeDescendants when true, includes descendants (default: true)
+     * @param predicate optional filter predicate
+     * @returns world-space min/max of the hierarchy bounding box
+     */
+    getHierarchyBoundingVectors(includeDescendants?: boolean, predicate?: Nullable<(abstractMesh: AbstractMesh) => boolean>): {
+        min: Vector3;
+        max: Vector3;
+    };
     /**
      * 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

package/Meshes/GaussianSplatting/gaussianSplattingMesh.pure.js

@@ -1,12 +1,13 @@
 /** This file must only contain pure code and pure imports */
-import { Quaternion, Vector3 } from "../../Maths/math.vector.pure.js";
+import { Matrix, Quaternion, Vector3 } from "../../Maths/math.vector.pure.js";
 import { GetGaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatting/gaussianSplattingMaterial.pure.js";
-import { GaussianSplattingMeshBase } from "./gaussianSplattingMeshBase.pure.js";
+import { GaussianSplattingMeshBase, AllocateShBuffers } from "./gaussianSplattingMeshBase.pure.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
 
 import { DecodeBase64ToBinary, EncodeArrayBufferToBase64 } from "../../Misc/stringTools.js";
 import { Mesh } from "../mesh.pure.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.pure.js";
+import { BoundingInfo } from "../../Culling/boundingInfo.js";
 const _GaussianSplattingBytesPerSplat = 32;
 const _GaussianSplattingBytesPerShTexel = 16;
 /**
@@ -78,6 +79,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
          * Proxy meshes indexed by part index. Maintained in sync with _partMatrices.
          */
         this._partProxies = [];
+        /** Part 0 local-space AABB when owned directly (not proxied). Set on first addPart, cleared on dispose/reset. */
+        this._part0LocalMin = null;
+        this._part0LocalMax = null;
         /**
          * World matrices for each part, indexed by part index.
          */
@@ -123,6 +127,101 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         }
         return super.isReady(completeCheck);
     }
+    /**
+     * Recomputes compound local-space bounds from part 0's stored AABB (if unproxied) plus all
+     * proxy world AABBs inverse-transformed to compound-local space. All 8 corners of each proxy
+     * AABB are transformed so the result is correct under non-identity compound rotation/scale.
+     */
+    _updateBoundingInfoFromProxies() {
+        const compoundWorld = this.getWorldMatrix();
+        const invCompoundWorld = Matrix.Invert(compoundWorld);
+        const localMin = this._part0LocalMin ? this._part0LocalMin.clone() : new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+        const localMax = this._part0LocalMax ? this._part0LocalMax.clone() : new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+        const corner = new Vector3();
+        for (const proxy of this._partProxies) {
+            if (!proxy) {
+                continue;
+            }
+            // Proxies have no geometry — getHierarchyBoundingVectors returns sentinels. Use boundingBox directly.
+            proxy.computeWorldMatrix(false);
+            const bb = proxy.getBoundingInfo().boundingBox;
+            const wMin = bb.minimumWorld;
+            const wMax = bb.maximumWorld;
+            for (let b = 0; b < 8; b++) {
+                corner.set(b & 1 ? wMax.x : wMin.x, b & 2 ? wMax.y : wMin.y, b & 4 ? wMax.z : wMin.z);
+                Vector3.TransformCoordinatesToRef(corner, invCompoundWorld, corner);
+                localMin.minimizeInPlace(corner);
+                localMax.maximizeInPlace(corner);
+            }
+        }
+        if (localMin.x <= localMax.x) {
+            // Direct access avoids getBoundingInfo() → _updateBoundingInfo() recursion.
+            if (this._boundingInfo) {
+                this._boundingInfo.reConstruct(localMin, localMax, compoundWorld);
+            }
+            else {
+                this._boundingInfo = new BoundingInfo(localMin, localMax, compoundWorld);
+            }
+            this._cachedBoundingMin = localMin.clone();
+            this._cachedBoundingMax = localMax.clone();
+        }
+    }
+    /**
+     * Override for compound meshes: recomputes bounds from proxy world extents instead of
+     * local bounds × world matrix, which is wrong for proxied parts with independent transforms.
+     * @returns this mesh
+     */
+    _updateBoundingInfo() {
+        if (this.isCompound) {
+            this._updateBoundingInfoFromProxies();
+            this._updateSubMeshesBoundingInfo(this.worldMatrixFromCache);
+            return this;
+        }
+        return super._updateBoundingInfo();
+    }
+    /**
+     * Replaces the base hierarchy bounds computation for compound meshes: computes world bounds
+     * from scratch by iterating part 0's local AABB and all proxy meshes, rather than delegating
+     * to the base _children traversal which never reaches proxies (they are not parented to the
+     * compound). Visibility per-part is respected; invisible parts are excluded.
+     * @param includeDescendants when true, includes descendants (default: true)
+     * @param predicate optional filter predicate
+     * @returns world-space min/max of the hierarchy bounding box
+     */
+    getHierarchyBoundingVectors(includeDescendants = true, predicate = null) {
+        if (!this.isCompound) {
+            return super.getHierarchyBoundingVectors(includeDescendants, predicate);
+        }
+        // For compound meshes, compute visible-only world bounds from scratch so that
+        // invisible parts don't inflate the result (e.g. for voxelization scene bounds).
+        const min = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
+        const max = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+        // Unproxied part 0: the compound mesh owns this geometry directly (no proxy node).
+        // Transform its local AABB to world space if visible.
+        if (this._part0LocalMin && (this._partVisibility[0] ?? 1.0) > 0) {
+            const wm = this.getWorldMatrix();
+            const lMin = this._part0LocalMin;
+            const lMax = this._part0LocalMax;
+            const corner = new Vector3();
+            for (let b = 0; b < 8; b++) {
+                corner.set(b & 1 ? lMax.x : lMin.x, b & 2 ? lMax.y : lMin.y, b & 4 ? lMax.z : lMin.z);
+                Vector3.TransformCoordinatesToRef(corner, wm, corner);
+                min.minimizeInPlace(corner);
+                max.maximizeInPlace(corner);
+            }
+        }
+        for (let i = 0; i < this._partProxies.length; i++) {
+            const proxy = this._partProxies[i];
+            if (!proxy || (this._partVisibility[i] ?? 1.0) === 0) {
+                continue;
+            }
+            proxy.computeWorldMatrix(false);
+            const bb = proxy.getBoundingInfo().boundingBox;
+            min.minimizeInPlace(bb.minimumWorld);
+            max.maximizeInPlace(bb.maximumWorld);
+        }
+        return { min, max };
+    }
     /**
      * 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
@@ -136,6 +235,8 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         this._partMatrices = [];
         this._partVisibility = [];
         this._partIndicesTexture = null;
+        this._part0LocalMin = null;
+        this._part0LocalMax = null;
         super.dispose(doNotRecurse);
     }
     // ---------------------------------------------------------------------------
@@ -385,7 +486,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             _vertexCount: proxy._vertexCount,
             _splatsData: splatBytes.subarray(splatByteOffset, splatByteOffset + splatByteLength),
             _shData: this._shData?.map((texture) => texture.subarray(shByteOffset, shByteOffset + shByteLength)) ?? null,
-            _shDegree: this._shData?.length ?? 0,
+            _shDegree: this._shData ? this._shDegree : 0,
             isCompound: false,
             getWorldMatrix: () => proxy.getWorldMatrix(),
             getBoundingInfo: () => proxy.getBoundingInfo(),
@@ -417,10 +518,11 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             this._shData = null;
             return;
         }
-        const mergedShData = [];
-        for (let textureIndex = 0; textureIndex < shDegree; textureIndex++) {
-            mergedShData.push(new Uint8Array(totalCount * _GaussianSplattingBytesPerShTexel));
-        }
+        // Each SH texture holds one texel per splat; each texel is _GaussianSplattingBytesPerShTexel
+        // bytes with one byte per scalar, so it carries that many scalars. Degree d has
+        // ((d+1)^2 - 1) higher-order coefficients × 3 RGB = total scalars per splat; divide by texel capacity.
+        const shTextureCount = Math.ceil((((shDegree + 1) * (shDegree + 1) - 1) * 3) / _GaussianSplattingBytesPerShTexel);
+        const mergedShData = AllocateShBuffers(shTextureCount, totalCount * _GaussianSplattingBytesPerShTexel);
         let shByteOffset = 0;
         if (this._shData && existingVertexCount > 0) {
             const existingShByteLength = existingVertexCount * _GaussianSplattingBytesPerShTexel;
@@ -476,16 +578,23 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         const covA = new Uint16Array(textureLength * 4);
         const covB = new Uint16Array(covBSItemSize * textureLength);
         const colorArray = new Uint8Array(textureLength * 4);
-        // Determine merged SH degree
-        const hasSH = (splatCountA === 0 || this._shData !== null) && others.every((o) => o._shData !== null);
+        // Determine merged SH degree.
+        // hasSH is true when the merged result will carry SH:
+        //   - Existing compound already has SH (_shDegree>0): preserve it even if new parts
+        //     have no SH — their texel region is pre-filled with 128 (neutral) by AllocateShBuffers.
+        //   - At least one new part carries SH: enable SH for the whole compound; existing
+        //     parts that had no SH also get neutral fill.
+        // Deliberately excludes the case where the existing compound has no SH and no new part
+        // has SH either (shDegreeNew stays 0, no SH textures allocated).
+        const hasSH = this._shDegree > 0 || others.some((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));
-            }
+            // Each SH texture holds one texel per splat; each texel is _GaussianSplattingBytesPerShTexel
+            // bytes with one byte per scalar, so it carries that many scalars. Degree d has
+            // ((d+1)^2 - 1) higher-order coefficients × 3 RGB = total scalars per splat; divide by texel capacity.
+            const shTextureCount = Math.ceil((((shDegreeNew + 1) * (shDegreeNew + 1) - 1) * 3) / _GaussianSplattingBytesPerShTexel);
+            sh = AllocateShBuffers(shTextureCount, textureLength * _GaussianSplattingBytesPerShTexel);
         }
         // --- Incremental path: can we reuse the already-committed GPU region? ---
         const incremental = this._canReuseCachedData(splatCountA, totalCount);
@@ -559,10 +668,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                                 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);
+                                        sh[texIdx].set(this._shData[texIdx].subarray(0, part0Count * _GaussianSplattingBytesPerShTexel), 0);
                                     }
                                 }
                             }
@@ -597,10 +705,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                             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);
+                                    sh[texIdx].set(this._shData[texIdx].subarray(0, splatCountA * _GaussianSplattingBytesPerShTexel), 0);
                                 }
                             }
                         }
@@ -612,6 +719,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         // 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.
+        // Boundary-row SH is restored after _retainMergedPartData (see below), where _shData is ready.
         if (incremental) {
             const firstNewTexel = firstNewLine * textureSize.x;
             if (firstNewTexel < splatCountA) {
@@ -704,6 +812,39 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         try {
             // --- Upload to GPU ---
             if (incremental) {
+                // Create missing SH GPU textures: either the compound just gained SH for the first
+                // time (_shTextures===null) or the degree increased (sh.length > _shTextures.length).
+                // Use _shData when available (contains correct merged values for all rows);
+                // fall back to sh[idx] (pre-filled with 128) when _shData is absent (keepInRam=false).
+                // _updateSubTextures will re-upload from firstNewLine, which is redundant but harmless.
+                if (sh && (!this._shTextures || sh.length > this._shTextures.length)) {
+                    if (!this._shTextures) {
+                        this._shTextures = [];
+                    }
+                    while (this._shTextures.length < sh.length) {
+                        const idx = this._shTextures.length;
+                        const shTexture = new RawTexture(null, textureSize.x, textureSize.y, 11, this._scene, false, false, 1, 7);
+                        shTexture.wrapU = 0;
+                        shTexture.wrapV = 0;
+                        this._shTextures.push(shTexture);
+                        const src = this._shData && idx < this._shData.length ? this._shData[idx] : sh[idx];
+                        this._updateShTextureData(shTexture, src, textureSize.x, 0, textureSize.y);
+                    }
+                }
+                // Restore boundary-row SH: sh is freshly filled with 128, and _updateSubTextures
+                // starts at firstNewLine — existing splats on that row need their values from _shData.
+                if (sh && this._shData) {
+                    const firstNewTexel = firstNewLine * textureSize.x;
+                    if (firstNewTexel < splatCountA) {
+                        const byteStart = firstNewTexel * _GaussianSplattingBytesPerShTexel;
+                        const byteEnd = splatCountA * _GaussianSplattingBytesPerShTexel;
+                        for (let texIdx = 0; texIdx < sh.length; texIdx++) {
+                            if (texIdx < this._shData.length) {
+                                sh[texIdx].set(this._shData[texIdx].subarray(byteStart, byteEnd), byteStart);
+                            }
+                        }
+                    }
+                }
                 // 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.
@@ -713,11 +854,23 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             else {
                 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();
+            // Bounding info is updated via _updateBoundingInfoFromProxies (called below, after proxy
+            // world matrices are known), which needs part 0's local-space AABB as an input:
+            //   • For unproxied part 0 (legacy layout A: compound loaded its own splat data before
+            //     any addPart call, so no _partProxies[0]), capture the local-space AABB from the
+            //     compound mesh's existing _boundingInfo — set when the mesh loaded its own data via
+            //     URL/updateData — so _updateBoundingInfoFromProxies can include part 0's geometry.
+            //   • For proxied part 0, skip — its bounds are already on the proxy's getBoundingInfo()
+            //     and _updateBoundingInfoFromProxies picks it up there.
+            // Guard splatCountA > 0 avoids reading a stale bounding box on a fresh empty mesh.
+            // Guard !this._part0LocalMin ensures we only store once; subsequent addPart calls must
+            // not overwrite it, because by then _boundingInfo reflects the full merged dataset.
+            if (!this._partProxies[0] && splatCountA > 0 && !this._part0LocalMin) {
+                this._part0LocalMin = this.getBoundingInfo().minimum.clone();
+                this._part0LocalMax = this.getBoundingInfo().maximum.clone();
+            }
             // --- Create proxy meshes ---
             const proxyMeshes = [];
             for (let i = 0; i < others.length; i++) {
@@ -736,6 +889,8 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                 this._partProxies[newPartIndex] = proxyMesh;
                 proxyMeshes.push(proxyMesh);
             }
+            // Update compound bounds now that all proxy world matrices are known.
+            this._updateBoundingInfoFromProxies();
             // Restore the rebuild gate and post the now-complete partMatrices in one message, then trigger a single sort pass.
             // This ensures the worker sees a consistent partMatrices array that matches the partIndices for every splat.
             if (needsWorkerGate) {
@@ -850,6 +1005,8 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         this._partVisibility = [];
         this._cachedBoundingMin = null;
         this._cachedBoundingMax = null;
+        this._part0LocalMin = null;
+        this._part0LocalMax = null;
         this._splatsData = null;
         this._shData = null;
         this._shDegree = 0;
@@ -933,6 +1090,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         }
         if (this._shData) {
             serializationObject.shData = encoding === "base64" ? this._shData.map(EncodeArrayBufferToBase64) : this._shData;
+            serializationObject.shDegree = this._shDegree;
         }
         if (this._partIndices) {
             const compressedIndices = CompressPartIndices(this._partIndices.subarray(0, this._vertexCount));
@@ -984,7 +1142,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         }
         if (splatsData) {
             const flipY = parsedMesh._flipY ?? false;
-            mesh.updateData(splatsData, parsedShData, { flipY }, parsedPartIndices);
+            mesh.updateData(splatsData, parsedShData, { flipY }, parsedPartIndices, parsedMesh.shDegree);
         }
         if (parsedMesh.partProxies) {
             for (const serializedPart of parsedMesh.partProxies) {