@babylonjs/viewer 7.29.0 → 7.30.0-alpha

package/dist/chunks/splatFileLoader-D53T0YTp.esm.js

@@ -0,0 +1,3534 @@
+import { i as ShaderStore, R as RegisterClass, x as PushMaterial, y as PrepareDefinesForMisc, z as PrepareDefinesForFrameBoundValues, H as PrepareDefinesForAttributes, J as PrepareAttributesForInstances, K as PrepareUniformsAndSamplersList, N as addClipPlaneUniforms, Q as Camera, W as bindClipPlane, X as BindFogParameters, Y as BindLogDepth, Z as SerializationHelper, _ as MaterialDefines, V as VertexBuffer, M as Mesh, $ as Matrix, t as Vector3, v as VertexData, a0 as SubMesh, a1 as TmpVectors, L as Logger, T as Tools, s as Vector2, a2 as Quaternion, C as Constants, k as Color4, a3 as BuildArray, a4 as Epsilon, a5 as IntersectionInfo, E as EngineStore, a6 as PickingInfo, a7 as _ImportHelper, a8 as Scene, p as Color3, a9 as Vector4, aa as RandomRange, B as BaseTexture, ab as functions, ac as HighestCommonFactor, ad as SPLATFileLoaderMetadata, w as registerSceneLoaderPlugin } from './index-DzE-qoIA.esm.js';
+import './fogFragment-n-fnZX94.esm.js';
+import './logDepthDeclaration-B-8DXc3B.esm.js';
+import './logDepthVertex-CtgMxuTW.esm.js';
+import { R as RawTexture } from './rawTexture-zvoEayWf.esm.js';
+import './thinInstanceMesh-CNjlSPEU.esm.js';
+import { A as AssetContainer } from './assetContainer-BrmmAQqf.esm.js';
+import { S as StandardMaterial } from './standardMaterial-Dvhii-7v.esm.js';
+
+// Do not edit.
+const name$3 = "gaussianSplattingPixelShader";
+const shader$3 = `#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+varying vec4 vColor;varying vec2 vPosition;void main () { 
+#include<clipPlaneFragment>
+float A=-dot(vPosition,vPosition);if (A<-4.0) discard;float B=exp(A)*vColor.a;
+#include<logDepthFragment>
+vec3 color=vColor.rgb;
+#ifdef FOG
+#include<fogFragment>
+#endif
+gl_FragColor=vec4(color,B);}
+`;
+// Sideeffect
+ShaderStore.ShadersStore[name$3] = shader$3;
+
+// Do not edit.
+const name$2 = "gaussianSplattingVertexDeclaration";
+const shader$2 = `uniform mat4 world;uniform mat4 view;uniform mat4 projection;
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$2] = shader$2;
+
+// Do not edit.
+const name$1 = "gaussianSplattingUboDeclaration";
+const shader$1 = `#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;
+// Sideeffect
+ShaderStore.IncludesShadersStore[name$1] = shader$1;
+
+// Do not edit.
+const name = "gaussianSplattingVertexShader";
+const shader = `#include<__decl__gaussianSplattingVertex>
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<logDepthDeclaration>
+attribute vec2 position;attribute float splatIndex;uniform vec2 invViewport;uniform vec2 dataTextureSize;uniform vec2 focal;uniform sampler2D covariancesATexture;uniform sampler2D covariancesBTexture;uniform sampler2D centersTexture;uniform sampler2D colorsTexture;varying vec4 vColor;varying vec2 vPosition;
+#if !defined(WEBGL2) && !defined(WEBGPU) && !defined(NATIVE)
+mat3 transpose(mat3 matrix) {return mat3(matrix[0][0],matrix[1][0],matrix[2][0],
+matrix[0][1],matrix[1][1],matrix[2][1],
+matrix[0][2],matrix[1][2],matrix[2][2]);}
+#endif
+vec2 getDataUV(float index,vec2 textureSize) {float y=floor(index/textureSize.x);float x=index-y*textureSize.x;return vec2((x+0.5)/textureSize.x,(y+0.5)/textureSize.y);}
+void main () {vec2 splatUV=getDataUV(splatIndex,dataTextureSize);vec3 center=texture2D(centersTexture,splatUV).xyz;vec4 color=texture2D(colorsTexture,splatUV);vec3 covA=texture2D(covariancesATexture,splatUV).xyz;vec3 covB=texture2D(covariancesBTexture,splatUV).xyz;vec4 worldPos=world*vec4(center,1.0);mat4 modelView=view*world;vec4 camspace=view*worldPos;vec4 pos2d=projection*camspace;float bounds=1.2*pos2d.w;if (pos2d.z<-pos2d.w || pos2d.x<-bounds || pos2d.x>bounds
+|| pos2d.y<-bounds || pos2d.y>bounds) {gl_Position=vec4(0.0,0.0,2.0,1.0);return;}
+mat3 Vrk=mat3(
+covA.x,covA.y,covA.z,
+covA.y,covB.x,covB.y,
+covA.z,covB.y,covB.z
+);mat3 J=mat3(
+focal.x/camspace.z,0.,-(focal.x*camspace.x)/(camspace.z*camspace.z),
+0.,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
+0.,0.,0.
+);mat3 invy=mat3(1,0,0,0,-1,0,0,0,1);mat3 T=invy*transpose(mat3(modelView))*J;mat3 cov2d=transpose(T)*Vrk*T;float mid=(cov2d[0][0]+cov2d[1][1])/2.0;float radius=length(vec2((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));float lambda1=mid+radius,lambda2=mid-radius;if (lambda2<0.0) return;vec2 diagonalVector=normalize(vec2(cov2d[0][1],lambda1-cov2d[0][0]));vec2 majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;vec2 minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2(diagonalVector.y,-diagonalVector.x);vColor=color;vPosition=position;vec2 vCenter=vec2(pos2d);gl_Position=vec4(
+vCenter 
++ (position.x*majorAxis
++ position.y*minorAxis)*invViewport*pos2d.w,pos2d.zw);
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<logDepthVertex>
+}
+`;
+// Sideeffect
+ShaderStore.ShadersStore[name] = shader;
+
+/**
+ * @internal
+ */
+class GaussianSplattingMaterialDefines extends MaterialDefines {
+    /**
+     * Constructor of the defines.
+     */
+    constructor() {
+        super();
+        this.FOG = false;
+        this.THIN_INSTANCES = true;
+        this.LOGARITHMICDEPTH = false;
+        this.CLIPPLANE = false;
+        this.CLIPPLANE2 = false;
+        this.CLIPPLANE3 = false;
+        this.CLIPPLANE4 = false;
+        this.CLIPPLANE5 = false;
+        this.CLIPPLANE6 = false;
+        this.rebuild();
+    }
+}
+/**
+ * GaussianSplattingMaterial material used to render Gaussian Splatting
+ * @experimental
+ */
+class GaussianSplattingMaterial extends PushMaterial {
+    /**
+     * Instantiates a Gaussian Splatting Material in the given scene
+     * @param name The friendly name of the material
+     * @param scene The scene to add the material to
+     */
+    constructor(name, scene) {
+        super(name, scene);
+        this.backFaceCulling = false;
+    }
+    /**
+     * Gets a boolean indicating that current material needs to register RTT
+     */
+    get hasRenderTargetTextures() {
+        return false;
+    }
+    /**
+     * Specifies whether or not this material should be rendered in alpha test mode.
+     * @returns false
+     */
+    needAlphaTesting() {
+        return false;
+    }
+    /**
+     * Specifies whether or not this material should be rendered in alpha blend mode.
+     * @returns true
+     */
+    needAlphaBlending() {
+        return true;
+    }
+    /**
+     * Checks whether the material is ready to be rendered for a given mesh.
+     * @param mesh The mesh to render
+     * @param subMesh The submesh to check against
+     * @returns true if all the dependencies are ready (Textures, Effects...)
+     */
+    isReadyForSubMesh(mesh, subMesh) {
+        const useInstances = true;
+        const drawWrapper = subMesh._drawWrapper;
+        if (drawWrapper.effect && this.isFrozen) {
+            if (drawWrapper._wasPreviouslyReady && drawWrapper._wasPreviouslyUsingInstances === useInstances) {
+                return true;
+            }
+        }
+        if (!subMesh.materialDefines) {
+            subMesh.materialDefines = new GaussianSplattingMaterialDefines();
+        }
+        const scene = this.getScene();
+        const defines = subMesh.materialDefines;
+        if (this._isReadyForSubMesh(subMesh)) {
+            return true;
+        }
+        const engine = scene.getEngine();
+        // Misc.
+        PrepareDefinesForMisc(mesh, scene, this._useLogarithmicDepth, this.pointsCloud, this.fogEnabled, false, defines);
+        // Values that need to be evaluated on every frame
+        PrepareDefinesForFrameBoundValues(scene, engine, this, defines, useInstances, null, true);
+        // Attribs
+        PrepareDefinesForAttributes(mesh, defines, false, false);
+        // Get correct effect
+        if (defines.isDirty) {
+            defines.markAsProcessed();
+            scene.resetCachedMaterial();
+            //Attributes
+            const attribs = [VertexBuffer.PositionKind, "splatIndex"];
+            PrepareAttributesForInstances(attribs, defines);
+            const uniforms = ["world", "view", "projection", "vFogInfos", "vFogColor", "logarithmicDepthConstant", "invViewport", "dataTextureSize", "focal"];
+            const samplers = ["covariancesATexture", "covariancesBTexture", "centersTexture", "colorsTexture"];
+            const uniformBuffers = ["Scene", "Mesh"];
+            PrepareUniformsAndSamplersList({
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
+                defines: defines,
+            });
+            addClipPlaneUniforms(uniforms);
+            const join = defines.toString();
+            const effect = scene.getEngine().createEffect("gaussianSplatting", {
+                attributes: attribs,
+                uniformsNames: uniforms,
+                uniformBuffersNames: uniformBuffers,
+                samplers: samplers,
+                defines: join,
+                onCompiled: this.onCompiled,
+                onError: this.onError,
+            }, engine);
+            subMesh.setEffect(effect, defines, this._materialContext);
+        }
+        if (!subMesh.effect || !subMesh.effect.isReady()) {
+            return false;
+        }
+        defines._renderId = scene.getRenderId();
+        drawWrapper._wasPreviouslyReady = true;
+        drawWrapper._wasPreviouslyUsingInstances = useInstances;
+        return true;
+    }
+    /**
+     * Binds the submesh to this material by preparing the effect and shader to draw
+     * @param world defines the world transformation matrix
+     * @param mesh defines the mesh containing the submesh
+     * @param subMesh defines the submesh to bind the material to
+     */
+    bindForSubMesh(world, mesh, subMesh) {
+        const scene = this.getScene();
+        const defines = subMesh.materialDefines;
+        if (!defines) {
+            return;
+        }
+        const effect = subMesh.effect;
+        if (!effect) {
+            return;
+        }
+        this._activeEffect = effect;
+        // Matrices Mesh.
+        mesh.getMeshUniformBuffer().bindToEffect(effect, "Mesh");
+        mesh.transferToEffect(world);
+        // Bind data
+        const mustRebind = this._mustRebind(scene, effect, subMesh, mesh.visibility);
+        if (mustRebind) {
+            this.bindView(effect);
+            this.bindViewProjection(effect);
+            const engine = scene.getEngine();
+            const camera = this.getScene().activeCamera;
+            const renderWidth = engine.getRenderWidth();
+            const renderHeight = engine.getRenderHeight();
+            // check if rigcamera, get number of rigs
+            const numberOfRigs = camera?.rigParent?.rigCameras.length || 1;
+            this._activeEffect.setFloat2("invViewport", 1 / (renderWidth / numberOfRigs), 1 / renderHeight);
+            let focal = 1000;
+            if (camera) {
+                /*
+                more explicit version:
+                const t = camera.getProjectionMatrix().m[5];
+                const FovY = Math.atan(1.0 / t) * 2.0;
+                focal = renderHeight / 2.0 / Math.tan(FovY / 2.0);
+                Using a shorter version here to not have tan(atan) and 2.0 factor
+                */
+                const t = camera.getProjectionMatrix().m[5];
+                if (camera.fovMode == Camera.FOVMODE_VERTICAL_FIXED) {
+                    focal = (renderHeight * t) / 2.0;
+                }
+                else {
+                    focal = (renderWidth * t) / 2.0;
+                }
+            }
+            this._activeEffect.setFloat2("focal", focal, focal);
+            const gsMesh = mesh;
+            if (gsMesh.covariancesATexture) {
+                const textureSize = gsMesh.covariancesATexture.getSize();
+                effect.setFloat2("dataTextureSize", textureSize.width, textureSize.height);
+                effect.setTexture("covariancesATexture", gsMesh.covariancesATexture);
+                effect.setTexture("covariancesBTexture", gsMesh.covariancesBTexture);
+                effect.setTexture("centersTexture", gsMesh.centersTexture);
+                effect.setTexture("colorsTexture", gsMesh.colorsTexture);
+            }
+            // Clip plane
+            bindClipPlane(effect, this, scene);
+        }
+        else if (scene.getEngine()._features.needToAlwaysBindUniformBuffers) {
+            this._needToBindSceneUbo = true;
+        }
+        // Fog
+        BindFogParameters(scene, mesh, effect);
+        // Log. depth
+        if (this.useLogarithmicDepth) {
+            BindLogDepth(defines, effect, scene);
+        }
+        this._afterBind(mesh, this._activeEffect, subMesh);
+    }
+    /**
+     * Clones the material.
+     * @param name The cloned name.
+     * @returns The cloned material.
+     */
+    clone(name) {
+        return SerializationHelper.Clone(() => new GaussianSplattingMaterial(name, this.getScene()), this);
+    }
+    /**
+     * Serializes the current material to its JSON representation.
+     * @returns The JSON representation.
+     */
+    serialize() {
+        const serializationObject = super.serialize();
+        serializationObject.customType = "BABYLON.GaussianSplattingMaterial";
+        return serializationObject;
+    }
+    /**
+     * Gets the class name of the material
+     * @returns "GaussianSplattingMaterial"
+     */
+    getClassName() {
+        return "GaussianSplattingMaterial";
+    }
+    /**
+     * Parse a JSON input to create back a Gaussian Splatting material.
+     * @param source The JSON data to parse
+     * @param scene The scene to create the parsed material in
+     * @param rootUrl The root url of the assets the material depends upon
+     * @returns the instantiated GaussianSplattingMaterial.
+     */
+    static Parse(source, scene, rootUrl) {
+        return SerializationHelper.Parse(() => new GaussianSplattingMaterial(source.name, scene), source, scene, rootUrl);
+    }
+}
+RegisterClass("BABYLON.GaussianSplattingMaterial", GaussianSplattingMaterial);
+
+/**
+ * Class used to render a gaussian splatting mesh
+ */
+class GaussianSplattingMesh extends Mesh {
+    /**
+     * 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;
+    }
+    /**
+     * 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._frameIdLastUpdate = -1;
+        this._modelViewMatrix = 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;
+        //@ts-expect-error
+        this._covariancesA = null;
+        //@ts-expect-error
+        this._covariancesB = null;
+        //@ts-expect-error
+        this._colors = null;
+        this._keepInRam = false;
+        this._delayedTextureUpdate = null;
+        this._oldDirection = new Vector3();
+        const vertexData = new VertexData();
+        vertexData.positions = [-2, -2, 0, 2, -2, 0, 2, 2, 0, -2, 2, 0];
+        vertexData.indices = [0, 1, 2, 0, 2, 3];
+        vertexData.applyToMesh(this);
+        this.subMeshes = [];
+        new SubMesh(0, 0, 4, 0, 6, this);
+        this.setEnabled(false);
+        this._keepInRam = keepInRam;
+        if (url) {
+            this.loadFileAsync(url);
+        }
+        this.material = new GaussianSplattingMaterial(this.name + "_material", this._scene);
+    }
+    /**
+     * Returns the class name
+     * @returns "GaussianSplattingMesh"
+     */
+    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;
+    }
+    _postToWorker(forced = false) {
+        const frameId = this.getScene().getFrameId();
+        if (frameId !== this._frameIdLastUpdate && this._worker && this._scene.activeCamera && this._canPostToWorker) {
+            const cameraMatrix = this._scene.activeCamera.getViewMatrix();
+            this.getWorldMatrix().multiplyToRef(cameraMatrix, this._modelViewMatrix);
+            cameraMatrix.invertToRef(TmpVectors.Matrix[0]);
+            this.getWorldMatrix().multiplyToRef(TmpVectors.Matrix[0], TmpVectors.Matrix[1]);
+            Vector3.TransformNormalToRef(Vector3.Forward(this._scene.useRightHandedSystem), TmpVectors.Matrix[1], TmpVectors.Vector3[2]);
+            TmpVectors.Vector3[2].normalize();
+            const dot = Vector3.Dot(TmpVectors.Vector3[2], this._oldDirection);
+            if (forced || Math.abs(dot - 1) >= 0.01) {
+                this._oldDirection.copyFrom(TmpVectors.Vector3[2]);
+                this._frameIdLastUpdate = frameId;
+                this._canPostToWorker = false;
+                this._worker.postMessage({ view: this._modelViewMatrix.m, depthMix: this._depthMix, useRightHandedSystem: this._scene.useRightHandedSystem }, [
+                    this._depthMix.buffer,
+                ]);
+            }
+        }
+    }
+    /**
+     * 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
+     */
+    render(subMesh, enableAlphaMode, effectiveMeshReplacement) {
+        this._postToWorker();
+        return super.render(subMesh, enableAlphaMode, effectiveMeshReplacement);
+    }
+    /**
+     * Code from https://github.com/dylanebert/gsplat.js/blob/main/src/loaders/PLYLoader.ts Under MIT license
+     * 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
+     * @deprecated Please use SceneLoader.ImportMeshAsync instead
+     */
+    static ConvertPLYToSplat(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) {
+            return data;
+        }
+        const vertexCount = parseInt(/element vertex (\d+)\n/.exec(header)[1]);
+        let rowOffset = 0;
+        const offsets = {
+            double: 8,
+            int: 4,
+            uint: 4,
+            float: 4,
+            short: 2,
+            ushort: 2,
+            uchar: 1,
+        };
+        const properties = [];
+        const filtered = header
+            .slice(0, headerEndIndex)
+            .split("\n")
+            .filter((k) => k.startsWith("property "));
+        for (const prop of filtered) {
+            const [, type, name] = prop.split(" ");
+            properties.push({ name, type, offset: rowOffset });
+            if (offsets[type]) {
+                rowOffset += offsets[type];
+            }
+            else {
+                Logger.Error(`Unsupported property type: ${type}. Are you sure it's a valid Gaussian Splatting file?`);
+                return new ArrayBuffer(0);
+            }
+        }
+        const rowLength = 3 * 4 + 3 * 4 + 4 + 4;
+        const SH_C0 = 0.28209479177387814;
+        const dataView = new DataView(data, headerEndIndex + headerEnd.length);
+        const buffer = new ArrayBuffer(rowLength * vertexCount);
+        const q = new Quaternion();
+        for (let i = 0; i < vertexCount; i++) {
+            const position = new Float32Array(buffer, i * rowLength, 3);
+            const scale = new Float32Array(buffer, i * rowLength + 12, 3);
+            const rgba = new Uint8ClampedArray(buffer, i * rowLength + 24, 4);
+            const rot = new Uint8ClampedArray(buffer, i * rowLength + 28, 4);
+            let r0 = 255;
+            let r1 = 0;
+            let r2 = 0;
+            let r3 = 0;
+            for (let propertyIndex = 0; propertyIndex < properties.length; propertyIndex++) {
+                const property = properties[propertyIndex];
+                let value;
+                switch (property.type) {
+                    case "float":
+                        value = dataView.getFloat32(property.offset + i * rowOffset, true);
+                        break;
+                    case "int":
+                        value = dataView.getInt32(property.offset + i * rowOffset, true);
+                        break;
+                    default:
+                        throw new Error(`Unsupported property type: ${property.type}`);
+                }
+                switch (property.name) {
+                    case "x":
+                        position[0] = value;
+                        break;
+                    case "y":
+                        position[1] = value;
+                        break;
+                    case "z":
+                        position[2] = value;
+                        break;
+                    case "scale_0":
+                        scale[0] = Math.exp(value);
+                        break;
+                    case "scale_1":
+                        scale[1] = Math.exp(value);
+                        break;
+                    case "scale_2":
+                        scale[2] = Math.exp(value);
+                        break;
+                    case "red":
+                        rgba[0] = value;
+                        break;
+                    case "green":
+                        rgba[1] = value;
+                        break;
+                    case "blue":
+                        rgba[2] = value;
+                        break;
+                    case "f_dc_0":
+                        rgba[0] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_1":
+                        rgba[1] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_2":
+                        rgba[2] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_3":
+                        rgba[3] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "opacity":
+                        rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
+                        break;
+                    case "rot_0":
+                        r0 = value;
+                        break;
+                    case "rot_1":
+                        r1 = value;
+                        break;
+                    case "rot_2":
+                        r2 = value;
+                        break;
+                    case "rot_3":
+                        r3 = value;
+                        break;
+                }
+            }
+            q.set(r1, r2, r3, r0);
+            q.normalize();
+            rot[0] = q.w * 128 + 128;
+            rot[1] = q.x * 128 + 128;
+            rot[2] = q.y * 128 + 128;
+            rot[3] = q.z * 128 + 128;
+        }
+        return buffer;
+    }
+    /**
+     * Loads a .splat Gaussian Splatting array buffer asynchronously
+     * @param data arraybuffer containing splat file
+     * @returns a promise that resolves when the operation is complete
+     */
+    loadDataAsync(data) {
+        return Promise.resolve(this._loadData(data));
+    }
+    /**
+     * Loads a .splat Gaussian or .ply Splatting file asynchronously
+     * @param url path to the splat file to load
+     * @returns a promise that resolves when the operation is complete
+     * @deprecated Please use SceneLoader.ImportMeshAsync instead
+     */
+    loadFileAsync(url) {
+        return Tools.LoadFileAsync(url, true).then((data) => {
+            this._loadData(GaussianSplattingMesh.ConvertPLYToSplat(data));
+        });
+    }
+    /**
+     * Releases resources associated with this mesh.
+     * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+     */
+    dispose(doNotRecurse) {
+        this._covariancesATexture?.dispose();
+        this._covariancesBTexture?.dispose();
+        this._centersTexture?.dispose();
+        this._colorsTexture?.dispose();
+        this._covariancesATexture = null;
+        this._covariancesBTexture = null;
+        this._centersTexture = null;
+        this._colorsTexture = null;
+        this._worker?.terminate();
+        this._worker = null;
+        super.dispose(doNotRecurse, true);
+    }
+    _copyTextures(source) {
+        this._covariancesATexture = source.covariancesATexture?.clone();
+        this._covariancesBTexture = source.covariancesBTexture?.clone();
+        this._centersTexture = source.centersTexture?.clone();
+        this._colorsTexture = source.colorsTexture?.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._modelViewMatrix = Matrix.Identity();
+        newGS._splatPositions = this._splatPositions;
+        newGS._readyToDisplay = false;
+        newGS._instanciateWorker();
+        const binfo = this.getBoundingInfo();
+        newGS.getBoundingInfo().reConstruct(binfo.minimum, binfo.maximum, this.getWorldMatrix());
+        newGS.forcedInstanceCount = newGS._vertexCount;
+        newGS.setEnabled(true);
+        return newGS;
+    }
+    /**
+     * @experimental
+     * Update data from GS (position, orientation, color, scaling)
+     * @param data array that contain all the datas
+     */
+    updateData(data) {
+        if (!data.byteLength) {
+            return;
+        }
+        // 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);
+        const rowLength = 3 * 4 + 3 * 4 + 4 + 4;
+        const vertexCount = uBuffer.length / rowLength;
+        if (vertexCount != this._vertexCount) {
+            this._updateSplatIndexBuffer(vertexCount);
+        }
+        this._vertexCount = vertexCount;
+        const textureSize = this._getTextureSize(vertexCount);
+        const textureLength = textureSize.x * textureSize.y;
+        this._splatPositions = new Float32Array(3 * textureLength);
+        const covA = new Float32Array(3 * textureLength);
+        const covB = new Float32Array(3 * textureLength);
+        const matrixRotation = TmpVectors.Matrix[0];
+        const matrixScale = TmpVectors.Matrix[1];
+        const quaternion = TmpVectors.Quaternion[0];
+        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);
+        for (let i = 0; i < vertexCount; i++) {
+            const x = fBuffer[8 * i + 0];
+            const y = -fBuffer[8 * i + 1];
+            const z = fBuffer[8 * i + 2];
+            this._splatPositions[3 * i + 0] = x;
+            this._splatPositions[3 * i + 1] = y;
+            this._splatPositions[3 * i + 2] = z;
+            minimum.minimizeInPlaceFromFloats(x, y, z);
+            maximum.maximizeInPlaceFromFloats(x, y, z);
+            quaternion.set((uBuffer[32 * i + 28 + 1] - 128) / 128, (uBuffer[32 * i + 28 + 2] - 128) / 128, (uBuffer[32 * i + 28 + 3] - 128) / 128, -(uBuffer[32 * i + 28 + 0] - 128) / 128);
+            quaternion.toRotationMatrix(matrixRotation);
+            Matrix.ScalingToRef(fBuffer[8 * i + 3 + 0] * 2, fBuffer[8 * i + 3 + 1] * 2, fBuffer[8 * i + 3 + 2] * 2, matrixScale);
+            const M = matrixRotation.multiplyToRef(matrixScale, TmpVectors.Matrix[0]).m;
+            covA[i * 3 + 0] = M[0] * M[0] + M[1] * M[1] + M[2] * M[2];
+            covA[i * 3 + 1] = M[0] * M[4] + M[1] * M[5] + M[2] * M[6];
+            covA[i * 3 + 2] = M[0] * M[8] + M[1] * M[9] + M[2] * M[10];
+            covB[i * 3 + 0] = M[4] * M[4] + M[5] * M[5] + M[6] * M[6];
+            covB[i * 3 + 1] = M[4] * M[8] + M[5] * M[9] + M[6] * M[10];
+            covB[i * 3 + 2] = M[8] * M[8] + M[9] * M[9] + M[10] * M[10];
+        }
+        // Update the mesh
+        const binfo = this.getBoundingInfo();
+        binfo.reConstruct(minimum, maximum, this.getWorldMatrix());
+        this.setEnabled(true);
+        // Update the material
+        const createTextureFromData = (data, width, height, format) => {
+            return new RawTexture(data, width, height, format, this._scene, false, false, Constants.TEXTURE_BILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_FLOAT);
+        };
+        const convertRgbToRgba = (rgb) => {
+            const count = rgb.length / 3;
+            const rgba = new Float32Array(count * 4);
+            for (let i = 0; i < count; ++i) {
+                rgba[i * 4 + 0] = rgb[i * 3 + 0];
+                rgba[i * 4 + 1] = rgb[i * 3 + 1];
+                rgba[i * 4 + 2] = rgb[i * 3 + 2];
+                rgba[i * 4 + 3] = 1.0;
+            }
+            return rgba;
+        };
+        const colorArray = new Float32Array(textureSize.x * textureSize.y * 4);
+        for (let i = 0; i < this._vertexCount; ++i) {
+            colorArray[i * 4 + 0] = uBuffer[32 * i + 24 + 0] / 255;
+            colorArray[i * 4 + 1] = uBuffer[32 * i + 24 + 1] / 255;
+            colorArray[i * 4 + 2] = uBuffer[32 * i + 24 + 2] / 255;
+            colorArray[i * 4 + 3] = uBuffer[32 * i + 24 + 3] / 255;
+        }
+        if (this._keepInRam) {
+            this._covariancesA = covA;
+            this._covariancesB = covB;
+            this._colors = colorArray;
+        }
+        if (this._covariancesATexture) {
+            this._delayedTextureUpdate = { covA: convertRgbToRgba(covA), covB: convertRgbToRgba(covB), colors: colorArray, centers: convertRgbToRgba(this._splatPositions) };
+            const positions = Float32Array.from(this._splatPositions);
+            const vertexCount = this._vertexCount;
+            this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+            this._postToWorker(true);
+        }
+        else {
+            this._covariancesATexture = createTextureFromData(convertRgbToRgba(covA), textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
+            this._covariancesBTexture = createTextureFromData(convertRgbToRgba(covB), textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
+            this._centersTexture = createTextureFromData(convertRgbToRgba(this._splatPositions), textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
+            this._colorsTexture = createTextureFromData(colorArray, textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
+            this._instanciateWorker();
+        }
+    }
+    _loadData(data) {
+        if (!data.byteLength) {
+            return;
+        }
+        this.updateData(data);
+    }
+    // in case size is different
+    _updateSplatIndexBuffer(vertexCount) {
+        if (!this._splatIndex || vertexCount > this._splatIndex.length) {
+            this._splatIndex = new Float32Array(vertexCount);
+            this.thinInstanceSetBuffer("splatIndex", this._splatIndex, 1, false);
+        }
+        this.forcedInstanceCount = vertexCount;
+    }
+    _instanciateWorker() {
+        if (!this._vertexCount) {
+            return;
+        }
+        this._updateSplatIndexBuffer(this._vertexCount);
+        // Start the worker thread
+        this._worker?.terminate();
+        this._worker = new Worker(URL.createObjectURL(new Blob(["(", GaussianSplattingMesh._CreateWorker.toString(), ")(self)"], {
+            type: "application/javascript",
+        })));
+        this._depthMix = new BigInt64Array(this._vertexCount);
+        const positions = Float32Array.from(this._splatPositions);
+        const vertexCount = this._vertexCount;
+        this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+        this._worker.onmessage = (e) => {
+            this._depthMix = e.data.depthMix;
+            const indexMix = new Uint32Array(e.data.depthMix.buffer);
+            if (this._splatIndex) {
+                for (let j = 0; j < this._vertexCount; j++) {
+                    this._splatIndex[j] = indexMix[2 * j];
+                }
+            }
+            if (this._delayedTextureUpdate) {
+                const updateTextureFromData = (texture, data, width, height) => {
+                    this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, 0, width, height, 0, 0, false);
+                };
+                const textureSize = this._getTextureSize(vertexCount);
+                updateTextureFromData(this._covariancesATexture, this._delayedTextureUpdate.covA, textureSize.x, textureSize.y);
+                updateTextureFromData(this._covariancesBTexture, this._delayedTextureUpdate.covB, textureSize.x, textureSize.y);
+                updateTextureFromData(this._centersTexture, this._delayedTextureUpdate.centers, textureSize.x, textureSize.y);
+                updateTextureFromData(this._colorsTexture, this._delayedTextureUpdate.colors, textureSize.x, textureSize.y);
+                this._delayedTextureUpdate = null;
+            }
+            this.thinInstanceBufferUpdated("splatIndex");
+            this._canPostToWorker = true;
+            this._readyToDisplay = true;
+        };
+    }
+    _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);
+    }
+}
+GaussianSplattingMesh._CreateWorker = function (self) {
+    let vertexCount = 0;
+    let positions;
+    let depthMix;
+    let indices;
+    let floatMix;
+    self.onmessage = (e) => {
+        // updated on init
+        if (e.data.positions) {
+            positions = e.data.positions;
+            vertexCount = e.data.vertexCount;
+        }
+        // udpate on view changed
+        else {
+            const viewProj = e.data.view;
+            if (!positions || !viewProj) {
+                // Sanity check, it shouldn't happen!
+                throw new Error("positions or view is not defined!");
+            }
+            depthMix = e.data.depthMix;
+            indices = new Uint32Array(depthMix.buffer);
+            floatMix = new Float32Array(depthMix.buffer);
+            // Sort
+            for (let j = 0; j < vertexCount; j++) {
+                indices[2 * j] = j;
+            }
+            let depthFactor = -1;
+            if (e.data.useRightHandedSystem) {
+                depthFactor = 1;
+            }
+            for (let j = 0; j < vertexCount; j++) {
+                floatMix[2 * j + 1] = 10000 + (viewProj[2] * positions[3 * j + 0] + viewProj[6] * positions[3 * j + 1] + viewProj[10] * positions[3 * j + 2]) * depthFactor;
+            }
+            depthMix.sort();
+            self.postMessage({ depthMix }, [depthMix.buffer]);
+        }
+    };
+};
+
+/**
+ * Represents one particle of a points cloud system.
+ */
+class CloudPoint {
+    /**
+     * Creates a Point Cloud object.
+     * Don't create particles manually, use instead the PCS internal tools like _addParticle()
+     * @param particleIndex (integer) is the particle index in the PCS pool. It's also the particle identifier.
+     * @param group (PointsGroup) is the group the particle belongs to
+     * @param groupId (integer) is the group identifier in the PCS.
+     * @param idxInGroup (integer) is the index of the particle in the current point group (ex: the 10th point of addPoints(30))
+     * @param pcs defines the PCS it is associated to
+     */
+    constructor(particleIndex, group, groupId, idxInGroup, pcs) {
+        /**
+         * particle global index
+         */
+        this.idx = 0;
+        /**
+         * The color of the particle
+         */
+        this.color = new Color4(1.0, 1.0, 1.0, 1.0);
+        /**
+         * The world space position of the particle.
+         */
+        this.position = Vector3.Zero();
+        /**
+         * The world space rotation of the particle. (Not use if rotationQuaternion is set)
+         */
+        this.rotation = Vector3.Zero();
+        /**
+         * The uv of the particle.
+         */
+        this.uv = new Vector2(0.0, 0.0);
+        /**
+         * The current speed of the particle.
+         */
+        this.velocity = Vector3.Zero();
+        /**
+         * The pivot point in the particle local space.
+         */
+        this.pivot = Vector3.Zero();
+        /**
+         * Must the particle be translated from its pivot point in its local space ?
+         * In this case, the pivot point is set at the origin of the particle local space and the particle is translated.
+         * Default : false
+         */
+        this.translateFromPivot = false;
+        /**
+         * Index of this particle in the global "positions" array (Internal use)
+         * @internal
+         */
+        this._pos = 0;
+        /**
+         * @internal Index of this particle in the global "indices" array (Internal use)
+         */
+        this._ind = 0;
+        /**
+         * Group id of this particle
+         */
+        this.groupId = 0;
+        /**
+         * Index of the particle in its group id (Internal use)
+         */
+        this.idxInGroup = 0;
+        /**
+         * @internal Still set as invisible in order to skip useless computations (Internal use)
+         */
+        this._stillInvisible = false;
+        /**
+         * @internal Last computed particle rotation matrix
+         */
+        this._rotationMatrix = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
+        /**
+         * Parent particle Id, if any.
+         * Default null.
+         */
+        this.parentId = null;
+        /**
+         * @internal Internal global position in the PCS.
+         */
+        this._globalPosition = Vector3.Zero();
+        this.idx = particleIndex;
+        this._group = group;
+        this.groupId = groupId;
+        this.idxInGroup = idxInGroup;
+        this._pcs = pcs;
+    }
+    /**
+     * get point size
+     */
+    get size() {
+        return this.size;
+    }
+    /**
+     * Set point size
+     */
+    set size(scale) {
+        this.size = scale;
+    }
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    get quaternion() {
+        return this.rotationQuaternion;
+    }
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    set quaternion(q) {
+        this.rotationQuaternion = q;
+    }
+    /**
+     * Returns a boolean. True if the particle intersects a mesh, else false
+     * The intersection is computed on the particle position and Axis Aligned Bounding Box (AABB) or Sphere
+     * @param target is the object (point or mesh) what the intersection is computed against
+     * @param isSphere is boolean flag when false (default) bounding box of mesh is used, when true the bounding sphere is used
+     * @returns true if it intersects
+     */
+    intersectsMesh(target, isSphere) {
+        if (!target.hasBoundingInfo) {
+            return false;
+        }
+        if (!this._pcs.mesh) {
+            throw new Error("Point Cloud System doesnt contain the Mesh");
+        }
+        if (isSphere) {
+            return target.getBoundingInfo().boundingSphere.intersectsPoint(this.position.add(this._pcs.mesh.position));
+        }
+        const bbox = target.getBoundingInfo().boundingBox;
+        const maxX = bbox.maximumWorld.x;
+        const minX = bbox.minimumWorld.x;
+        const maxY = bbox.maximumWorld.y;
+        const minY = bbox.minimumWorld.y;
+        const maxZ = bbox.maximumWorld.z;
+        const minZ = bbox.minimumWorld.z;
+        const x = this.position.x + this._pcs.mesh.position.x;
+        const y = this.position.y + this._pcs.mesh.position.y;
+        const z = this.position.z + this._pcs.mesh.position.z;
+        return minX <= x && x <= maxX && minY <= y && y <= maxY && minZ <= z && z <= maxZ;
+    }
+    /**
+     * get the rotation matrix of the particle
+     * @internal
+     */
+    getRotationMatrix(m) {
+        let quaternion;
+        if (this.rotationQuaternion) {
+            quaternion = this.rotationQuaternion;
+        }
+        else {
+            quaternion = TmpVectors.Quaternion[0];
+            const rotation = this.rotation;
+            Quaternion.RotationYawPitchRollToRef(rotation.y, rotation.x, rotation.z, quaternion);
+        }
+        quaternion.toRotationMatrix(m);
+    }
+}
+/**
+ * Represents a group of points in a points cloud system
+ *  * PCS internal tool, don't use it manually.
+ */
+class PointsGroup {
+    /**
+     * Get or set the groupId
+     * @deprecated Please use groupId instead
+     */
+    get groupID() {
+        return this.groupId;
+    }
+    set groupID(groupID) {
+        this.groupId = groupID;
+    }
+    /**
+     * Creates a points group object. This is an internal reference to produce particles for the PCS.
+     * PCS internal tool, don't use it manually.
+     * @internal
+     */
+    constructor(id, posFunction) {
+        this.groupId = id;
+        this._positionFunction = posFunction;
+    }
+}
+
+/**
+ * Class representing a ray with position and direction
+ */
+class Ray {
+    /**
+     * Creates a new ray
+     * @param origin origin point
+     * @param direction direction
+     * @param length length of the ray
+     * @param epsilon The epsilon value to use when calculating the ray/triangle intersection (default: 0)
+     */
+    constructor(
+    /** origin point */
+    origin, 
+    /** direction */
+    direction, 
+    /** [Number.MAX_VALUE] length of the ray */
+    length = Number.MAX_VALUE, 
+    /** [Epsilon] The epsilon value to use when calculating the ray/triangle intersection (default: Epsilon from math constants) */
+    epsilon = Epsilon) {
+        this.origin = origin;
+        this.direction = direction;
+        this.length = length;
+        this.epsilon = epsilon;
+    }
+    // Methods
+    /**
+     * Clone the current ray
+     * @returns a new ray
+     */
+    clone() {
+        return new Ray(this.origin.clone(), this.direction.clone(), this.length);
+    }
+    /**
+     * Checks if the ray intersects a box
+     * This does not account for the ray length by design to improve perfs.
+     * @param minimum bound of the box
+     * @param maximum bound of the box
+     * @param intersectionTreshold extra extend to be added to the box in all direction
+     * @returns if the box was hit
+     */
+    intersectsBoxMinMax(minimum, maximum, intersectionTreshold = 0) {
+        const newMinimum = Ray._TmpVector3[0].copyFromFloats(minimum.x - intersectionTreshold, minimum.y - intersectionTreshold, minimum.z - intersectionTreshold);
+        const newMaximum = Ray._TmpVector3[1].copyFromFloats(maximum.x + intersectionTreshold, maximum.y + intersectionTreshold, maximum.z + intersectionTreshold);
+        let d = 0.0;
+        let maxValue = Number.MAX_VALUE;
+        let inv;
+        let min;
+        let max;
+        let temp;
+        if (Math.abs(this.direction.x) < 0.0000001) {
+            if (this.origin.x < newMinimum.x || this.origin.x > newMaximum.x) {
+                return false;
+            }
+        }
+        else {
+            inv = 1.0 / this.direction.x;
+            min = (newMinimum.x - this.origin.x) * inv;
+            max = (newMaximum.x - this.origin.x) * inv;
+            if (max === -Infinity) {
+                max = Infinity;
+            }
+            if (min > max) {
+                temp = min;
+                min = max;
+                max = temp;
+            }
+            d = Math.max(min, d);
+            maxValue = Math.min(max, maxValue);
+            if (d > maxValue) {
+                return false;
+            }
+        }
+        if (Math.abs(this.direction.y) < 0.0000001) {
+            if (this.origin.y < newMinimum.y || this.origin.y > newMaximum.y) {
+                return false;
+            }
+        }
+        else {
+            inv = 1.0 / this.direction.y;
+            min = (newMinimum.y - this.origin.y) * inv;
+            max = (newMaximum.y - this.origin.y) * inv;
+            if (max === -Infinity) {
+                max = Infinity;
+            }
+            if (min > max) {
+                temp = min;
+                min = max;
+                max = temp;
+            }
+            d = Math.max(min, d);
+            maxValue = Math.min(max, maxValue);
+            if (d > maxValue) {
+                return false;
+            }
+        }
+        if (Math.abs(this.direction.z) < 0.0000001) {
+            if (this.origin.z < newMinimum.z || this.origin.z > newMaximum.z) {
+                return false;
+            }
+        }
+        else {
+            inv = 1.0 / this.direction.z;
+            min = (newMinimum.z - this.origin.z) * inv;
+            max = (newMaximum.z - this.origin.z) * inv;
+            if (max === -Infinity) {
+                max = Infinity;
+            }
+            if (min > max) {
+                temp = min;
+                min = max;
+                max = temp;
+            }
+            d = Math.max(min, d);
+            maxValue = Math.min(max, maxValue);
+            if (d > maxValue) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if the ray intersects a box
+     * This does not account for the ray lenght by design to improve perfs.
+     * @param box the bounding box to check
+     * @param intersectionTreshold extra extend to be added to the BoundingBox in all direction
+     * @returns if the box was hit
+     */
+    intersectsBox(box, intersectionTreshold = 0) {
+        return this.intersectsBoxMinMax(box.minimum, box.maximum, intersectionTreshold);
+    }
+    /**
+     * If the ray hits a sphere
+     * @param sphere the bounding sphere to check
+     * @param intersectionTreshold extra extend to be added to the BoundingSphere in all direction
+     * @returns true if it hits the sphere
+     */
+    intersectsSphere(sphere, intersectionTreshold = 0) {
+        const x = sphere.center.x - this.origin.x;
+        const y = sphere.center.y - this.origin.y;
+        const z = sphere.center.z - this.origin.z;
+        const pyth = x * x + y * y + z * z;
+        const radius = sphere.radius + intersectionTreshold;
+        const rr = radius * radius;
+        if (pyth <= rr) {
+            return true;
+        }
+        const dot = x * this.direction.x + y * this.direction.y + z * this.direction.z;
+        if (dot < 0.0) {
+            return false;
+        }
+        const temp = pyth - dot * dot;
+        return temp <= rr;
+    }
+    /**
+     * If the ray hits a triange
+     * @param vertex0 triangle vertex
+     * @param vertex1 triangle vertex
+     * @param vertex2 triangle vertex
+     * @returns intersection information if hit
+     */
+    intersectsTriangle(vertex0, vertex1, vertex2) {
+        const edge1 = Ray._TmpVector3[0];
+        const edge2 = Ray._TmpVector3[1];
+        const pvec = Ray._TmpVector3[2];
+        const tvec = Ray._TmpVector3[3];
+        const qvec = Ray._TmpVector3[4];
+        vertex1.subtractToRef(vertex0, edge1);
+        vertex2.subtractToRef(vertex0, edge2);
+        Vector3.CrossToRef(this.direction, edge2, pvec);
+        const det = Vector3.Dot(edge1, pvec);
+        if (det === 0) {
+            return null;
+        }
+        const invdet = 1 / det;
+        this.origin.subtractToRef(vertex0, tvec);
+        const bv = Vector3.Dot(tvec, pvec) * invdet;
+        if (bv < -this.epsilon || bv > 1.0 + this.epsilon) {
+            return null;
+        }
+        Vector3.CrossToRef(tvec, edge1, qvec);
+        const bw = Vector3.Dot(this.direction, qvec) * invdet;
+        if (bw < -this.epsilon || bv + bw > 1.0 + this.epsilon) {
+            return null;
+        }
+        //check if the distance is longer than the predefined length.
+        const distance = Vector3.Dot(edge2, qvec) * invdet;
+        if (distance > this.length) {
+            return null;
+        }
+        return new IntersectionInfo(1 - bv - bw, bv, distance);
+    }
+    /**
+     * Checks if ray intersects a plane
+     * @param plane the plane to check
+     * @returns the distance away it was hit
+     */
+    intersectsPlane(plane) {
+        let distance;
+        const result1 = Vector3.Dot(plane.normal, this.direction);
+        if (Math.abs(result1) < 9.99999997475243e-7) {
+            return null;
+        }
+        else {
+            const result2 = Vector3.Dot(plane.normal, this.origin);
+            distance = (-plane.d - result2) / result1;
+            if (distance < 0.0) {
+                if (distance < -9.99999997475243e-7) {
+                    return null;
+                }
+                else {
+                    return 0;
+                }
+            }
+            return distance;
+        }
+    }
+    /**
+     * Calculate the intercept of a ray on a given axis
+     * @param axis to check 'x' | 'y' | 'z'
+     * @param offset from axis interception (i.e. an offset of 1y is intercepted above ground)
+     * @returns a vector containing the coordinates where 'axis' is equal to zero (else offset), or null if there is no intercept.
+     */
+    intersectsAxis(axis, offset = 0) {
+        switch (axis) {
+            case "y": {
+                const t = (this.origin.y - offset) / this.direction.y;
+                if (t > 0) {
+                    return null;
+                }
+                return new Vector3(this.origin.x + this.direction.x * -t, offset, this.origin.z + this.direction.z * -t);
+            }
+            case "x": {
+                const t = (this.origin.x - offset) / this.direction.x;
+                if (t > 0) {
+                    return null;
+                }
+                return new Vector3(offset, this.origin.y + this.direction.y * -t, this.origin.z + this.direction.z * -t);
+            }
+            case "z": {
+                const t = (this.origin.z - offset) / this.direction.z;
+                if (t > 0) {
+                    return null;
+                }
+                return new Vector3(this.origin.x + this.direction.x * -t, this.origin.y + this.direction.y * -t, offset);
+            }
+            default:
+                return null;
+        }
+    }
+    /**
+     * Checks if ray intersects a mesh. The ray is defined in WORLD space. A mesh triangle can be picked both from its front and back sides,
+     * irrespective of orientation.
+     * @param mesh the mesh to check
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+     * @param onlyBoundingInfo defines a boolean indicating if picking should only happen using bounding info (false by default)
+     * @param worldToUse defines the world matrix to use to get the world coordinate of the intersection point
+     * @param skipBoundingInfo a boolean indicating if we should skip the bounding info check
+     * @returns picking info of the intersection
+     */
+    intersectsMesh(mesh, fastCheck, trianglePredicate, onlyBoundingInfo = false, worldToUse, skipBoundingInfo = false) {
+        const tm = TmpVectors.Matrix[0];
+        mesh.getWorldMatrix().invertToRef(tm);
+        if (this._tmpRay) {
+            Ray.TransformToRef(this, tm, this._tmpRay);
+        }
+        else {
+            this._tmpRay = Ray.Transform(this, tm);
+        }
+        return mesh.intersects(this._tmpRay, fastCheck, trianglePredicate, onlyBoundingInfo, worldToUse, skipBoundingInfo);
+    }
+    /**
+     * Checks if ray intersects a mesh
+     * @param meshes the meshes to check
+     * @param fastCheck defines if the first intersection will be used (and not the closest)
+     * @param results array to store result in
+     * @returns Array of picking infos
+     */
+    intersectsMeshes(meshes, fastCheck, results) {
+        if (results) {
+            results.length = 0;
+        }
+        else {
+            results = [];
+        }
+        for (let i = 0; i < meshes.length; i++) {
+            const pickInfo = this.intersectsMesh(meshes[i], fastCheck);
+            if (pickInfo.hit) {
+                results.push(pickInfo);
+            }
+        }
+        results.sort(this._comparePickingInfo);
+        return results;
+    }
+    _comparePickingInfo(pickingInfoA, pickingInfoB) {
+        if (pickingInfoA.distance < pickingInfoB.distance) {
+            return -1;
+        }
+        else if (pickingInfoA.distance > pickingInfoB.distance) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Intersection test between the ray and a given segment within a given tolerance (threshold)
+     * @param sega the first point of the segment to test the intersection against
+     * @param segb the second point of the segment to test the intersection against
+     * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
+     * @returns the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
+     */
+    intersectionSegment(sega, segb, threshold) {
+        const o = this.origin;
+        const u = TmpVectors.Vector3[0];
+        const rsegb = TmpVectors.Vector3[1];
+        const v = TmpVectors.Vector3[2];
+        const w = TmpVectors.Vector3[3];
+        segb.subtractToRef(sega, u);
+        this.direction.scaleToRef(Ray._Rayl, v);
+        o.addToRef(v, rsegb);
+        sega.subtractToRef(o, w);
+        const a = Vector3.Dot(u, u); // always >= 0
+        const b = Vector3.Dot(u, v);
+        const c = Vector3.Dot(v, v); // always >= 0
+        const d = Vector3.Dot(u, w);
+        const e = Vector3.Dot(v, w);
+        const D = a * c - b * b; // always >= 0
+        let sN, sD = D; // sc = sN / sD, default sD = D >= 0
+        let tN, tD = D; // tc = tN / tD, default tD = D >= 0
+        // compute the line parameters of the two closest points
+        if (D < Ray._Smallnum) {
+            // the lines are almost parallel
+            sN = 0.0; // force using point P0 on segment S1
+            sD = 1.0; // to prevent possible division by 0.0 later
+            tN = e;
+            tD = c;
+        }
+        else {
+            // get the closest points on the infinite lines
+            sN = b * e - c * d;
+            tN = a * e - b * d;
+            if (sN < 0.0) {
+                // sc < 0 => the s=0 edge is visible
+                sN = 0.0;
+                tN = e;
+                tD = c;
+            }
+            else if (sN > sD) {
+                // sc > 1 => the s=1 edge is visible
+                sN = sD;
+                tN = e + b;
+                tD = c;
+            }
+        }
+        if (tN < 0.0) {
+            // tc < 0 => the t=0 edge is visible
+            tN = 0.0;
+            // recompute sc for this edge
+            if (-d < 0.0) {
+                sN = 0.0;
+            }
+            else if (-d > a) {
+                sN = sD;
+            }
+            else {
+                sN = -d;
+                sD = a;
+            }
+        }
+        else if (tN > tD) {
+            // tc > 1 => the t=1 edge is visible
+            tN = tD;
+            // recompute sc for this edge
+            if (-d + b < 0.0) {
+                sN = 0;
+            }
+            else if (-d + b > a) {
+                sN = sD;
+            }
+            else {
+                sN = -d + b;
+                sD = a;
+            }
+        }
+        // finally do the division to get sc and tc
+        const sc = Math.abs(sN) < Ray._Smallnum ? 0.0 : sN / sD;
+        const tc = Math.abs(tN) < Ray._Smallnum ? 0.0 : tN / tD;
+        // get the difference of the two closest points
+        const qtc = TmpVectors.Vector3[4];
+        v.scaleToRef(tc, qtc);
+        const qsc = TmpVectors.Vector3[5];
+        u.scaleToRef(sc, qsc);
+        qsc.addInPlace(w);
+        const dP = TmpVectors.Vector3[6];
+        qsc.subtractToRef(qtc, dP); // = S1(sc) - S2(tc)
+        const isIntersected = tc > 0 && tc <= this.length && dP.lengthSquared() < threshold * threshold; // return intersection result
+        if (isIntersected) {
+            return qsc.length();
+        }
+        return -1;
+    }
+    /**
+     * Update the ray from viewport position
+     * @param x position
+     * @param y y position
+     * @param viewportWidth viewport width
+     * @param viewportHeight viewport height
+     * @param world world matrix
+     * @param view view matrix
+     * @param projection projection matrix
+     * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+     * @returns this ray updated
+     */
+    update(x, y, viewportWidth, viewportHeight, world, view, projection, enableDistantPicking = false) {
+        if (enableDistantPicking) {
+            // With world matrices having great values (like 8000000000 on 1 or more scaling or position axis),
+            // multiplying view/projection/world and doing invert will result in loss of float precision in the matrix.
+            // One way to fix it is to compute the ray with world at identity then transform the ray in object space.
+            // This is slower (2 matrix inverts instead of 1) but precision is preserved.
+            // This is hidden behind `EnableDistantPicking` flag (default is false)
+            if (!Ray._RayDistant) {
+                Ray._RayDistant = Ray.Zero();
+            }
+            Ray._RayDistant.unprojectRayToRef(x, y, viewportWidth, viewportHeight, Matrix.IdentityReadOnly, view, projection);
+            const tm = TmpVectors.Matrix[0];
+            world.invertToRef(tm);
+            Ray.TransformToRef(Ray._RayDistant, tm, this);
+        }
+        else {
+            this.unprojectRayToRef(x, y, viewportWidth, viewportHeight, world, view, projection);
+        }
+        return this;
+    }
+    // Statics
+    /**
+     * Creates a ray with origin and direction of 0,0,0
+     * @returns the new ray
+     */
+    static Zero() {
+        return new Ray(Vector3.Zero(), Vector3.Zero());
+    }
+    /**
+     * Creates a new ray from screen space and viewport
+     * @param x position
+     * @param y y position
+     * @param viewportWidth viewport width
+     * @param viewportHeight viewport height
+     * @param world world matrix
+     * @param view view matrix
+     * @param projection projection matrix
+     * @returns new ray
+     */
+    static CreateNew(x, y, viewportWidth, viewportHeight, world, view, projection) {
+        const result = Ray.Zero();
+        return result.update(x, y, viewportWidth, viewportHeight, world, view, projection);
+    }
+    /**
+     * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
+     * transformed to the given world matrix.
+     * @param origin The origin point
+     * @param end The end point
+     * @param world a matrix to transform the ray to. Default is the identity matrix.
+     * @returns the new ray
+     */
+    static CreateNewFromTo(origin, end, world = Matrix.IdentityReadOnly) {
+        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));
+        return Ray.CreateFromToToRef(origin, end, result, world);
+    }
+    /**
+     * Function will update a transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
+     * transformed to the given world matrix.
+     * @param origin The origin point
+     * @param end The end point
+     * @param result the object to store the result
+     * @param world a matrix to transform the ray to. Default is the identity matrix.
+     * @returns the ref ray
+     */
+    static CreateFromToToRef(origin, end, result, world = Matrix.IdentityReadOnly) {
+        result.origin.copyFrom(origin);
+        const direction = end.subtractToRef(origin, result.direction);
+        const length = Math.sqrt(direction.x * direction.x + direction.y * direction.y + direction.z * direction.z);
+        result.length = length;
+        result.direction.normalize();
+        return Ray.TransformToRef(result, world, result);
+    }
+    /**
+     * Transforms a ray by a matrix
+     * @param ray ray to transform
+     * @param matrix matrix to apply
+     * @returns the resulting new ray
+     */
+    static Transform(ray, matrix) {
+        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));
+        Ray.TransformToRef(ray, matrix, result);
+        return result;
+    }
+    /**
+     * Transforms a ray by a matrix
+     * @param ray ray to transform
+     * @param matrix matrix to apply
+     * @param result ray to store result in
+     * @returns the updated result ray
+     */
+    static TransformToRef(ray, matrix, result) {
+        Vector3.TransformCoordinatesToRef(ray.origin, matrix, result.origin);
+        Vector3.TransformNormalToRef(ray.direction, matrix, result.direction);
+        result.length = ray.length;
+        result.epsilon = ray.epsilon;
+        const dir = result.direction;
+        const len = dir.length();
+        if (!(len === 0 || len === 1)) {
+            const num = 1.0 / len;
+            dir.x *= num;
+            dir.y *= num;
+            dir.z *= num;
+            result.length *= len;
+        }
+        return result;
+    }
+    /**
+     * Unproject a ray from screen space to object space
+     * @param sourceX defines the screen space x coordinate to use
+     * @param sourceY defines the screen space y coordinate to use
+     * @param viewportWidth defines the current width of the viewport
+     * @param viewportHeight defines the current height of the viewport
+     * @param world defines the world matrix to use (can be set to Identity to go to world space)
+     * @param view defines the view matrix to use
+     * @param projection defines the projection matrix to use
+     */
+    unprojectRayToRef(sourceX, sourceY, viewportWidth, viewportHeight, world, view, projection) {
+        const matrix = TmpVectors.Matrix[0];
+        world.multiplyToRef(view, matrix);
+        matrix.multiplyToRef(projection, matrix);
+        matrix.invert();
+        const engine = EngineStore.LastCreatedEngine;
+        const nearScreenSource = TmpVectors.Vector3[0];
+        nearScreenSource.x = (sourceX / viewportWidth) * 2 - 1;
+        nearScreenSource.y = -((sourceY / viewportHeight) * 2 - 1);
+        nearScreenSource.z = engine?.useReverseDepthBuffer ? 1 : engine?.isNDCHalfZRange ? 0 : -1;
+        // far Z need to be close but < to 1 or camera projection matrix with maxZ = 0 will NaN
+        const farScreenSource = TmpVectors.Vector3[1].copyFromFloats(nearScreenSource.x, nearScreenSource.y, 1.0 - 1e-8);
+        const nearVec3 = TmpVectors.Vector3[2];
+        const farVec3 = TmpVectors.Vector3[3];
+        Vector3._UnprojectFromInvertedMatrixToRef(nearScreenSource, matrix, nearVec3);
+        Vector3._UnprojectFromInvertedMatrixToRef(farScreenSource, matrix, farVec3);
+        this.origin.copyFrom(nearVec3);
+        farVec3.subtractToRef(nearVec3, this.direction);
+        this.direction.normalize();
+    }
+}
+Ray._TmpVector3 = BuildArray(6, Vector3.Zero);
+Ray._RayDistant = Ray.Zero();
+Ray._Smallnum = 0.00000001;
+Ray._Rayl = 10e8;
+/**
+ * Creates a ray that can be used to pick in the scene
+ * @param scene defines the scene to use for the picking
+ * @param x defines the x coordinate of the origin (on-screen)
+ * @param y defines the y coordinate of the origin (on-screen)
+ * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+ * @param camera defines the camera to use for the picking
+ * @param cameraViewSpace defines if picking will be done in view space (false by default)
+ * @returns a Ray
+ */
+function CreatePickingRay(scene, x, y, world, camera, cameraViewSpace = false) {
+    const result = Ray.Zero();
+    CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace);
+    return result;
+}
+/**
+ * Creates a ray that can be used to pick in the scene
+ * @param scene defines the scene to use for the picking
+ * @param x defines the x coordinate of the origin (on-screen)
+ * @param y defines the y coordinate of the origin (on-screen)
+ * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+ * @param result defines the ray where to store the picking ray
+ * @param camera defines the camera to use for the picking
+ * @param cameraViewSpace defines if picking will be done in view space (false by default)
+ * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+ * @returns the current scene
+ */
+function CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {
+    const engine = scene.getEngine();
+    if (!camera && !(camera = scene.activeCamera)) {
+        return scene;
+    }
+    const cameraViewport = camera.viewport;
+    const renderHeight = engine.getRenderHeight();
+    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);
+    // Moving coordinates to local viewport world
+    const levelInv = 1 / engine.getHardwareScalingLevel();
+    x = x * levelInv - vx;
+    y = y * levelInv - (renderHeight - vy - height);
+    result.update(x, y, width, height, world ? world : Matrix.IdentityReadOnly, cameraViewSpace ? Matrix.IdentityReadOnly : camera.getViewMatrix(), camera.getProjectionMatrix(), enableDistantPicking);
+    return scene;
+}
+/**
+ * Creates a ray that can be used to pick in the scene
+ * @param scene defines the scene to use for the picking
+ * @param x defines the x coordinate of the origin (on-screen)
+ * @param y defines the y coordinate of the origin (on-screen)
+ * @param camera defines the camera to use for the picking
+ * @returns a Ray
+ */
+function CreatePickingRayInCameraSpace(scene, x, y, camera) {
+    const result = Ray.Zero();
+    CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera);
+    return result;
+}
+/**
+ * Creates a ray that can be used to pick in the scene
+ * @param scene defines the scene to use for the picking
+ * @param x defines the x coordinate of the origin (on-screen)
+ * @param y defines the y coordinate of the origin (on-screen)
+ * @param result defines the ray where to store the picking ray
+ * @param camera defines the camera to use for the picking
+ * @returns the current scene
+ */
+function CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera) {
+    if (!PickingInfo) {
+        return scene;
+    }
+    const engine = scene.getEngine();
+    if (!camera && !(camera = scene.activeCamera)) {
+        throw new Error("Active camera not set");
+    }
+    const cameraViewport = camera.viewport;
+    const renderHeight = engine.getRenderHeight();
+    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);
+    const identity = Matrix.Identity();
+    // Moving coordinates to local viewport world
+    const levelInv = 1 / engine.getHardwareScalingLevel();
+    x = x * levelInv - vx;
+    y = y * levelInv - (renderHeight - vy - height);
+    result.update(x, y, width, height, identity, identity, camera.getProjectionMatrix());
+    return scene;
+}
+function InternalPickForMesh(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate, skipBoundingInfo) {
+    const ray = rayFunction(world, mesh.enableDistantPicking);
+    const result = mesh.intersects(ray, fastCheck, trianglePredicate, onlyBoundingInfo, world, skipBoundingInfo);
+    if (!result || !result.hit) {
+        return null;
+    }
+    if (!fastCheck && pickingInfo != null && result.distance >= pickingInfo.distance) {
+        return null;
+    }
+    return result;
+}
+function InternalPick(scene, rayFunction, predicate, fastCheck, onlyBoundingInfo, trianglePredicate) {
+    let pickingInfo = null;
+    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);
+    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;
+    const picker = InternalPickForMesh;
+    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {
+        const mesh = scene.meshes[meshIndex];
+        if (predicate) {
+            if (!predicate(mesh, -1)) {
+                continue;
+            }
+        }
+        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {
+            continue;
+        }
+        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();
+        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);
+        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {
+            // first check if the ray intersects the whole bounding box/sphere of the mesh
+            const result = picker(pickingInfo, rayFunction, mesh, world, true, true, trianglePredicate);
+            if (result) {
+                if (onlyBoundingInfo) {
+                    // the user only asked for a bounding info check so we can return
+                    return result;
+                }
+                const tmpMatrix = TmpVectors.Matrix[1];
+                const thinMatrices = mesh.thinInstanceGetWorldMatrices();
+                for (let index = 0; index < thinMatrices.length; index++) {
+                    if (predicate && !predicate(mesh, index)) {
+                        continue;
+                    }
+                    const thinMatrix = thinMatrices[index];
+                    thinMatrix.multiplyToRef(world, tmpMatrix);
+                    const result = picker(pickingInfo, rayFunction, mesh, tmpMatrix, fastCheck, onlyBoundingInfo, trianglePredicate, true);
+                    if (result) {
+                        pickingInfo = result;
+                        pickingInfo.thinInstanceIndex = index;
+                        if (fastCheck) {
+                            return pickingInfo;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const result = picker(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate);
+            if (result) {
+                pickingInfo = result;
+                if (fastCheck) {
+                    return pickingInfo;
+                }
+            }
+        }
+    }
+    return pickingInfo || new PickingInfo();
+}
+function InternalMultiPick(scene, rayFunction, predicate, trianglePredicate) {
+    if (!PickingInfo) {
+        return null;
+    }
+    const pickingInfos = [];
+    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);
+    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;
+    const picker = InternalPickForMesh;
+    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {
+        const mesh = scene.meshes[meshIndex];
+        if (predicate) {
+            if (!predicate(mesh, -1)) {
+                continue;
+            }
+        }
+        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {
+            continue;
+        }
+        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();
+        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);
+        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {
+            const result = picker(null, rayFunction, mesh, world, true, true, trianglePredicate);
+            if (result) {
+                const tmpMatrix = TmpVectors.Matrix[1];
+                const thinMatrices = mesh.thinInstanceGetWorldMatrices();
+                for (let index = 0; index < thinMatrices.length; index++) {
+                    if (predicate && !predicate(mesh, index)) {
+                        continue;
+                    }
+                    const thinMatrix = thinMatrices[index];
+                    thinMatrix.multiplyToRef(world, tmpMatrix);
+                    const result = picker(null, rayFunction, mesh, tmpMatrix, false, false, trianglePredicate, true);
+                    if (result) {
+                        result.thinInstanceIndex = index;
+                        pickingInfos.push(result);
+                    }
+                }
+            }
+        }
+        else {
+            const result = picker(null, rayFunction, mesh, world, false, false, trianglePredicate);
+            if (result) {
+                pickingInfos.push(result);
+            }
+        }
+    }
+    return pickingInfos;
+}
+/** Launch a ray to try to pick a mesh in the scene using only bounding information of the main mesh (not using submeshes)
+ * @param scene defines the scene to use for the picking
+ * @param x position on screen
+ * @param y position on screen
+ * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
+ * @param fastCheck defines if the first intersection will be used (and not the closest)
+ * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+ * @returns a PickingInfo (Please note that some info will not be set like distance, bv, bu and everything that cannot be capture by only using bounding infos)
+ */
+function PickWithBoundingInfo(scene, x, y, predicate, fastCheck, camera) {
+    if (!PickingInfo) {
+        return null;
+    }
+    const result = InternalPick(scene, (world) => {
+        if (!scene._tempPickingRay) {
+            scene._tempPickingRay = Ray.Zero();
+        }
+        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null);
+        return scene._tempPickingRay;
+    }, predicate, fastCheck, true);
+    if (result) {
+        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);
+    }
+    return result;
+}
+/** Launch a ray to try to pick a mesh in the scene
+ * @param scene defines the scene to use for the picking
+ * @param x position on screen
+ * @param y position on screen
+ * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
+ * @param fastCheck defines if the first intersection will be used (and not the closest)
+ * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+ * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+ * @param _enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+ * @returns a PickingInfo
+ */
+function Pick(scene, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {
+    const result = InternalPick(scene, (world, enableDistantPicking) => {
+        if (!scene._tempPickingRay) {
+            scene._tempPickingRay = Ray.Zero();
+        }
+        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null, false, enableDistantPicking);
+        return scene._tempPickingRay;
+    }, predicate, fastCheck, false, trianglePredicate);
+    if (result) {
+        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);
+    }
+    return result;
+}
+/**
+ * Use the given ray to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
+ * irrespective of orientation.
+ * @param scene defines the scene to use for the picking
+ * @param ray The ray to use to pick meshes
+ * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must have isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
+ * @param fastCheck defines if the first intersection will be used (and not the closest)
+ * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+ * @returns a PickingInfo
+ */
+function PickWithRay(scene, ray, predicate, fastCheck, trianglePredicate) {
+    const result = InternalPick(scene, (world) => {
+        if (!scene._pickWithRayInverseMatrix) {
+            scene._pickWithRayInverseMatrix = Matrix.Identity();
+        }
+        world.invertToRef(scene._pickWithRayInverseMatrix);
+        if (!scene._cachedRayForTransform) {
+            scene._cachedRayForTransform = Ray.Zero();
+        }
+        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);
+        return scene._cachedRayForTransform;
+    }, predicate, fastCheck, false, trianglePredicate);
+    if (result) {
+        result.ray = ray;
+    }
+    return result;
+}
+/**
+ * Launch a ray to try to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
+ * irrespective of orientation.
+ * @param scene defines the scene to use for the picking
+ * @param x X position on screen
+ * @param y Y position on screen
+ * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
+ * @param camera camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+ * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+ * @returns an array of PickingInfo
+ */
+function MultiPick(scene, x, y, predicate, camera, trianglePredicate) {
+    return InternalMultiPick(scene, (world) => CreatePickingRay(scene, x, y, world, camera || null), predicate, trianglePredicate);
+}
+/**
+ * Launch a ray to try to pick a mesh in the scene
+ * @param scene defines the scene to use for the picking
+ * @param ray Ray to use
+ * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
+ * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+ * @returns an array of PickingInfo
+ */
+function MultiPickWithRay(scene, ray, predicate, trianglePredicate) {
+    return InternalMultiPick(scene, (world) => {
+        if (!scene._pickWithRayInverseMatrix) {
+            scene._pickWithRayInverseMatrix = Matrix.Identity();
+        }
+        world.invertToRef(scene._pickWithRayInverseMatrix);
+        if (!scene._cachedRayForTransform) {
+            scene._cachedRayForTransform = Ray.Zero();
+        }
+        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);
+        return scene._cachedRayForTransform;
+    }, predicate, trianglePredicate);
+}
+/**
+ * Gets a ray in the forward direction from the camera.
+ * @param camera Defines the camera to use to get the ray from
+ * @param refRay the ray to (re)use when setting the values
+ * @param length Defines the length of the ray to create
+ * @param transform Defines the transform to apply to the ray, by default the world matrx is used to create a workd space ray
+ * @param origin Defines the start point of the ray which defaults to the camera position
+ * @returns the forward ray
+ */
+function GetForwardRayToRef(camera, refRay, length = 100, transform, origin) {
+    if (!transform) {
+        transform = camera.getWorldMatrix();
+    }
+    refRay.length = length;
+    if (origin) {
+        refRay.origin.copyFrom(origin);
+    }
+    else {
+        refRay.origin.copyFrom(camera.position);
+    }
+    const forward = TmpVectors.Vector3[2];
+    forward.set(0, 0, camera._scene.useRightHandedSystem ? -1 : 1);
+    const worldForward = TmpVectors.Vector3[3];
+    Vector3.TransformNormalToRef(forward, transform, worldForward);
+    Vector3.NormalizeToRef(worldForward, refRay.direction);
+    return refRay;
+}
+/**
+ * Initialize the minimal interdependecies between the Ray and Scene and Camera
+ * @param sceneClass defines the scene prototype to use
+ * @param cameraClass defines the camera prototype to use
+ */
+function AddRayExtensions(sceneClass, cameraClass) {
+    if (cameraClass) {
+        cameraClass.prototype.getForwardRay = function (length = 100, transform, origin) {
+            return GetForwardRayToRef(this, new Ray(Vector3.Zero(), Vector3.Zero(), length), length, transform, origin);
+        };
+        cameraClass.prototype.getForwardRayToRef = function (refRay, length = 100, transform, origin) {
+            return GetForwardRayToRef(this, refRay, length, transform, origin);
+        };
+    }
+    if (!sceneClass) {
+        return;
+    }
+    _ImportHelper._IsPickingAvailable = true;
+    sceneClass.prototype.createPickingRay = function (x, y, world, camera, cameraViewSpace = false) {
+        return CreatePickingRay(this, x, y, world, camera, cameraViewSpace);
+    };
+}
+
+// Picking
+AddRayExtensions(Scene, Camera);
+Scene.prototype.createPickingRayToRef = function (x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {
+    return CreatePickingRayToRef(this, x, y, world, result, camera, cameraViewSpace, enableDistantPicking);
+};
+Scene.prototype.createPickingRayInCameraSpace = function (x, y, camera) {
+    return CreatePickingRayInCameraSpace(this, x, y, camera);
+};
+Scene.prototype.createPickingRayInCameraSpaceToRef = function (x, y, result, camera) {
+    return CreatePickingRayInCameraSpaceToRef(this, x, y, result, camera);
+};
+Scene.prototype.pickWithBoundingInfo = function (x, y, predicate, fastCheck, camera) {
+    return PickWithBoundingInfo(this, x, y, predicate, fastCheck, camera);
+};
+Scene.prototype.pick = function (x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {
+    return Pick(this, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking);
+};
+Scene.prototype.pickWithRay = function (ray, predicate, fastCheck, trianglePredicate) {
+    return PickWithRay(this, ray, predicate, fastCheck, trianglePredicate);
+};
+Scene.prototype.multiPick = function (x, y, predicate, camera, trianglePredicate) {
+    return MultiPick(this, x, y, predicate, camera, trianglePredicate);
+};
+Scene.prototype.multiPickWithRay = function (ray, predicate, trianglePredicate) {
+    return MultiPickWithRay(this, ray, predicate, trianglePredicate);
+};
+
+/** Defines the 4 color options */
+var PointColor;
+(function (PointColor) {
+    /** color value */
+    PointColor[PointColor["Color"] = 2] = "Color";
+    /** uv value */
+    PointColor[PointColor["UV"] = 1] = "UV";
+    /** random value */
+    PointColor[PointColor["Random"] = 0] = "Random";
+    /** stated value */
+    PointColor[PointColor["Stated"] = 3] = "Stated";
+})(PointColor || (PointColor = {}));
+/**
+ * The PointCloudSystem (PCS) is a single updatable mesh. The points corresponding to the vertices of this big mesh.
+ * As it is just a mesh, the PointCloudSystem has all the same properties as any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
+
+ * The PointCloudSystem is also a particle system, with each point being a particle. It provides some methods to manage the particles.
+ * However it is behavior agnostic. This means it has no emitter, no particle physics, no particle recycler. You have to implement your own behavior.
+ *
+ * Full documentation here : TO BE ENTERED
+ */
+class PointsCloudSystem {
+    /**
+     * Gets the particle positions computed by the Point Cloud System
+     */
+    get positions() {
+        return this._positions32;
+    }
+    /**
+     * Gets the particle colors computed by the Point Cloud System
+     */
+    get colors() {
+        return this._colors32;
+    }
+    /**
+     * Gets the particle uvs computed by the Point Cloud System
+     */
+    get uvs() {
+        return this._uvs32;
+    }
+    /**
+     * Creates a PCS (Points Cloud System) object
+     * @param name (String) is the PCS name, this will be the underlying mesh name
+     * @param pointSize (number) is the size for each point. Has no effect on a WebGPU engine.
+     * @param scene (Scene) is the scene in which the PCS is added
+     * @param options defines the options of the PCS e.g.
+     * * updatable (optional boolean, default true) : if the PCS must be updatable or immutable
+     */
+    constructor(name, pointSize, scene, options) {
+        /**
+         *  The PCS array of cloud point objects. Just access each particle as with any classic array.
+         *  Example : var p = SPS.particles[i];
+         */
+        this.particles = new Array();
+        /**
+         * The PCS total number of particles. Read only. Use PCS.counter instead if you need to set your own value.
+         */
+        this.nbParticles = 0;
+        /**
+         * This a counter for your own usage. It's not set by any SPS functions.
+         */
+        this.counter = 0;
+        /**
+         * This empty object is intended to store some PCS specific or temporary values in order to lower the Garbage Collector activity.
+         * Please read :
+         */
+        this.vars = {};
+        this._promises = [];
+        this._positions = new Array();
+        this._indices = new Array();
+        this._normals = new Array();
+        this._colors = new Array();
+        this._uvs = new Array();
+        this._updatable = true;
+        this._isVisibilityBoxLocked = false;
+        this._alwaysVisible = false;
+        this._groups = new Array(); //start indices for each group of particles
+        this._groupCounter = 0;
+        this._computeParticleColor = true;
+        this._computeParticleTexture = true;
+        this._computeParticleRotation = true;
+        this._computeBoundingBox = false;
+        this._isReady = false;
+        this.name = name;
+        this._size = pointSize;
+        this._scene = scene || EngineStore.LastCreatedScene;
+        if (options && options.updatable !== undefined) {
+            this._updatable = options.updatable;
+        }
+        else {
+            this._updatable = true;
+        }
+    }
+    /**
+     * Builds the PCS underlying mesh. Returns a standard Mesh.
+     * If no points were added to the PCS, the returned mesh is just a single point.
+     * @param material The material to use to render the mesh. If not provided, will create a default one
+     * @returns a promise for the created mesh
+     */
+    buildMeshAsync(material) {
+        return Promise.all(this._promises).then(() => {
+            this._isReady = true;
+            return this._buildMesh(material);
+        });
+    }
+    /**
+     * @internal
+     */
+    _buildMesh(material) {
+        if (this.nbParticles === 0) {
+            this.addPoints(1);
+        }
+        this._positions32 = new Float32Array(this._positions);
+        this._uvs32 = new Float32Array(this._uvs);
+        this._colors32 = new Float32Array(this._colors);
+        const vertexData = new VertexData();
+        vertexData.set(this._positions32, VertexBuffer.PositionKind);
+        if (this._uvs32.length > 0) {
+            vertexData.set(this._uvs32, VertexBuffer.UVKind);
+        }
+        let ec = 0; //emissive color value 0 for UVs, 1 for color
+        if (this._colors32.length > 0) {
+            ec = 1;
+            vertexData.set(this._colors32, VertexBuffer.ColorKind);
+        }
+        const mesh = new Mesh(this.name, this._scene);
+        vertexData.applyToMesh(mesh, this._updatable);
+        this.mesh = mesh;
+        // free memory
+        this._positions = null;
+        this._uvs = null;
+        this._colors = null;
+        if (!this._updatable) {
+            this.particles.length = 0;
+        }
+        let mat = material;
+        if (!mat) {
+            mat = new StandardMaterial("point cloud material", this._scene);
+            mat.emissiveColor = new Color3(ec, ec, ec);
+            mat.disableLighting = true;
+            mat.pointsCloud = true;
+            mat.pointSize = this._size;
+        }
+        mesh.material = mat;
+        return new Promise((resolve) => resolve(mesh));
+    }
+    // adds a new particle object in the particles array
+    _addParticle(idx, group, groupId, idxInGroup) {
+        const cp = new CloudPoint(idx, group, groupId, idxInGroup, this);
+        this.particles.push(cp);
+        return cp;
+    }
+    _randomUnitVector(particle) {
+        particle.position = new Vector3(Math.random(), Math.random(), Math.random());
+        particle.color = new Color4(1, 1, 1, 1);
+    }
+    _getColorIndicesForCoord(pointsGroup, x, y, width) {
+        const imageData = pointsGroup._groupImageData;
+        const color = y * (width * 4) + x * 4;
+        const colorIndices = [color, color + 1, color + 2, color + 3];
+        const redIndex = colorIndices[0];
+        const greenIndex = colorIndices[1];
+        const blueIndex = colorIndices[2];
+        const alphaIndex = colorIndices[3];
+        const redForCoord = imageData[redIndex];
+        const greenForCoord = imageData[greenIndex];
+        const blueForCoord = imageData[blueIndex];
+        const alphaForCoord = imageData[alphaIndex];
+        return new Color4(redForCoord / 255, greenForCoord / 255, blueForCoord / 255, alphaForCoord);
+    }
+    _setPointsColorOrUV(mesh, pointsGroup, isVolume, colorFromTexture, hasTexture, color, range, uvSetIndex) {
+        uvSetIndex = uvSetIndex ?? 0;
+        if (isVolume) {
+            mesh.updateFacetData();
+        }
+        const boundInfo = mesh.getBoundingInfo();
+        const diameter = 2 * boundInfo.boundingSphere.radius;
+        let meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
+        const meshInd = mesh.getIndices();
+        const meshUV = mesh.getVerticesData(VertexBuffer.UVKind + (uvSetIndex ? uvSetIndex + 1 : ""));
+        const meshCol = mesh.getVerticesData(VertexBuffer.ColorKind);
+        const place = Vector3.Zero();
+        mesh.computeWorldMatrix();
+        const meshMatrix = mesh.getWorldMatrix();
+        if (!meshMatrix.isIdentity()) {
+            meshPos = meshPos.slice(0);
+            for (let p = 0; p < meshPos.length / 3; p++) {
+                Vector3.TransformCoordinatesFromFloatsToRef(meshPos[3 * p], meshPos[3 * p + 1], meshPos[3 * p + 2], meshMatrix, place);
+                meshPos[3 * p] = place.x;
+                meshPos[3 * p + 1] = place.y;
+                meshPos[3 * p + 2] = place.z;
+            }
+        }
+        let idxPoints = 0;
+        let id0 = 0;
+        let id1 = 0;
+        let id2 = 0;
+        let v0X = 0;
+        let v0Y = 0;
+        let v0Z = 0;
+        let v1X = 0;
+        let v1Y = 0;
+        let v1Z = 0;
+        let v2X = 0;
+        let v2Y = 0;
+        let v2Z = 0;
+        const vertex0 = Vector3.Zero();
+        const vertex1 = Vector3.Zero();
+        const vertex2 = Vector3.Zero();
+        const vec0 = Vector3.Zero();
+        const vec1 = Vector3.Zero();
+        let uv0X = 0;
+        let uv0Y = 0;
+        let uv1X = 0;
+        let uv1Y = 0;
+        let uv2X = 0;
+        let uv2Y = 0;
+        const uv0 = Vector2.Zero();
+        const uv1 = Vector2.Zero();
+        const uv2 = Vector2.Zero();
+        const uvec0 = Vector2.Zero();
+        const uvec1 = Vector2.Zero();
+        let col0X = 0;
+        let col0Y = 0;
+        let col0Z = 0;
+        let col0A = 0;
+        let col1X = 0;
+        let col1Y = 0;
+        let col1Z = 0;
+        let col1A = 0;
+        let col2X = 0;
+        let col2Y = 0;
+        let col2Z = 0;
+        let col2A = 0;
+        const col0 = Vector4.Zero();
+        const col1 = Vector4.Zero();
+        const col2 = Vector4.Zero();
+        const colvec0 = Vector4.Zero();
+        const colvec1 = Vector4.Zero();
+        let lamda = 0;
+        let mu = 0;
+        range = range ? range : 0;
+        let facetPoint;
+        let uvPoint;
+        let colPoint = new Vector4(0, 0, 0, 0);
+        let norm = Vector3.Zero();
+        let tang = Vector3.Zero();
+        let biNorm = Vector3.Zero();
+        let angle = 0;
+        let facetPlaneVec = Vector3.Zero();
+        let gap = 0;
+        let distance = 0;
+        const ray = new Ray(Vector3.Zero(), new Vector3(1, 0, 0));
+        let pickInfo;
+        let direction = Vector3.Zero();
+        for (let index = 0; index < meshInd.length / 3; index++) {
+            id0 = meshInd[3 * index];
+            id1 = meshInd[3 * index + 1];
+            id2 = meshInd[3 * index + 2];
+            v0X = meshPos[3 * id0];
+            v0Y = meshPos[3 * id0 + 1];
+            v0Z = meshPos[3 * id0 + 2];
+            v1X = meshPos[3 * id1];
+            v1Y = meshPos[3 * id1 + 1];
+            v1Z = meshPos[3 * id1 + 2];
+            v2X = meshPos[3 * id2];
+            v2Y = meshPos[3 * id2 + 1];
+            v2Z = meshPos[3 * id2 + 2];
+            vertex0.set(v0X, v0Y, v0Z);
+            vertex1.set(v1X, v1Y, v1Z);
+            vertex2.set(v2X, v2Y, v2Z);
+            vertex1.subtractToRef(vertex0, vec0);
+            vertex2.subtractToRef(vertex1, vec1);
+            if (meshUV) {
+                uv0X = meshUV[2 * id0];
+                uv0Y = meshUV[2 * id0 + 1];
+                uv1X = meshUV[2 * id1];
+                uv1Y = meshUV[2 * id1 + 1];
+                uv2X = meshUV[2 * id2];
+                uv2Y = meshUV[2 * id2 + 1];
+                uv0.set(uv0X, uv0Y);
+                uv1.set(uv1X, uv1Y);
+                uv2.set(uv2X, uv2Y);
+                uv1.subtractToRef(uv0, uvec0);
+                uv2.subtractToRef(uv1, uvec1);
+            }
+            if (meshCol && colorFromTexture) {
+                col0X = meshCol[4 * id0];
+                col0Y = meshCol[4 * id0 + 1];
+                col0Z = meshCol[4 * id0 + 2];
+                col0A = meshCol[4 * id0 + 3];
+                col1X = meshCol[4 * id1];
+                col1Y = meshCol[4 * id1 + 1];
+                col1Z = meshCol[4 * id1 + 2];
+                col1A = meshCol[4 * id1 + 3];
+                col2X = meshCol[4 * id2];
+                col2Y = meshCol[4 * id2 + 1];
+                col2Z = meshCol[4 * id2 + 2];
+                col2A = meshCol[4 * id2 + 3];
+                col0.set(col0X, col0Y, col0Z, col0A);
+                col1.set(col1X, col1Y, col1Z, col1A);
+                col2.set(col2X, col2Y, col2Z, col2A);
+                col1.subtractToRef(col0, colvec0);
+                col2.subtractToRef(col1, colvec1);
+            }
+            let width;
+            let height;
+            let deltaS;
+            let deltaV;
+            let h;
+            let s;
+            let v;
+            let hsvCol;
+            const statedColor = new Color3(0, 0, 0);
+            const colPoint3 = new Color3(0, 0, 0);
+            let pointColors;
+            let particle;
+            for (let i = 0; i < pointsGroup._groupDensity[index]; i++) {
+                idxPoints = this.particles.length;
+                this._addParticle(idxPoints, pointsGroup, this._groupCounter, index + i);
+                particle = this.particles[idxPoints];
+                //form a point inside the facet v0, v1, v2;
+                lamda = Math.sqrt(RandomRange(0, 1));
+                mu = RandomRange(0, 1);
+                facetPoint = vertex0.add(vec0.scale(lamda)).add(vec1.scale(lamda * mu));
+                if (isVolume) {
+                    norm = mesh.getFacetNormal(index).normalize().scale(-1);
+                    tang = vec0.clone().normalize();
+                    biNorm = Vector3.Cross(norm, tang);
+                    angle = RandomRange(0, 2 * Math.PI);
+                    facetPlaneVec = tang.scale(Math.cos(angle)).add(biNorm.scale(Math.sin(angle)));
+                    angle = RandomRange(0.1, Math.PI / 2);
+                    direction = facetPlaneVec.scale(Math.cos(angle)).add(norm.scale(Math.sin(angle)));
+                    ray.origin = facetPoint.add(direction.scale(0.00001));
+                    ray.direction = direction;
+                    ray.length = diameter;
+                    pickInfo = ray.intersectsMesh(mesh);
+                    if (pickInfo.hit) {
+                        distance = pickInfo.pickedPoint.subtract(facetPoint).length();
+                        gap = RandomRange(0, 1) * distance;
+                        facetPoint.addInPlace(direction.scale(gap));
+                    }
+                }
+                particle.position = facetPoint.clone();
+                this._positions.push(particle.position.x, particle.position.y, particle.position.z);
+                if (colorFromTexture !== undefined) {
+                    if (meshUV) {
+                        uvPoint = uv0.add(uvec0.scale(lamda)).add(uvec1.scale(lamda * mu));
+                        if (colorFromTexture) {
+                            //Set particle color to texture color
+                            if (hasTexture && pointsGroup._groupImageData !== null) {
+                                width = pointsGroup._groupImgWidth;
+                                height = pointsGroup._groupImgHeight;
+                                pointColors = this._getColorIndicesForCoord(pointsGroup, Math.round(uvPoint.x * width), Math.round(uvPoint.y * height), width);
+                                particle.color = pointColors;
+                                this._colors.push(pointColors.r, pointColors.g, pointColors.b, pointColors.a);
+                            }
+                            else {
+                                if (meshCol) {
+                                    //failure in texture and colors available
+                                    colPoint = col0.add(colvec0.scale(lamda)).add(colvec1.scale(lamda * mu));
+                                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                                }
+                                else {
+                                    colPoint = col0.set(Math.random(), Math.random(), Math.random(), 1);
+                                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                                }
+                            }
+                        }
+                        else {
+                            //Set particle uv based on a mesh uv
+                            particle.uv = uvPoint.clone();
+                            this._uvs.push(particle.uv.x, particle.uv.y);
+                        }
+                    }
+                }
+                else {
+                    if (color) {
+                        statedColor.set(color.r, color.g, color.b);
+                        deltaS = RandomRange(-range, range);
+                        deltaV = RandomRange(-range, range);
+                        hsvCol = statedColor.toHSV();
+                        h = hsvCol.r;
+                        s = hsvCol.g + deltaS;
+                        v = hsvCol.b + deltaV;
+                        if (s < 0) {
+                            s = 0;
+                        }
+                        if (s > 1) {
+                            s = 1;
+                        }
+                        if (v < 0) {
+                            v = 0;
+                        }
+                        if (v > 1) {
+                            v = 1;
+                        }
+                        Color3.HSVtoRGBToRef(h, s, v, colPoint3);
+                        colPoint.set(colPoint3.r, colPoint3.g, colPoint3.b, 1);
+                    }
+                    else {
+                        colPoint = col0.set(Math.random(), Math.random(), Math.random(), 1);
+                    }
+                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
+                }
+            }
+        }
+    }
+    // stores mesh texture in dynamic texture for color pixel retrieval
+    // when pointColor type is color for surface points
+    _colorFromTexture(mesh, pointsGroup, isVolume) {
+        if (mesh.material === null) {
+            Logger.Warn(mesh.name + "has no material.");
+            pointsGroup._groupImageData = null;
+            this._setPointsColorOrUV(mesh, pointsGroup, isVolume, true, false);
+            return;
+        }
+        const mat = mesh.material;
+        const textureList = mat.getActiveTextures();
+        if (textureList.length === 0) {
+            Logger.Warn(mesh.name + "has no usable texture.");
+            pointsGroup._groupImageData = null;
+            this._setPointsColorOrUV(mesh, pointsGroup, isVolume, true, false);
+            return;
+        }
+        const clone = mesh.clone();
+        clone.setEnabled(false);
+        this._promises.push(new Promise((resolve) => {
+            BaseTexture.WhenAllReady(textureList, () => {
+                let n = pointsGroup._textureNb;
+                if (n < 0) {
+                    n = 0;
+                }
+                if (n > textureList.length - 1) {
+                    n = textureList.length - 1;
+                }
+                const finalize = () => {
+                    pointsGroup._groupImgWidth = textureList[n].getSize().width;
+                    pointsGroup._groupImgHeight = textureList[n].getSize().height;
+                    this._setPointsColorOrUV(clone, pointsGroup, isVolume, true, true, undefined, undefined, textureList[n].coordinatesIndex);
+                    clone.dispose();
+                    resolve();
+                };
+                pointsGroup._groupImageData = null;
+                const dataPromise = textureList[n].readPixels();
+                if (!dataPromise) {
+                    finalize();
+                }
+                else {
+                    dataPromise.then((data) => {
+                        pointsGroup._groupImageData = data;
+                        finalize();
+                    });
+                }
+            });
+        }));
+    }
+    // calculates the point density per facet of a mesh for surface points
+    _calculateDensity(nbPoints, positions, indices) {
+        let id0;
+        let id1;
+        let id2;
+        let v0X;
+        let v0Y;
+        let v0Z;
+        let v1X;
+        let v1Y;
+        let v1Z;
+        let v2X;
+        let v2Y;
+        let v2Z;
+        const vertex0 = Vector3.Zero();
+        const vertex1 = Vector3.Zero();
+        const vertex2 = Vector3.Zero();
+        const vec0 = Vector3.Zero();
+        const vec1 = Vector3.Zero();
+        const normal = Vector3.Zero();
+        let area;
+        const cumulativeAreas = [];
+        let surfaceArea = 0;
+        const nbFacets = indices.length / 3;
+        //surface area
+        for (let index = 0; index < nbFacets; index++) {
+            id0 = indices[3 * index];
+            id1 = indices[3 * index + 1];
+            id2 = indices[3 * index + 2];
+            v0X = positions[3 * id0];
+            v0Y = positions[3 * id0 + 1];
+            v0Z = positions[3 * id0 + 2];
+            v1X = positions[3 * id1];
+            v1Y = positions[3 * id1 + 1];
+            v1Z = positions[3 * id1 + 2];
+            v2X = positions[3 * id2];
+            v2Y = positions[3 * id2 + 1];
+            v2Z = positions[3 * id2 + 2];
+            vertex0.set(v0X, v0Y, v0Z);
+            vertex1.set(v1X, v1Y, v1Z);
+            vertex2.set(v2X, v2Y, v2Z);
+            vertex1.subtractToRef(vertex0, vec0);
+            vertex2.subtractToRef(vertex1, vec1);
+            Vector3.CrossToRef(vec0, vec1, normal);
+            area = 0.5 * normal.length();
+            surfaceArea += area;
+            cumulativeAreas[index] = surfaceArea;
+        }
+        const density = new Array(nbFacets);
+        let remainingPoints = nbPoints;
+        for (let index = nbFacets - 1; index > 0; index--) {
+            const cumulativeArea = cumulativeAreas[index];
+            if (cumulativeArea === 0) {
+                // avoiding division by 0 upon degenerate triangles
+                density[index] = 0;
+            }
+            else {
+                const area = cumulativeArea - cumulativeAreas[index - 1];
+                const facetPointsWithFraction = (area / cumulativeArea) * remainingPoints;
+                const floored = Math.floor(facetPointsWithFraction);
+                const fraction = facetPointsWithFraction - floored;
+                const extraPoint = Number(Math.random() < fraction);
+                const facetPoints = floored + extraPoint;
+                density[index] = facetPoints;
+                remainingPoints -= facetPoints;
+            }
+        }
+        density[0] = remainingPoints;
+        return density;
+    }
+    /**
+     * Adds points to the PCS in random positions within a unit sphere
+     * @param nb (positive integer) the number of particles to be created from this model
+     * @param pointFunction is an optional javascript function to be called for each particle on PCS creation
+     * @returns the number of groups in the system
+     */
+    addPoints(nb, pointFunction = this._randomUnitVector) {
+        const pointsGroup = new PointsGroup(this._groupCounter, pointFunction);
+        let cp;
+        // particles
+        let idx = this.nbParticles;
+        for (let i = 0; i < nb; i++) {
+            cp = this._addParticle(idx, pointsGroup, this._groupCounter, i);
+            if (pointsGroup && pointsGroup._positionFunction) {
+                pointsGroup._positionFunction(cp, idx, i);
+            }
+            this._positions.push(cp.position.x, cp.position.y, cp.position.z);
+            if (cp.color) {
+                this._colors.push(cp.color.r, cp.color.g, cp.color.b, cp.color.a);
+            }
+            if (cp.uv) {
+                this._uvs.push(cp.uv.x, cp.uv.y);
+            }
+            idx++;
+        }
+        this.nbParticles += nb;
+        this._groupCounter++;
+        return this._groupCounter;
+    }
+    /**
+     * Adds points to the PCS from the surface of the model shape
+     * @param mesh is any Mesh object that will be used as a surface model for the points
+     * @param nb (positive integer) the number of particles to be created from this model
+     * @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
+     * @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
+     * @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
+     * @returns the number of groups in the system
+     */
+    addSurfacePoints(mesh, nb, colorWith, color, range) {
+        let colored = colorWith ? colorWith : 0 /* PointColor.Random */;
+        if (isNaN(colored) || colored < 0 || colored > 3) {
+            colored = 0 /* PointColor.Random */;
+        }
+        const meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
+        const meshInd = mesh.getIndices();
+        this._groups.push(this._groupCounter);
+        const pointsGroup = new PointsGroup(this._groupCounter, null);
+        pointsGroup._groupDensity = this._calculateDensity(nb, meshPos, meshInd);
+        if (colored === 2 /* PointColor.Color */) {
+            pointsGroup._textureNb = color ? color : 0;
+        }
+        else {
+            color = color ? color : new Color4(1, 1, 1, 1);
+        }
+        switch (colored) {
+            case 2 /* PointColor.Color */:
+                this._colorFromTexture(mesh, pointsGroup, false);
+                break;
+            case 1 /* PointColor.UV */:
+                this._setPointsColorOrUV(mesh, pointsGroup, false, false, false);
+                break;
+            case 0 /* PointColor.Random */:
+                this._setPointsColorOrUV(mesh, pointsGroup, false);
+                break;
+            case 3 /* PointColor.Stated */:
+                this._setPointsColorOrUV(mesh, pointsGroup, false, undefined, undefined, color, range);
+                break;
+        }
+        this.nbParticles += nb;
+        this._groupCounter++;
+        return this._groupCounter - 1;
+    }
+    /**
+     * Adds points to the PCS inside the model shape
+     * @param mesh is any Mesh object that will be used as a surface model for the points
+     * @param nb (positive integer) the number of particles to be created from this model
+     * @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
+     * @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
+     * @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
+     * @returns the number of groups in the system
+     */
+    addVolumePoints(mesh, nb, colorWith, color, range) {
+        let colored = colorWith ? colorWith : 0 /* PointColor.Random */;
+        if (isNaN(colored) || colored < 0 || colored > 3) {
+            colored = 0 /* PointColor.Random */;
+        }
+        const meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
+        const meshInd = mesh.getIndices();
+        this._groups.push(this._groupCounter);
+        const pointsGroup = new PointsGroup(this._groupCounter, null);
+        pointsGroup._groupDensity = this._calculateDensity(nb, meshPos, meshInd);
+        if (colored === 2 /* PointColor.Color */) {
+            pointsGroup._textureNb = color ? color : 0;
+        }
+        else {
+            color = color ? color : new Color4(1, 1, 1, 1);
+        }
+        switch (colored) {
+            case 2 /* PointColor.Color */:
+                this._colorFromTexture(mesh, pointsGroup, true);
+                break;
+            case 1 /* PointColor.UV */:
+                this._setPointsColorOrUV(mesh, pointsGroup, true, false, false);
+                break;
+            case 0 /* PointColor.Random */:
+                this._setPointsColorOrUV(mesh, pointsGroup, true);
+                break;
+            case 3 /* PointColor.Stated */:
+                this._setPointsColorOrUV(mesh, pointsGroup, true, undefined, undefined, color, range);
+                break;
+        }
+        this.nbParticles += nb;
+        this._groupCounter++;
+        return this._groupCounter - 1;
+    }
+    /**
+     *  Sets all the particles : this method actually really updates the mesh according to the particle positions, rotations, colors, textures, etc.
+     *  This method calls `updateParticle()` for each particle of the SPS.
+     *  For an animated SPS, it is usually called within the render loop.
+     * @param start The particle index in the particle array where to start to compute the particle property values _(default 0)_
+     * @param end The particle index in the particle array where to stop to compute the particle property values _(default nbParticle - 1)_
+     * @param update If the mesh must be finally updated on this call after all the particle computations _(default true)_
+     * @returns the PCS.
+     */
+    setParticles(start = 0, end = this.nbParticles - 1, update = true) {
+        if (!this._updatable || !this._isReady) {
+            return this;
+        }
+        // custom beforeUpdate
+        this.beforeUpdateParticles(start, end, update);
+        const rotMatrix = TmpVectors.Matrix[0];
+        const mesh = this.mesh;
+        const colors32 = this._colors32;
+        const positions32 = this._positions32;
+        const uvs32 = this._uvs32;
+        const tempVectors = TmpVectors.Vector3;
+        const camAxisX = tempVectors[5].copyFromFloats(1.0, 0.0, 0.0);
+        const camAxisY = tempVectors[6].copyFromFloats(0.0, 1.0, 0.0);
+        const camAxisZ = tempVectors[7].copyFromFloats(0.0, 0.0, 1.0);
+        const minimum = tempVectors[8].setAll(Number.MAX_VALUE);
+        const maximum = tempVectors[9].setAll(-Number.MAX_VALUE);
+        Matrix.IdentityToRef(rotMatrix);
+        let idx = 0; // current index of the particle
+        if (this.mesh?.isFacetDataEnabled) {
+            this._computeBoundingBox = true;
+        }
+        end = end >= this.nbParticles ? this.nbParticles - 1 : end;
+        if (this._computeBoundingBox) {
+            if (start != 0 || end != this.nbParticles - 1) {
+                // only some particles are updated, then use the current existing BBox basis. Note : it can only increase.
+                const boundingInfo = this.mesh?.getBoundingInfo();
+                if (boundingInfo) {
+                    minimum.copyFrom(boundingInfo.minimum);
+                    maximum.copyFrom(boundingInfo.maximum);
+                }
+            }
+        }
+        idx = 0; // particle index
+        let pindex = 0; //index in positions array
+        let cindex = 0; //index in color array
+        let uindex = 0; //index in uv array
+        // particle loop
+        for (let p = start; p <= end; p++) {
+            const particle = this.particles[p];
+            idx = particle.idx;
+            pindex = 3 * idx;
+            cindex = 4 * idx;
+            uindex = 2 * idx;
+            // call to custom user function to update the particle properties
+            this.updateParticle(particle);
+            const particleRotationMatrix = particle._rotationMatrix;
+            const particlePosition = particle.position;
+            const particleGlobalPosition = particle._globalPosition;
+            if (this._computeParticleRotation) {
+                particle.getRotationMatrix(rotMatrix);
+            }
+            const particleHasParent = particle.parentId !== null;
+            if (particleHasParent) {
+                const parent = this.particles[particle.parentId];
+                const parentRotationMatrix = parent._rotationMatrix;
+                const parentGlobalPosition = parent._globalPosition;
+                const rotatedY = particlePosition.x * parentRotationMatrix[1] + particlePosition.y * parentRotationMatrix[4] + particlePosition.z * parentRotationMatrix[7];
+                const rotatedX = particlePosition.x * parentRotationMatrix[0] + particlePosition.y * parentRotationMatrix[3] + particlePosition.z * parentRotationMatrix[6];
+                const rotatedZ = particlePosition.x * parentRotationMatrix[2] + particlePosition.y * parentRotationMatrix[5] + particlePosition.z * parentRotationMatrix[8];
+                particleGlobalPosition.x = parentGlobalPosition.x + rotatedX;
+                particleGlobalPosition.y = parentGlobalPosition.y + rotatedY;
+                particleGlobalPosition.z = parentGlobalPosition.z + rotatedZ;
+                if (this._computeParticleRotation) {
+                    const rotMatrixValues = rotMatrix.m;
+                    particleRotationMatrix[0] =
+                        rotMatrixValues[0] * parentRotationMatrix[0] + rotMatrixValues[1] * parentRotationMatrix[3] + rotMatrixValues[2] * parentRotationMatrix[6];
+                    particleRotationMatrix[1] =
+                        rotMatrixValues[0] * parentRotationMatrix[1] + rotMatrixValues[1] * parentRotationMatrix[4] + rotMatrixValues[2] * parentRotationMatrix[7];
+                    particleRotationMatrix[2] =
+                        rotMatrixValues[0] * parentRotationMatrix[2] + rotMatrixValues[1] * parentRotationMatrix[5] + rotMatrixValues[2] * parentRotationMatrix[8];
+                    particleRotationMatrix[3] =
+                        rotMatrixValues[4] * parentRotationMatrix[0] + rotMatrixValues[5] * parentRotationMatrix[3] + rotMatrixValues[6] * parentRotationMatrix[6];
+                    particleRotationMatrix[4] =
+                        rotMatrixValues[4] * parentRotationMatrix[1] + rotMatrixValues[5] * parentRotationMatrix[4] + rotMatrixValues[6] * parentRotationMatrix[7];
+                    particleRotationMatrix[5] =
+                        rotMatrixValues[4] * parentRotationMatrix[2] + rotMatrixValues[5] * parentRotationMatrix[5] + rotMatrixValues[6] * parentRotationMatrix[8];
+                    particleRotationMatrix[6] =
+                        rotMatrixValues[8] * parentRotationMatrix[0] + rotMatrixValues[9] * parentRotationMatrix[3] + rotMatrixValues[10] * parentRotationMatrix[6];
+                    particleRotationMatrix[7] =
+                        rotMatrixValues[8] * parentRotationMatrix[1] + rotMatrixValues[9] * parentRotationMatrix[4] + rotMatrixValues[10] * parentRotationMatrix[7];
+                    particleRotationMatrix[8] =
+                        rotMatrixValues[8] * parentRotationMatrix[2] + rotMatrixValues[9] * parentRotationMatrix[5] + rotMatrixValues[10] * parentRotationMatrix[8];
+                }
+            }
+            else {
+                particleGlobalPosition.x = 0;
+                particleGlobalPosition.y = 0;
+                particleGlobalPosition.z = 0;
+                if (this._computeParticleRotation) {
+                    const rotMatrixValues = rotMatrix.m;
+                    particleRotationMatrix[0] = rotMatrixValues[0];
+                    particleRotationMatrix[1] = rotMatrixValues[1];
+                    particleRotationMatrix[2] = rotMatrixValues[2];
+                    particleRotationMatrix[3] = rotMatrixValues[4];
+                    particleRotationMatrix[4] = rotMatrixValues[5];
+                    particleRotationMatrix[5] = rotMatrixValues[6];
+                    particleRotationMatrix[6] = rotMatrixValues[8];
+                    particleRotationMatrix[7] = rotMatrixValues[9];
+                    particleRotationMatrix[8] = rotMatrixValues[10];
+                }
+            }
+            const pivotBackTranslation = tempVectors[11];
+            if (particle.translateFromPivot) {
+                pivotBackTranslation.setAll(0.0);
+            }
+            else {
+                pivotBackTranslation.copyFrom(particle.pivot);
+            }
+            // positions
+            const tmpVertex = tempVectors[0];
+            tmpVertex.copyFrom(particle.position);
+            const vertexX = tmpVertex.x - particle.pivot.x;
+            const vertexY = tmpVertex.y - particle.pivot.y;
+            const vertexZ = tmpVertex.z - particle.pivot.z;
+            let rotatedX = vertexX * particleRotationMatrix[0] + vertexY * particleRotationMatrix[3] + vertexZ * particleRotationMatrix[6];
+            let rotatedY = vertexX * particleRotationMatrix[1] + vertexY * particleRotationMatrix[4] + vertexZ * particleRotationMatrix[7];
+            let rotatedZ = vertexX * particleRotationMatrix[2] + vertexY * particleRotationMatrix[5] + vertexZ * particleRotationMatrix[8];
+            rotatedX += pivotBackTranslation.x;
+            rotatedY += pivotBackTranslation.y;
+            rotatedZ += pivotBackTranslation.z;
+            const px = (positions32[pindex] = particleGlobalPosition.x + camAxisX.x * rotatedX + camAxisY.x * rotatedY + camAxisZ.x * rotatedZ);
+            const py = (positions32[pindex + 1] = particleGlobalPosition.y + camAxisX.y * rotatedX + camAxisY.y * rotatedY + camAxisZ.y * rotatedZ);
+            const pz = (positions32[pindex + 2] = particleGlobalPosition.z + camAxisX.z * rotatedX + camAxisY.z * rotatedY + camAxisZ.z * rotatedZ);
+            if (this._computeBoundingBox) {
+                minimum.minimizeInPlaceFromFloats(px, py, pz);
+                maximum.maximizeInPlaceFromFloats(px, py, pz);
+            }
+            if (this._computeParticleColor && particle.color) {
+                const color = particle.color;
+                const colors32 = this._colors32;
+                colors32[cindex] = color.r;
+                colors32[cindex + 1] = color.g;
+                colors32[cindex + 2] = color.b;
+                colors32[cindex + 3] = color.a;
+            }
+            if (this._computeParticleTexture && particle.uv) {
+                const uv = particle.uv;
+                const uvs32 = this._uvs32;
+                uvs32[uindex] = uv.x;
+                uvs32[uindex + 1] = uv.y;
+            }
+        }
+        // if the VBO must be updated
+        if (mesh) {
+            if (update) {
+                if (this._computeParticleColor) {
+                    mesh.updateVerticesData(VertexBuffer.ColorKind, colors32, false, false);
+                }
+                if (this._computeParticleTexture) {
+                    mesh.updateVerticesData(VertexBuffer.UVKind, uvs32, false, false);
+                }
+                mesh.updateVerticesData(VertexBuffer.PositionKind, positions32, false, false);
+            }
+            if (this._computeBoundingBox) {
+                if (mesh.hasBoundingInfo) {
+                    mesh.getBoundingInfo().reConstruct(minimum, maximum, mesh._worldMatrix);
+                }
+                else {
+                    mesh.buildBoundingInfo(minimum, maximum, mesh._worldMatrix);
+                }
+            }
+        }
+        this.afterUpdateParticles(start, end, update);
+        return this;
+    }
+    /**
+     * Disposes the PCS.
+     */
+    dispose() {
+        this.mesh?.dispose();
+        this.vars = null;
+        // drop references to internal big arrays for the GC
+        this._positions = null;
+        this._indices = null;
+        this._normals = null;
+        this._uvs = null;
+        this._colors = null;
+        this._indices32 = null;
+        this._positions32 = null;
+        this._uvs32 = null;
+        this._colors32 = null;
+    }
+    /**
+     * Visibility helper : Recomputes the visible size according to the mesh bounding box
+     * doc :
+     * @returns the PCS.
+     */
+    refreshVisibleSize() {
+        if (!this._isVisibilityBoxLocked) {
+            this.mesh?.refreshBoundingInfo();
+        }
+        return this;
+    }
+    /**
+     * Visibility helper : Sets the size of a visibility box, this sets the underlying mesh bounding box.
+     * @param size the size (float) of the visibility box
+     * note : this doesn't lock the PCS mesh bounding box.
+     * doc :
+     */
+    setVisibilityBox(size) {
+        if (!this.mesh) {
+            return;
+        }
+        const vis = size / 2;
+        this.mesh.buildBoundingInfo(new Vector3(-vis, -vis, -vis), new Vector3(vis, vis, vis));
+    }
+    /**
+     * Gets whether the PCS is always visible or not
+     * doc :
+     */
+    get isAlwaysVisible() {
+        return this._alwaysVisible;
+    }
+    /**
+     * Sets the PCS as always visible or not
+     * doc :
+     */
+    set isAlwaysVisible(val) {
+        if (!this.mesh) {
+            return;
+        }
+        this._alwaysVisible = val;
+        this.mesh.alwaysSelectAsActiveMesh = val;
+    }
+    /**
+     * Tells to `setParticles()` to compute the particle rotations or not
+     * Default value : false. The PCS is faster when it's set to false
+     * Note : particle rotations are only applied to parent particles
+     * Note : the particle rotations aren't stored values, so setting `computeParticleRotation` to false will prevents the particle to rotate
+     */
+    set computeParticleRotation(val) {
+        this._computeParticleRotation = val;
+    }
+    /**
+     * Tells to `setParticles()` to compute the particle colors or not.
+     * Default value : true. The PCS is faster when it's set to false.
+     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
+     */
+    set computeParticleColor(val) {
+        this._computeParticleColor = val;
+    }
+    set computeParticleTexture(val) {
+        this._computeParticleTexture = val;
+    }
+    /**
+     * Gets if `setParticles()` computes the particle colors or not.
+     * Default value : false. The PCS is faster when it's set to false.
+     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
+     */
+    get computeParticleColor() {
+        return this._computeParticleColor;
+    }
+    /**
+     * Gets if `setParticles()` computes the particle textures or not.
+     * Default value : false. The PCS is faster when it's set to false.
+     * Note : the particle textures are stored values, so setting `computeParticleTexture` to false will keep yet the last colors set.
+     */
+    get computeParticleTexture() {
+        return this._computeParticleTexture;
+    }
+    /**
+     * Tells to `setParticles()` to compute or not the mesh bounding box when computing the particle positions.
+     */
+    set computeBoundingBox(val) {
+        this._computeBoundingBox = val;
+    }
+    /**
+     * Gets if `setParticles()` computes or not the mesh bounding box when computing the particle positions.
+     */
+    get computeBoundingBox() {
+        return this._computeBoundingBox;
+    }
+    // =======================================================================
+    // Particle behavior logic
+    // these following methods may be overwritten by users to fit their needs
+    /**
+     * This function does nothing. It may be overwritten to set all the particle first values.
+     * The PCS doesn't call this function, you may have to call it by your own.
+     * doc :
+     */
+    initParticles() { }
+    /**
+     * This function does nothing. It may be overwritten to recycle a particle
+     * The PCS doesn't call this function, you can to call it
+     * doc :
+     * @param particle The particle to recycle
+     * @returns the recycled particle
+     */
+    recycleParticle(particle) {
+        return particle;
+    }
+    /**
+     * Updates a particle : this function should  be overwritten by the user.
+     * It is called on each particle by `setParticles()`. This is the place to code each particle behavior.
+     * doc :
+     * @example : just set a particle position or velocity and recycle conditions
+     * @param particle The particle to update
+     * @returns the updated particle
+     */
+    updateParticle(particle) {
+        return particle;
+    }
+    /**
+     * This will be called before any other treatment by `setParticles()` and will be passed three parameters.
+     * This does nothing and may be overwritten by the user.
+     * @param start the particle index in the particle array where to start to iterate, same than the value passed to setParticle()
+     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param update the boolean update value actually passed to setParticles()
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    beforeUpdateParticles(start, stop, update) { }
+    /**
+     * This will be called  by `setParticles()` after all the other treatments and just before the actual mesh update.
+     * This will be passed three parameters.
+     * This does nothing and may be overwritten by the user.
+     * @param start the particle index in the particle array where to start to iterate, same than the value passed to setParticle()
+     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
+     * @param update the boolean update value actually passed to setParticles()
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    afterUpdateParticles(start, stop, update) { }
+}
+
+const HCF = HighestCommonFactor;
+/**
+ * Scalar computation library
+ * @deprecated Please use the scalar functions
+ */
+/* eslint-disable @typescript-eslint/naming-convention */
+const Scalar = {
+    ...functions,
+    /**
+     * Two pi constants convenient for computation.
+     */
+    TwoPi: Math.PI * 2,
+    /**
+     * Returns -1 if value is negative and +1 is value is positive.
+     * @param value the value
+     * @returns the value itself if it's equal to zero.
+     */
+    Sign: Math.sign,
+    /**
+     * the log2 of value.
+     * @param value the value to compute log2 of
+     * @returns the log2 of value.
+     */
+    Log2: Math.log2,
+    /**
+     * Returns the highest common factor of two integers.
+     * @param a first parameter
+     * @param b second parameter
+     * @returns HCF of a and b
+     */
+    HCF,
+};
+/* eslint-enable @typescript-eslint/naming-convention */
+
+/**
+ * Indicator of the parsed ply buffer. A standard ready to use splat or an array of positions for a point cloud
+ */
+var Mode;
+(function (Mode) {
+    Mode[Mode["Splat"] = 0] = "Splat";
+    Mode[Mode["PointCloud"] = 1] = "PointCloud";
+    Mode[Mode["Mesh"] = 2] = "Mesh";
+})(Mode || (Mode = {}));
+/** @internal */
+var ElementMode;
+(function (ElementMode) {
+    ElementMode[ElementMode["Vertex"] = 0] = "Vertex";
+    ElementMode[ElementMode["Chunk"] = 1] = "Chunk";
+})(ElementMode || (ElementMode = {}));
+/**
+ * @experimental
+ * SPLAT file type loader.
+ * This is a babylon scene loader plugin.
+ */
+class SPLATFileLoader {
+    /**
+     * Creates loader for gaussian splatting files
+     * @param loadingOptions options for loading and parsing splat and PLY files.
+     */
+    constructor(loadingOptions = SPLATFileLoader._DefaultLoadingOptions) {
+        /**
+         * Defines the name of the plugin.
+         */
+        this.name = SPLATFileLoaderMetadata.name;
+        this._assetContainer = null;
+        /**
+         * Defines the extensions the splat loader is able to load.
+         * force data to come in as an ArrayBuffer
+         */
+        this.extensions = SPLATFileLoaderMetadata.extensions;
+        this._loadingOptions = loadingOptions;
+    }
+    /** @internal */
+    createPlugin(options) {
+        return new SPLATFileLoader(options[SPLATFileLoaderMetadata.name]);
+    }
+    /**
+     * Imports  from the loaded gaussian splatting data and adds them to the scene
+     * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
+     * @param scene the scene the meshes should be added to
+     * @param data the gaussian splatting data to load
+     * @param rootUrl root url to load from
+     * @param onProgress callback called while file is loading
+     * @param fileName Defines the name of the file to load
+     * @returns a promise containing the loaded meshes, particles, skeletons and animations
+     */
+    async importMeshAsync(meshesNames, scene, data, rootUrl, onProgress, fileName) {
+        return this._parse(meshesNames, scene, data, rootUrl).then((meshes) => {
+            return {
+                meshes: meshes,
+                particleSystems: [],
+                skeletons: [],
+                animationGroups: [],
+                transformNodes: [],
+                geometries: [],
+                lights: [],
+                spriteManagers: [],
+            };
+        });
+    }
+    static _BuildPointCloud(pointcloud, data) {
+        if (!data.byteLength) {
+            return false;
+        }
+        const uBuffer = new Uint8Array(data);
+        const fBuffer = new Float32Array(data);
+        // parsed array contains room for position(3floats), normal(3floats), color (4b), quantized quaternion (4b)
+        const rowLength = 3 * 4 + 3 * 4 + 4 + 4;
+        const vertexCount = uBuffer.length / rowLength;
+        const pointcloudfunc = function (particle, i) {
+            const x = fBuffer[8 * i + 0];
+            const y = fBuffer[8 * i + 1];
+            const z = fBuffer[8 * i + 2];
+            particle.position = new Vector3(x, y, z);
+            const r = uBuffer[rowLength * i + 24 + 0] / 255;
+            const g = uBuffer[rowLength * i + 24 + 1] / 255;
+            const b = uBuffer[rowLength * i + 24 + 2] / 255;
+            particle.color = new Color4(r, g, b, 1);
+        };
+        pointcloud.addPoints(vertexCount, pointcloudfunc);
+        return true;
+    }
+    static _BuildMesh(scene, parsedPLY) {
+        const mesh = new Mesh("PLYMesh", scene);
+        const uBuffer = new Uint8Array(parsedPLY.data);
+        const fBuffer = new Float32Array(parsedPLY.data);
+        const rowLength = 3 * 4 + 3 * 4 + 4 + 4;
+        const vertexCount = uBuffer.length / rowLength;
+        const positions = [];
+        const vertexData = new VertexData();
+        for (let i = 0; i < vertexCount; i++) {
+            const x = fBuffer[8 * i + 0];
+            const y = fBuffer[8 * i + 1];
+            const z = fBuffer[8 * i + 2];
+            positions.push(x, y, z);
+        }
+        if (parsedPLY.hasVertexColors) {
+            const colors = new Float32Array(vertexCount * 4);
+            for (let i = 0; i < vertexCount; i++) {
+                const r = uBuffer[rowLength * i + 24 + 0] / 255;
+                const g = uBuffer[rowLength * i + 24 + 1] / 255;
+                const b = uBuffer[rowLength * i + 24 + 2] / 255;
+                colors[i * 4 + 0] = r;
+                colors[i * 4 + 1] = g;
+                colors[i * 4 + 2] = b;
+                colors[i * 4 + 3] = 1;
+            }
+            vertexData.colors = colors;
+        }
+        vertexData.positions = positions;
+        vertexData.indices = parsedPLY.faces;
+        vertexData.applyToMesh(mesh);
+        return mesh;
+    }
+    _parse(meshesNames, scene, data, rootUrl) {
+        const babylonMeshesArray = []; //The mesh for babylon
+        const parsedPLY = SPLATFileLoader._ConvertPLYToSplat(data);
+        switch (parsedPLY.mode) {
+            case 0 /* Mode.Splat */:
+                {
+                    const gaussianSplatting = new GaussianSplattingMesh("GaussianSplatting", null, scene, this._loadingOptions.keepInRam);
+                    gaussianSplatting._parentContainer = this._assetContainer;
+                    babylonMeshesArray.push(gaussianSplatting);
+                    gaussianSplatting.loadDataAsync(parsedPLY.data);
+                }
+                break;
+            case 1 /* Mode.PointCloud */:
+                {
+                    const pointcloud = new PointsCloudSystem("PointCloud", 1, scene);
+                    if (SPLATFileLoader._BuildPointCloud(pointcloud, parsedPLY.data)) {
+                        return Promise.all([pointcloud.buildMeshAsync()]).then((mesh) => {
+                            babylonMeshesArray.push(mesh[0]);
+                            return babylonMeshesArray;
+                        });
+                    }
+                    else {
+                        pointcloud.dispose();
+                    }
+                }
+                break;
+            case 2 /* Mode.Mesh */:
+                {
+                    if (parsedPLY.faces) {
+                        babylonMeshesArray.push(SPLATFileLoader._BuildMesh(scene, parsedPLY));
+                    }
+                    else {
+                        throw new Error("PLY mesh doesn't contain face informations.");
+                    }
+                }
+                break;
+            default:
+                throw new Error("Unsupported Splat mode");
+        }
+        return Promise.resolve(babylonMeshesArray);
+    }
+    /**
+     * Load into an asset container.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @returns The loaded asset container
+     */
+    loadAssetContainerAsync(scene, data, rootUrl) {
+        const container = new AssetContainer(scene);
+        this._assetContainer = container;
+        return this.importMeshAsync(null, scene, data, rootUrl)
+            .then((result) => {
+            result.meshes.forEach((mesh) => container.meshes.push(mesh));
+            // mesh material will be null before 1st rendered frame.
+            this._assetContainer = null;
+            return container;
+        })
+            .catch((ex) => {
+            this._assetContainer = null;
+            throw ex;
+        });
+    }
+    /**
+     * Imports all objects from the loaded OBJ data and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data the OBJ data to load
+     * @param rootUrl root url to load from
+     * @returns a promise which completes when objects have been loaded to the scene
+     */
+    loadAsync(scene, data, rootUrl) {
+        //Get the 3D model
+        return this.importMeshAsync(null, scene, data, rootUrl).then(() => {
+            // return void
+        });
+    }
+    /**
+     * Code from https://github.com/dylanebert/gsplat.js/blob/main/src/loaders/PLYLoader.ts Under MIT license
+     * 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 _ConvertPLYToSplat(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 { mode: 0 /* Mode.Splat */, data: data };
+        }
+        const vertexCount = parseInt(/element vertex (\d+)\n/.exec(header)[1]);
+        const faceElement = /element face (\d+)\n/.exec(header);
+        const chunkElement = /element chunk (\d+)\n/.exec(header);
+        let faceCount = 0;
+        let chunkCount = 0;
+        if (faceElement) {
+            faceCount = parseInt(faceElement[1]);
+        }
+        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 chunkMode = 1 /* ElementMode.Chunk */;
+        const vertexProperties = [];
+        const chunkProperties = [];
+        const filtered = header.slice(0, headerEndIndex).split("\n");
+        for (const prop of filtered) {
+            if (prop.startsWith("property ")) {
+                const [, type, name] = prop.split(" ");
+                if (chunkMode == 1 /* ElementMode.Chunk */) {
+                    chunkProperties.push({ name, type, offset: rowChunkOffset });
+                    rowChunkOffset += offsets[type];
+                }
+                else if (chunkMode == 0 /* ElementMode.Vertex */) {
+                    vertexProperties.push({ name, type, offset: rowVertexOffset });
+                    rowVertexOffset += offsets[type];
+                }
+                if (!offsets[type]) {
+                    Logger.Warn(`Unsupported property type: ${type}.`);
+                }
+            }
+            else if (prop.startsWith("element ")) {
+                const [, type] = prop.split(" ");
+                if (type == "chunk") {
+                    chunkMode = 1 /* ElementMode.Chunk */;
+                }
+                else if (type == "vertex") {
+                    chunkMode = 0 /* ElementMode.Vertex */;
+                }
+            }
+        }
+        const rowVertexLength = rowVertexOffset;
+        const rowChunkLength = rowChunkOffset;
+        const rowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
+        const SH_C0 = 0.28209479177387814;
+        let offset = 0;
+        const dataView = new DataView(data, headerEndIndex + headerEnd.length);
+        const buffer = new ArrayBuffer(rowOutputLength * vertexCount);
+        const q = new Quaternion();
+        const temp3 = TmpVectors.Vector3[0];
+        const unpackUnorm = (value, bits) => {
+            const t = (1 << bits) - 1;
+            return (value & t) / t;
+        };
+        const unpack111011 = (value, result) => {
+            result.x = unpackUnorm(value >>> 21, 11);
+            result.y = unpackUnorm(value >>> 11, 10);
+            result.z = unpackUnorm(value, 11);
+        };
+        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;
+        };
+        // 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;
+            }
+        };
+        const compressedChunks = new Array(chunkCount);
+        for (let i = 0; i < chunkCount; i++) {
+            const currentChunk = { min: new Vector3(), max: new Vector3(), minScale: new Vector3(), maxScale: new Vector3() };
+            compressedChunks[i] = currentChunk;
+            for (let propertyIndex = 0; propertyIndex < chunkProperties.length; propertyIndex++) {
+                const property = chunkProperties[propertyIndex];
+                let value;
+                switch (property.type) {
+                    case "float":
+                        value = dataView.getFloat32(property.offset + offset, true);
+                        break;
+                    default:
+                        //throw new Error(`Unsupported property type: ${property.type}`);
+                        continue;
+                }
+                switch (property.name) {
+                    case "min_x":
+                        currentChunk.min.x = value;
+                        break;
+                    case "min_y":
+                        currentChunk.min.y = value;
+                        break;
+                    case "min_z":
+                        currentChunk.min.z = value;
+                        break;
+                    case "max_x":
+                        currentChunk.max.x = value;
+                        break;
+                    case "max_y":
+                        currentChunk.max.y = value;
+                        break;
+                    case "max_z":
+                        currentChunk.max.z = value;
+                        break;
+                    case "min_scale_x":
+                        currentChunk.minScale.x = value;
+                        break;
+                    case "min_scale_y":
+                        currentChunk.minScale.y = value;
+                        break;
+                    case "min_scale_z":
+                        currentChunk.minScale.z = value;
+                        break;
+                    case "max_scale_x":
+                        currentChunk.maxScale.x = value;
+                        break;
+                    case "max_scale_y":
+                        currentChunk.maxScale.y = value;
+                        break;
+                    case "max_scale_z":
+                        currentChunk.maxScale.z = value;
+                        break;
+                }
+            }
+            offset += rowChunkLength;
+        }
+        for (let i = 0; i < vertexCount; i++) {
+            const position = new Float32Array(buffer, i * rowOutputLength, 3);
+            const scale = new Float32Array(buffer, i * rowOutputLength + 12, 3);
+            const rgba = new Uint8ClampedArray(buffer, i * rowOutputLength + 24, 4);
+            const rot = new Uint8ClampedArray(buffer, i * rowOutputLength + 28, 4);
+            const chunkIndex = i >> 8;
+            let r0 = 255;
+            let r1 = 0;
+            let r2 = 0;
+            let r3 = 0;
+            for (let propertyIndex = 0; propertyIndex < vertexProperties.length; propertyIndex++) {
+                const property = vertexProperties[propertyIndex];
+                let value;
+                switch (property.type) {
+                    case "float":
+                        value = dataView.getFloat32(offset + property.offset, true);
+                        break;
+                    case "int":
+                        value = dataView.getInt32(offset + property.offset, true);
+                        break;
+                    case "uint":
+                        value = dataView.getUint32(offset + property.offset, true);
+                        break;
+                    case "double":
+                        value = dataView.getFloat64(offset + property.offset, true);
+                        break;
+                    case "uchar":
+                        value = dataView.getUint8(offset + property.offset);
+                        break;
+                    default:
+                        //throw new Error(`Unsupported property type: ${property.type}`);
+                        continue;
+                }
+                switch (property.name) {
+                    case "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 "packed_rotation":
+                        {
+                            unpackRot(value, q);
+                            r0 = q.w;
+                            r1 = q.z;
+                            r2 = q.y;
+                            r3 = q.x;
+                        }
+                        break;
+                    case "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 "packed_color":
+                        unpack8888(value, rgba);
+                        break;
+                    case "x":
+                        position[0] = value;
+                        break;
+                    case "y":
+                        position[1] = value;
+                        break;
+                    case "z":
+                        position[2] = value;
+                        break;
+                    case "scale_0":
+                        scale[0] = Math.exp(value);
+                        break;
+                    case "scale_1":
+                        scale[1] = Math.exp(value);
+                        break;
+                    case "scale_2":
+                        scale[2] = Math.exp(value);
+                        break;
+                    case "diffuse_red":
+                    case "red":
+                        rgba[0] = value;
+                        break;
+                    case "diffuse_green":
+                    case "green":
+                        rgba[1] = value;
+                        break;
+                    case "diffuse_blue":
+                    case "blue":
+                        rgba[2] = value;
+                        break;
+                    case "f_dc_0":
+                        rgba[0] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_1":
+                        rgba[1] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_2":
+                        rgba[2] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "f_dc_3":
+                        rgba[3] = (0.5 + SH_C0 * value) * 255;
+                        break;
+                    case "opacity":
+                        rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
+                        break;
+                    case "rot_0":
+                        r0 = value;
+                        break;
+                    case "rot_1":
+                        r1 = value;
+                        break;
+                    case "rot_2":
+                        r2 = value;
+                        break;
+                    case "rot_3":
+                        r3 = value;
+                        break;
+                }
+            }
+            q.set(r1, r2, r3, r0);
+            q.normalize();
+            rot[0] = q.w * 128 + 128;
+            rot[1] = q.x * 128 + 128;
+            rot[2] = q.y * 128 + 128;
+            rot[3] = q.z * 128 + 128;
+            offset += rowVertexLength;
+        }
+        // faces
+        const faces = [];
+        if (faceCount) {
+            for (let i = 0; i < faceCount; i++) {
+                const faceVertexCount = dataView.getUint8(offset);
+                if (faceVertexCount != 3) {
+                    continue; // only support triangles
+                }
+                offset += 1;
+                for (let j = 0; j < faceVertexCount; j++) {
+                    const vertexIndex = dataView.getUint32(offset + (2 - j) * 4, true); // change face winding
+                    faces.push(vertexIndex);
+                }
+                offset += 12;
+            }
+        }
+        // early exit for chunked/quantized ply
+        if (chunkCount) {
+            return { mode: 0 /* Mode.Splat */, data: buffer, faces: faces, hasVertexColors: false };
+        }
+        // count available properties. if all necessary are present then it's a splat. Otherwise, it's a point cloud
+        // if faces are found, then it's a standard mesh
+        let propertyCount = 0;
+        let propertyColorCount = 0;
+        const splatProperties = ["x", "y", "z", "scale_0", "scale_1", "scale_2", "opacity", "rot_0", "rot_1", "rot_2", "rot_3"];
+        const splatColorProperties = ["red", "green", "blue", "f_dc_0", "f_dc_1", "f_dc_2"];
+        for (let propertyIndex = 0; propertyIndex < vertexProperties.length; propertyIndex++) {
+            const property = vertexProperties[propertyIndex];
+            if (splatProperties.includes(property.name)) {
+                propertyCount++;
+            }
+            if (splatColorProperties.includes(property.name)) {
+                propertyColorCount++;
+            }
+        }
+        const hasMandatoryProperties = propertyCount == splatProperties.length && propertyColorCount == 3;
+        const currentMode = faceCount ? 2 /* Mode.Mesh */ : hasMandatoryProperties ? 0 /* Mode.Splat */ : 1 /* Mode.PointCloud */;
+        // parsed ready ready to be used as a splat
+        return { mode: currentMode, data: buffer, faces: faces, hasVertexColors: !!propertyColorCount };
+    }
+}
+SPLATFileLoader._DefaultLoadingOptions = {
+    keepInRam: false,
+};
+// Add this loader into the register plugin
+registerSceneLoaderPlugin(new SPLATFileLoader());
+
+export { SPLATFileLoader };
+//# sourceMappingURL=splatFileLoader-D53T0YTp.esm.js.map