@babylonjs/core 7.43.0 → 7.44.0

package/Meshes/Compression/dracoEncoder.types.d.ts

@@ -0,0 +1,82 @@
+import type { Nullable } from "../../types.js";
+/**
+ * The available Draco attribute names.
+ */
+export type DracoAttributeName = "POSITION" | "NORMAL" | "COLOR" | "TEX_COORD" | "GENERIC";
+/**
+ * Draco encoding method (from EncoderMethod enum in `draco_encoder.ts`).
+ */
+export type DracoEncoderMethod = "MESH_SEQUENTIAL_ENCODING" | "MESH_EDGEBREAKER_ENCODING";
+/**
+ * Options for a particular encoding.
+ */
+export interface IDracoEncoderOptions {
+    /**
+     * Tune how fast decoding should be (0 = fastest but least compressed, 10 = slowest but most compressed).
+     */
+    decodeSpeed?: number;
+    /**
+     * Tune how fast encoding should be (0 = fastest but least compressed, 10 = slowest but most compressed).
+     */
+    encodeSpeed?: number;
+    /**
+     * The method to use for encoding the data (EDGEBREAKER or SEQUENTIAL). Defaults to EDGEBREAKER, if possible.
+     */
+    method?: DracoEncoderMethod;
+    /**
+     * The number of bits to use for each DRACO attribute kind.
+     */
+    quantizationBits?: Record<DracoAttributeName, number>;
+    /**
+     * The list of BABYLON attribute kinds to skip exporting, if present. Defaults to none.
+     */
+    excludedAttributes?: string[];
+}
+/**
+ * Encoder parameter carrying Babylon attribute data.
+ * @internal
+ */
+export interface IDracoAttributeData {
+    /**
+     * The Babylon kind of the attribute.
+     */
+    babylonAttribute: string;
+    /**
+     * The Draco kind to use for the attribute.
+     */
+    dracoAttribute: DracoAttributeName;
+    /**
+     * The size of the attribute.
+     */
+    size: number;
+    /**
+     * The buffer view of the attribute.
+     */
+    data: Float32Array;
+}
+/**
+ * Encoded Draco mesh data.
+ * @internal
+ */
+export interface IDracoEncodedMeshData {
+    /**
+     * The encoded data.
+     */
+    data: Int8Array;
+    /**
+     * A map of Babylon vertex attributes to their Draco unique ids in the encoded data.
+     */
+    attributeIDs: Record<string, number>;
+}
+/**
+ * @internal
+ */
+interface EncodeDoneMessage {
+    id: "encodeMeshDone";
+    encodedMeshData: Nullable<IDracoEncodedMeshData>;
+}
+/**
+ * @internal
+ */
+export type EncoderMessage = EncodeDoneMessage;
+export {};

package/Meshes/Compression/dracoEncoder.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dracoEncoder.types.js.map

package/Meshes/Compression/dracoEncoder.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dracoEncoder.types.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/dracoEncoder.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Nullable } from \"core/types\";\n\n/**\n * The available Draco attribute names.\n */\nexport type DracoAttributeName = \"POSITION\" | \"NORMAL\" | \"COLOR\" | \"TEX_COORD\" | \"GENERIC\";\n\n/**\n * Draco encoding method (from EncoderMethod enum in `draco_encoder.ts`).\n */\nexport type DracoEncoderMethod = \"MESH_SEQUENTIAL_ENCODING\" | \"MESH_EDGEBREAKER_ENCODING\";\n\n/**\n * Options for a particular encoding.\n */\nexport interface IDracoEncoderOptions {\n    /**\n     * Tune how fast decoding should be (0 = fastest but least compressed, 10 = slowest but most compressed).\n     */\n    decodeSpeed?: number;\n    /**\n     * Tune how fast encoding should be (0 = fastest but least compressed, 10 = slowest but most compressed).\n     */\n    encodeSpeed?: number;\n    /**\n     * The method to use for encoding the data (EDGEBREAKER or SEQUENTIAL). Defaults to EDGEBREAKER, if possible.\n     */\n    method?: DracoEncoderMethod;\n    /**\n     * The number of bits to use for each DRACO attribute kind.\n     */\n    quantizationBits?: Record<DracoAttributeName, number>;\n    /**\n     * The list of BABYLON attribute kinds to skip exporting, if present. Defaults to none.\n     */\n    excludedAttributes?: string[];\n}\n\n/**\n * Encoder parameter carrying Babylon attribute data.\n * @internal\n */\nexport interface IDracoAttributeData {\n    /**\n     * The Babylon kind of the attribute.\n     */\n    babylonAttribute: string;\n    /**\n     * The Draco kind to use for the attribute.\n     */\n    dracoAttribute: DracoAttributeName;\n    /**\n     * The size of the attribute.\n     */\n    size: number;\n    /**\n     * The buffer view of the attribute.\n     */\n    data: Float32Array;\n}\n\n/**\n * Encoded Draco mesh data.\n * @internal\n */\nexport interface IDracoEncodedMeshData {\n    /**\n     * The encoded data.\n     */\n    data: Int8Array;\n    /**\n     * A map of Babylon vertex attributes to their Draco unique ids in the encoded data.\n     */\n    attributeIDs: Record<string, number>;\n}\n\n/**\n * @internal\n */\ninterface EncodeDoneMessage {\n    id: \"encodeMeshDone\";\n    encodedMeshData: Nullable<IDracoEncodedMeshData>;\n}\n\n/**\n * @internal\n */\nexport type EncoderMessage = EncodeDoneMessage;\n"]}

package/Meshes/Compression/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./dracoCompression";
 export * from "./meshoptCompression";
 export * from "./dracoDecoder";
+export * from "./dracoEncoder";

package/Meshes/Compression/index.js

@@ -1,4 +1,5 @@
 export * from "./dracoCompression.js";
 export * from "./meshoptCompression.js";
 export * from "./dracoDecoder.js";
+export * from "./dracoEncoder.js";
 //# sourceMappingURL=index.js.map

package/Meshes/Compression/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC","sourcesContent":["export * from \"./dracoCompression\";\r\nexport * from \"./meshoptCompression\";\r\nexport * from \"./dracoDecoder\";\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../dev/core/src/Meshes/Compression/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC","sourcesContent":["export * from \"./dracoCompression\";\r\nexport * from \"./meshoptCompression\";\r\nexport * from \"./dracoDecoder\";\r\nexport * from \"./dracoEncoder\";\r\n"]}

package/Meshes/GaussianSplatting/gaussianSplattingMesh.d.ts

@@ -55,7 +55,58 @@ declare enum PLYValue {
     ROT_1 = 31,
     ROT_2 = 32,
     ROT_3 = 33,
-    UNDEFINED = 34
+    MIN_COLOR_R = 34,
+    MIN_COLOR_G = 35,
+    MIN_COLOR_B = 36,
+    MAX_COLOR_R = 37,
+    MAX_COLOR_G = 38,
+    MAX_COLOR_B = 39,
+    SH_0 = 40,
+    SH_1 = 41,
+    SH_2 = 42,
+    SH_3 = 43,
+    SH_4 = 44,
+    SH_5 = 45,
+    SH_6 = 46,
+    SH_7 = 47,
+    SH_8 = 48,
+    SH_9 = 49,
+    SH_10 = 50,
+    SH_11 = 51,
+    SH_12 = 52,
+    SH_13 = 53,
+    SH_14 = 54,
+    SH_15 = 55,
+    SH_16 = 56,
+    SH_17 = 57,
+    SH_18 = 58,
+    SH_19 = 59,
+    SH_20 = 60,
+    SH_21 = 61,
+    SH_22 = 62,
+    SH_23 = 63,
+    SH_24 = 64,
+    SH_25 = 65,
+    SH_26 = 66,
+    SH_27 = 67,
+    SH_28 = 68,
+    SH_29 = 69,
+    SH_30 = 70,
+    SH_31 = 71,
+    SH_32 = 72,
+    SH_33 = 73,
+    SH_34 = 74,
+    SH_35 = 75,
+    SH_36 = 76,
+    SH_37 = 77,
+    SH_38 = 78,
+    SH_39 = 79,
+    SH_40 = 80,
+    SH_41 = 81,
+    SH_42 = 82,
+    SH_43 = 83,
+    SH_44 = 84,
+    UNDEFINED = 85
 }
 /**
  * Property field found in PLY header
@@ -110,6 +161,18 @@ export interface PLYHeader {
      * buffer for the data view
      */
     buffer: ArrayBuffer;
+    /**
+     * degree of SH coefficients
+     */
+    shDegree: number;
+    /**
+     * number of coefficient per splat
+     */
+    shCoefficientCount: number;
+    /**
+     * buffer for SH coefficients
+     */
+    shBuffer: ArrayBuffer | null;
 }
 /**
  * Class used to render a gaussian splatting mesh
@@ -228,12 +291,26 @@ export declare class GaussianSplattingMesh extends Mesh {
     static ParseHeader(data: ArrayBuffer): PLYHeader | null;
     private static _GetCompressedChunks;
     private static _GetSplat;
+    /**
+     * 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
+     */
+    static ConvertPLYWithSHToSplat(data: ArrayBuffer, useCoroutine?: boolean): Generator<undefined, {
+        buffer: ArrayBuffer;
+        sh?: undefined;
+    } | {
+        buffer: ArrayBuffer;
+        sh: Uint8Array<ArrayBuffer>[] | null;
+    }, unknown>;
     /**
      * 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
+     * @returns the loaded splat buffer without SH coefficient, whether ply contains or not SH.
      */
     static ConvertPLYToSplat(data: ArrayBuffer, useCoroutine?: boolean): Generator<undefined, ArrayBuffer, unknown>;
     /**
@@ -243,6 +320,19 @@ export declare class GaussianSplattingMesh extends Mesh {
      * @returns the loaded splat buffer
      */
     static ConvertPLYToSplatAsync(data: ArrayBuffer): Promise<ArrayBuffer>;
+    /**
+     * 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 ConvertPLYWithSHToSplatAsync(data: ArrayBuffer): Promise<{
+        buffer: ArrayBuffer;
+        sh?: undefined;
+    } | {
+        buffer: ArrayBuffer;
+        sh: Uint8Array<ArrayBuffer>[] | null;
+    }>;
     /**
      * Loads a .splat Gaussian Splatting array buffer asynchronously
      * @param data arraybuffer containing splat file

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -11,6 +11,7 @@ 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";
 // @internal
 const unpackUnorm = (value, bits) => {
     const t = (1 << bits) - 1;
@@ -103,7 +104,58 @@ var PLYValue;
     PLYValue[PLYValue["ROT_1"] = 31] = "ROT_1";
     PLYValue[PLYValue["ROT_2"] = 32] = "ROT_2";
     PLYValue[PLYValue["ROT_3"] = 33] = "ROT_3";
-    PLYValue[PLYValue["UNDEFINED"] = 34] = "UNDEFINED";
+    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
@@ -371,8 +423,110 @@ export class GaussianSplattingMesh extends Mesh {
                 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 */;
         }
-        return 34 /* PLYValue.UNDEFINED */;
+        return 85 /* PLYValue.UNDEFINED */;
     }
     /**
      * Parse a PLY file header and returns metas infos on splats and chunks
@@ -415,10 +569,21 @@ export class GaussianSplattingMesh extends Mesh {
         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);
+                // 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 = 2;
+                }
+                else if (value >= 48 /* PLYValue.SH_8 */) {
+                    shDegree = 1;
+                }
                 const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
                 if (chunkMode == 1 /* ElementMode.Chunk */) {
                     chunkProperties.push({ value, type, offset: rowChunkOffset });
@@ -444,6 +609,13 @@ export class GaussianSplattingMesh extends Mesh {
         }
         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,
@@ -453,6 +625,9 @@ export class GaussianSplattingMesh extends Mesh {
             chunkProperties: chunkProperties,
             dataView: dataView,
             buffer: buffer,
+            shDegree: shDegree,
+            shCoefficientCount: shCoefficientCount,
+            shBuffer: shBuffer,
         };
     }
     static _GetCompressedChunks(header, offset) {
@@ -462,7 +637,14 @@ export class GaussianSplattingMesh extends Mesh {
         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() };
+            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];
@@ -511,6 +693,24 @@ export class GaussianSplattingMesh extends Mesh {
                     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;
@@ -527,6 +727,10 @@ export class GaussianSplattingMesh extends Mesh {
         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;
@@ -560,7 +764,7 @@ export class GaussianSplattingMesh extends Mesh {
                         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[1] = Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
                         position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
                     }
                     break;
@@ -568,9 +772,9 @@ export class GaussianSplattingMesh extends Mesh {
                     {
                         unpackRot(value, q);
                         r0 = q.w;
-                        r1 = q.z;
+                        r1 = -q.z;
                         r2 = q.y;
-                        r3 = q.x;
+                        r3 = -q.x;
                     }
                     break;
                 case 14 /* PLYValue.PACKED_SCALE */:
@@ -583,7 +787,13 @@ export class GaussianSplattingMesh extends Mesh {
                     }
                     break;
                 case 15 /* PLYValue.PACKED_COLOR */:
-                    unpack8888(value, rgba);
+                    {
+                        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;
@@ -640,6 +850,11 @@ export class GaussianSplattingMesh extends Mesh {
                     r3 = value;
                     break;
             }
+            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
+                const clampedValue = Scalar.Clamp(value * 127.5 + 127.5, 0, 255);
+                const shIndex = property.value - 40 /* PLYValue.SH_0 */;
+                sh[shIndex] = clampedValue;
+            }
         }
         q.set(r1, r2, r3, r0);
         q.normalize();
@@ -649,12 +864,64 @@ export class GaussianSplattingMesh extends Mesh {
         rot[3] = q.z * 128 + 128;
         offset.value += header.rowVertexLength;
     }
+    /**
+     * 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
+     */
+    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 };
+    }
     /**
      * 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
+     * @returns the loaded splat buffer without SH coefficient, whether ply contains or not SH.
      */
     static *ConvertPLYToSplat(data, useCoroutine = false) {
         const header = GaussianSplattingMesh.ParseHeader(data);
@@ -680,6 +947,15 @@ export class GaussianSplattingMesh extends Mesh {
     static async ConvertPLYToSplatAsync(data) {
         return 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 runCoroutineAsync(GaussianSplattingMesh.ConvertPLYWithSHToSplat(data, true), createYieldingScheduler());
+    }
     /**
      * Loads a .splat Gaussian Splatting array buffer asynchronously
      * @param data arraybuffer containing splat file
@@ -696,8 +972,8 @@ export class GaussianSplattingMesh extends Mesh {
      */
     loadFileAsync(url) {
         return Tools.LoadFileAsync(url, true).then(async (plyBuffer) => {
-            GaussianSplattingMesh.ConvertPLYToSplatAsync(plyBuffer).then((splatsData) => {
-                this.updateDataAsync(splatsData);
+            GaussianSplattingMesh.ConvertPLYWithSHToSplatAsync(plyBuffer).then((splatsData) => {
+                this.updateDataAsync(splatsData.buffer, splatsData.sh);
             });
         });
     }