@babylonjs/viewer 7.28.0-alpha → 7.29.0

package/dist/chunks/splatFileLoader-BO6la5-H.esm.js

@@ -1,3340 +0,0 @@
-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 SPLATFileLoaderMetadata, w as registerSceneLoaderPlugin } from './index-D0E1moDr.esm.js';
-import './fogFragment-CizzLpaY.esm.js';
-import './logDepthDeclaration-CgsbzCKe.esm.js';
-import './logDepthVertex-KLC5ytc9.esm.js';
-import { R as RawTexture } from './rawTexture-C-BSm1U5.esm.js';
-import './thinInstanceMesh-CkU4tmTv.esm.js';
-import { A as AssetContainer } from './assetContainer-C-F4HA2b.esm.js';
-import { S as StandardMaterial } from './standardMaterial-BH9cL7Zd.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;
-    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 = InternalPickForMesh(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 = InternalPickForMesh(pickingInfo, rayFunction, mesh, tmpMatrix, fastCheck, onlyBoundingInfo, trianglePredicate, true);
-                    if (result) {
-                        pickingInfo = result;
-                        pickingInfo.thinInstanceIndex = index;
-                        if (fastCheck) {
-                            return pickingInfo;
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const result = InternalPickForMesh(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;
-    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 = InternalPickForMesh(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 = InternalPickForMesh(null, rayFunction, mesh, tmpMatrix, false, false, trianglePredicate, true);
-                    if (result) {
-                        result.thinInstanceIndex = index;
-                        pickingInfos.push(result);
-                    }
-                }
-            }
-        }
-        else {
-            const result = InternalPickForMesh(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) { }
-}
-
-/**
- * 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 = {}));
-/**
- * @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);
-        let faceCount = 0;
-        if (faceElement) {
-            faceCount = parseInt(faceElement[1]);
-        }
-        let rowOffset = 0;
-        const offsets = {
-            double: 8,
-            int: 4,
-            uint: 4,
-            float: 4,
-            short: 2,
-            ushort: 2,
-            uchar: 1,
-            list: 0,
-        };
-        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.Warn(`Unsupported property type: ${type}.`);
-            }
-        }
-        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;
-                    case "uint":
-                        value = dataView.getUint32(property.offset + i * rowOffset, true);
-                        break;
-                    case "double":
-                        value = dataView.getFloat64(property.offset + i * rowOffset, true);
-                        break;
-                    case "uchar":
-                        value = dataView.getUint8(property.offset + i * rowOffset);
-                        break;
-                    default:
-                        //throw new Error(`Unsupported property type: ${property.type}`);
-                        continue;
-                }
-                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 "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;
-        }
-        // faces
-        const faces = [];
-        if (faceCount) {
-            let offset = rowOffset * vertexCount;
-            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;
-            }
-        }
-        // 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 < properties.length; propertyIndex++) {
-            const property = properties[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-BO6la5-H.esm.js.map