@babylonjs/viewer 7.37.1-alpha → 7.37.1

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

@@ -1,4312 +0,0 @@
-import { i as ShaderStore, R as RegisterClass, z as PushMaterial, J as PrepareDefinesForMisc, K as PrepareDefinesForFrameBoundValues, N as PrepareDefinesForAttributes, Q as PrepareAttributesForInstances, W as PrepareUniformsAndSamplersList, X as addClipPlaneUniforms, Y as Camera, Z as bindClipPlane, _ as BindFogParameters, $ as BindLogDepth, a0 as SerializationHelper, a1 as MaterialDefines, V as VertexBuffer, a2 as functions, a3 as HighestCommonFactor, M as Mesh, a4 as Matrix, v as Vector3, x as VertexData, a5 as SubMesh, a6 as TmpVectors, L as Logger, a7 as runCoroutineAsync, T as Tools, a8 as ToHalfFloat, C as Constants, a9 as runCoroutineSync, u as Vector2, aa as createYieldingScheduler, m as Color4, ab as Quaternion, ac as BuildArray, ad as Epsilon, ae as IntersectionInfo, E as EngineStore, af as PickingInfo, ag as _ImportHelper, ah as Scene, s as Color3, ai as Vector4, aj as RandomRange, B as BaseTexture, ak as SPLATFileLoaderMetadata, y as registerSceneLoaderPlugin } from './index-ft-NqTCE.esm.js';
-import './fogFragment-h9FPnPoM.esm.js';
-import './logDepthDeclaration-BkgrzFr-.esm.js';
-import './logDepthVertex-C-tEJ4YD.esm.js';
-import './fogFragment-B4-SlSDo.esm.js';
-import './logDepthDeclaration-uuaJZU_f.esm.js';
-import './meshUboDeclaration-BWZH2NAD.esm.js';
-import './logDepthVertex-DiLmNz-k.esm.js';
-import { R as RawTexture } from './rawTexture-BdnztUXL.esm.js';
-import './thinInstanceMesh-C46IYDPb.esm.js';
-import { A as AssetContainer } from './assetContainer-BDuQ9TBc.esm.js';
-import { S as StandardMaterial } from './standardMaterial-DsjgYxIo.esm.js';
-
-// Do not edit.
-const name$9 = "gaussianSplattingFragmentDeclaration";
-const shader$9 = `vec4 gaussianColor(vec4 inColor)
-{float A=-dot(vPosition,vPosition);if (A<-4.0) discard;float B=exp(A)*inColor.a;
-#include<logDepthFragment>
-vec3 color=inColor.rgb;
-#ifdef FOG
-#include<fogFragment>
-#endif
-return vec4(color,B);}
-`;
-// Sideeffect
-ShaderStore.IncludesShadersStore[name$9] = shader$9;
-
-// Do not edit.
-const name$8 = "gaussianSplattingPixelShader";
-const shader$8 = `#include<clipPlaneFragmentDeclaration>
-#include<logDepthDeclaration>
-#include<fogFragmentDeclaration>
-varying vec4 vColor;varying vec2 vPosition;
-#include<gaussianSplattingFragmentDeclaration>
-void main () { 
-#include<clipPlaneFragment>
-gl_FragColor=gaussianColor(vColor);}
-`;
-// Sideeffect
-ShaderStore.ShadersStore[name$8] = shader$8;
-/** @internal */
-const gaussianSplattingPixelShader = { name: name$8, shader: shader$8 };
-
-var gaussianSplatting_fragment$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    gaussianSplattingPixelShader: gaussianSplattingPixelShader
-});
-
-// Do not edit.
-const name$7 = "gaussianSplattingVertexDeclaration";
-const shader$7 = `attribute vec2 position;uniform mat4 view;uniform mat4 projection;uniform mat4 world;uniform vec4 vEyePosition;`;
-// Sideeffect
-ShaderStore.IncludesShadersStore[name$7] = shader$7;
-
-// Do not edit.
-const name$6 = "gaussianSplattingUboDeclaration";
-const shader$6 = `#include<sceneUboDeclaration>
-#include<meshUboDeclaration>
-attribute vec2 position;`;
-// Sideeffect
-ShaderStore.IncludesShadersStore[name$6] = shader$6;
-
-// Do not edit.
-const name$5 = "gaussianSplatting";
-const shader$5 = `#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);}
-#if SH_DEGREE>0
-ivec2 getDataUVint(float index,vec2 textureSize) {float y=floor(index/textureSize.x);float x=index-y*textureSize.x;return ivec2(uint(x+0.5),uint(y+0.5));}
-#endif
-struct Splat {vec4 center;vec4 color;vec4 covA;vec4 covB;
-#if SH_DEGREE>0
-uvec4 sh0; 
-#endif
-#if SH_DEGREE>1
-uvec4 sh1;
-#endif
-#if SH_DEGREE>2
-uvec4 sh2;
-#endif
-};Splat readSplat(float splatIndex)
-{Splat splat;vec2 splatUV=getDataUV(splatIndex,dataTextureSize);splat.center=texture2D(centersTexture,splatUV);splat.color=texture2D(colorsTexture,splatUV);splat.covA=texture2D(covariancesATexture,splatUV)*splat.center.w;splat.covB=texture2D(covariancesBTexture,splatUV)*splat.center.w;
-#if SH_DEGREE>0
-ivec2 splatUVint=getDataUVint(splatIndex,dataTextureSize);splat.sh0=texelFetch(shTexture0,splatUVint,0);
-#endif
-#if SH_DEGREE>1
-splat.sh1=texelFetch(shTexture1,splatUVint,0);
-#endif
-#if SH_DEGREE>2
-splat.sh2=texelFetch(shTexture2,splatUVint,0);
-#endif
-return splat;}
-#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
-vec3 computeColorFromSHDegree(vec3 dir,const vec3 sh[16])
-{const float SH_C0=0.28209479;const float SH_C1=0.48860251;float SH_C2[5];SH_C2[0]=1.092548430;SH_C2[1]=-1.09254843;SH_C2[2]=0.315391565;SH_C2[3]=-1.09254843;SH_C2[4]=0.546274215;float SH_C3[7];SH_C3[0]=-0.59004358;SH_C3[1]=2.890611442;SH_C3[2]=-0.45704579;SH_C3[3]=0.373176332;SH_C3[4]=-0.45704579;SH_C3[5]=1.445305721;SH_C3[6]=-0.59004358;vec3 result=/*SH_C0**/sh[0];
-#if SH_DEGREE>0
-float x=dir.x;float y=dir.y;float z=dir.z;result+=- SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3];
-#if SH_DEGREE>1
-float xx=x*x,yy=y*y,zz=z*z;float xy=x*y,yz=y*z,xz=x*z;result+=
-SH_C2[0]*xy*sh[4] +
-SH_C2[1]*yz*sh[5] +
-SH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +
-SH_C2[3]*xz*sh[7] +
-SH_C2[4]*(xx-yy)*sh[8];
-#if SH_DEGREE>2
-result+=
-SH_C3[0]*y*(3.0f*xx-yy)*sh[9] +
-SH_C3[1]*xy*z*sh[10] +
-SH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +
-SH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +
-SH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +
-SH_C3[5]*z*(xx-yy)*sh[14] +
-SH_C3[6]*x*(xx-3.0f*yy)*sh[15];
-#endif
-#endif
-#endif
-return result;}
-vec4 decompose(uint value)
-{vec4 components=vec4(
-float((value ) & 255u),
-float((value>>uint( 8)) & 255u),
-float((value>>uint(16)) & 255u),
-float((value>>uint(24)) & 255u));return components*vec4(2./255.)-vec4(1.);}
-vec3 computeSH(Splat splat,vec3 color,vec3 dir)
-{vec3 sh[16];sh[0]=color;
-#if SH_DEGREE>0
-vec4 sh00=decompose(splat.sh0.x);vec4 sh01=decompose(splat.sh0.y);vec4 sh02=decompose(splat.sh0.z);sh[1]=vec3(sh00.x,sh00.y,sh00.z);sh[2]=vec3(sh00.w,sh01.x,sh01.y);sh[3]=vec3(sh01.z,sh01.w,sh02.x);
-#endif
-#if SH_DEGREE>1
-vec4 sh03=decompose(splat.sh0.w);vec4 sh04=decompose(splat.sh1.x);vec4 sh05=decompose(splat.sh1.y);sh[4]=vec3(sh02.y,sh02.z,sh02.w);sh[5]=vec3(sh03.x,sh03.y,sh03.z);sh[6]=vec3(sh03.w,sh04.x,sh04.y);sh[7]=vec3(sh04.z,sh04.w,sh05.x);sh[8]=vec3(sh05.y,sh05.z,sh05.w);
-#endif
-#if SH_DEGREE>2
-vec4 sh06=decompose(splat.sh1.z);vec4 sh07=decompose(splat.sh1.w);vec4 sh08=decompose(splat.sh2.x);vec4 sh09=decompose(splat.sh2.y);vec4 sh10=decompose(splat.sh2.z);vec4 sh11=decompose(splat.sh2.w);sh[9]=vec3(sh06.x,sh06.y,sh06.z);sh[10]=vec3(sh06.w,sh07.x,sh07.y);sh[11]=vec3(sh07.z,sh07.w,sh08.x);sh[12]=vec3(sh08.y,sh08.z,sh08.w);sh[13]=vec3(sh09.x,sh09.y,sh09.z);sh[14]=vec3(sh09.w,sh10.x,sh10.y);sh[15]=vec3(sh10.z,sh10.w,sh11.x); 
-#endif
-return computeColorFromSHDegree(dir,sh);}
-#else
-vec3 computeSH(Splat splat,vec3 color,vec3 dir)
-{return color;}
-#endif
-vec4 gaussianSplatting(vec2 meshPos,vec3 worldPos,vec2 scale,vec3 covA,vec3 covB,mat4 worldMatrix,mat4 viewMatrix,mat4 projectionMatrix)
-{mat4 modelView=viewMatrix*worldMatrix;vec4 camspace=viewMatrix*vec4(worldPos,1.);vec4 pos2d=projectionMatrix*camspace;float bounds=1.2*pos2d.w;if (pos2d.z<-pos2d.w || pos2d.x<-bounds || pos2d.x>bounds
-|| pos2d.y<-bounds || pos2d.y>bounds) {return vec4(0.0,0.0,2.0,1.0);}
-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 vec4(0.0,0.0,2.0,1.0);}
-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);vec2 vCenter=vec2(pos2d);return vec4(
-vCenter 
-+ ((meshPos.x*majorAxis
-+ meshPos.y*minorAxis)*invViewport*pos2d.w)*scale,pos2d.zw);}`;
-// Sideeffect
-ShaderStore.IncludesShadersStore[name$5] = shader$5;
-
-// Do not edit.
-const name$4 = "gaussianSplattingVertexShader";
-const shader$4 = `#include<__decl__gaussianSplattingVertex>
-#ifdef LOGARITHMICDEPTH
-#extension GL_EXT_frag_depth : enable
-#endif
-#include<clipPlaneVertexDeclaration>
-#include<fogVertexDeclaration>
-#include<logDepthDeclaration>
-attribute float splatIndex;uniform vec2 invViewport;uniform vec2 dataTextureSize;uniform vec2 focal;uniform sampler2D covariancesATexture;uniform sampler2D covariancesBTexture;uniform sampler2D centersTexture;uniform sampler2D colorsTexture;
-#if SH_DEGREE>0
-uniform highp usampler2D shTexture0;
-#endif
-#if SH_DEGREE>1
-uniform highp usampler2D shTexture1;
-#endif
-#if SH_DEGREE>2
-uniform highp usampler2D shTexture2;
-#endif
-varying vec4 vColor;varying vec2 vPosition;
-#include<gaussianSplatting>
-void main () {Splat splat=readSplat(splatIndex);vec3 covA=splat.covA.xyz;vec3 covB=vec3(splat.covA.w,splat.covB.xy);vec4 worldPos=world*vec4(splat.center.xyz,1.0);vColor=splat.color;vPosition=position;
-#if SH_DEGREE>0
-vec3 dir=normalize(worldPos.xyz-vEyePosition.xyz);vColor.xyz=computeSH(splat,splat.color.xyz,dir);
-#endif
-gl_Position=gaussianSplatting(position,worldPos.xyz,vec2(1.,1.),covA,covB,world,view,projection);
-#include<clipPlaneVertex>
-#include<fogVertex>
-#include<logDepthVertex>
-}
-`;
-// Sideeffect
-ShaderStore.ShadersStore[name$4] = shader$4;
-/** @internal */
-const gaussianSplattingVertexShader = { name: name$4, shader: shader$4 };
-
-var gaussianSplatting_vertex$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    gaussianSplattingVertexShader: gaussianSplattingVertexShader
-});
-
-// Do not edit.
-const name$3 = "gaussianSplattingFragmentDeclaration";
-const shader$3 = `fn gaussianColor(inColor: vec4f,inPosition: vec2f)->vec4f
-{var A : f32=-dot(inPosition,inPosition);if (A>-4.0)
-{var B: f32=exp(A)*inColor.a;
-#include<logDepthFragment>
-var color: vec3f=inColor.rgb;
-#ifdef FOG
-#include<fogFragment>
-#endif
-return vec4f(color,B);} else {return vec4f(0.0);}}
-`;
-// Sideeffect
-ShaderStore.IncludesShadersStoreWGSL[name$3] = shader$3;
-
-// Do not edit.
-const name$2 = "gaussianSplattingPixelShader";
-const shader$2 = `#include<clipPlaneFragmentDeclaration>
-#include<logDepthDeclaration>
-#include<fogFragmentDeclaration>
-varying vColor: vec4f;varying vPosition: vec2f;
-#include<gaussianSplattingFragmentDeclaration>
-@fragment
-fn main(input: FragmentInputs)->FragmentOutputs {
-#include<clipPlaneFragment>
-fragmentOutputs.color=gaussianColor(input.vColor,input.vPosition);}
-`;
-// Sideeffect
-ShaderStore.ShadersStoreWGSL[name$2] = shader$2;
-/** @internal */
-const gaussianSplattingPixelShaderWGSL = { name: name$2, shader: shader$2 };
-
-var gaussianSplatting_fragment = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    gaussianSplattingPixelShaderWGSL: gaussianSplattingPixelShaderWGSL
-});
-
-// Do not edit.
-const name$1 = "gaussianSplatting";
-const shader$1 = `fn getDataUV(index: f32,dataTextureSize: vec2f)->vec2<f32> {let y: f32=floor(index/dataTextureSize.x);let x: f32=index-y*dataTextureSize.x;return vec2f((x+0.5),(y+0.5));}
-struct Splat {center: vec4f,
-color: vec4f,
-covA: vec4f,
-covB: vec4f,
-#if SH_DEGREE>0
-sh0: vec4<u32>,
-#endif
-#if SH_DEGREE>1
-sh1: vec4<u32>,
-#endif
-#if SH_DEGREE>2
-sh2: vec4<u32>,
-#endif
-};fn readSplat(splatIndex: f32,dataTextureSize: vec2f)->Splat {var splat: Splat;let splatUV=getDataUV(splatIndex,dataTextureSize);let splatUVi32=vec2<i32>(i32(splatUV.x),i32(splatUV.y));splat.center=textureLoad(centersTexture,splatUVi32,0);splat.color=textureLoad(colorsTexture,splatUVi32,0);splat.covA=textureLoad(covariancesATexture,splatUVi32,0)*splat.center.w;splat.covB=textureLoad(covariancesBTexture,splatUVi32,0)*splat.center.w;
-#if SH_DEGREE>0
-splat.sh0=textureLoad(shTexture0,splatUVi32,0);
-#endif
-#if SH_DEGREE>1
-splat.sh1=textureLoad(shTexture1,splatUVi32,0);
-#endif
-#if SH_DEGREE>2
-splat.sh2=textureLoad(shTexture2,splatUVi32,0);
-#endif
-return splat;}
-fn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,16>)->vec3f
-{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(
-1.092548430,
--1.09254843,
-0.315391565,
--1.09254843,
-0.546274215
-);var SH_C3: array<f32,7>=array<f32,7>(
--0.59004358,
-2.890611442,
--0.45704579,
-0.373176332,
--0.45704579,
-1.445305721,
--0.59004358
-);var result: vec3f=/*SH_C0**/sh[0];
-#if SH_DEGREE>0
-let x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3];
-#if SH_DEGREE>1
-let xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=
-SH_C2[0]*xy*sh[4] +
-SH_C2[1]*yz*sh[5] +
-SH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +
-SH_C2[3]*xz*sh[7] +
-SH_C2[4]*(xx-yy)*sh[8];
-#if SH_DEGREE>2
-result+=
-SH_C3[0]*y*(3.0f*xx-yy)*sh[9] +
-SH_C3[1]*xy*z*sh[10] +
-SH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +
-SH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +
-SH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +
-SH_C3[5]*z*(xx-yy)*sh[14] +
-SH_C3[6]*x*(xx-3.0f*yy)*sh[15];
-#endif
-#endif
-#endif
-return result;}
-fn decompose(value: u32)->vec4f
-{let components : vec4f=vec4f(
-f32((value ) & 255u),
-f32((value>>u32( 8)) & 255u),
-f32((value>>u32(16)) & 255u),
-f32((value>>u32(24)) & 255u));return components*vec4f(2./255.)-vec4f(1.);}
-fn computeSH(splat: Splat,color: vec3f,dir: vec3f)->vec3f
-{var sh: array<vec3<f32>,16>;sh[0]=color;
-#if SH_DEGREE>0
-let sh00: vec4f=decompose(splat.sh0.x);let sh01: vec4f=decompose(splat.sh0.y);let sh02: vec4f=decompose(splat.sh0.z);sh[1]=vec3f(sh00.x,sh00.y,sh00.z);sh[2]=vec3f(sh00.w,sh01.x,sh01.y);sh[3]=vec3f(sh01.z,sh01.w,sh02.x);
-#endif
-#if SH_DEGREE>1
-let sh03: vec4f=decompose(splat.sh0.w);let sh04: vec4f=decompose(splat.sh1.x);let sh05: vec4f=decompose(splat.sh1.y);sh[4]=vec3f(sh02.y,sh02.z,sh02.w);sh[5]=vec3f(sh03.x,sh03.y,sh03.z);sh[6]=vec3f(sh03.w,sh04.x,sh04.y);sh[7]=vec3f(sh04.z,sh04.w,sh05.x);sh[8]=vec3f(sh05.y,sh05.z,sh05.w);
-#endif
-#if SH_DEGREE>2
-let sh06: vec4f=decompose(splat.sh1.z);let sh07: vec4f=decompose(splat.sh1.w);let sh08: vec4f=decompose(splat.sh2.x);let sh09: vec4f=decompose(splat.sh2.y);let sh10: vec4f=decompose(splat.sh2.z);let sh11: vec4f=decompose(splat.sh2.w);sh[9]=vec3f(sh06.x,sh06.y,sh06.z);sh[10]=vec3f(sh06.w,sh07.x,sh07.y);sh[11]=vec3f(sh07.z,sh07.w,sh08.x);sh[12]=vec3f(sh08.y,sh08.z,sh08.w);sh[13]=vec3f(sh09.x,sh09.y,sh09.z);sh[14]=vec3f(sh09.w,sh10.x,sh10.y);sh[15]=vec3f(sh10.z,sh10.w,sh11.x); 
-#endif
-return computeColorFromSHDegree(dir,sh);}
-fn gaussianSplatting(
-meshPos: vec2<f32>,
-worldPos: vec3<f32>,
-scale: vec2<f32>,
-covA: vec3<f32>,
-covB: vec3<f32>,
-worldMatrix: mat4x4<f32>,
-viewMatrix: mat4x4<f32>,
-projectionMatrix: mat4x4<f32>,
-focal: vec2f,
-invViewport: vec2f
-)->vec4f {let modelView=viewMatrix*worldMatrix;let camspace=viewMatrix*vec4f(worldPos,1.0);let pos2d=projectionMatrix*camspace;let bounds=1.2*pos2d.w;if (pos2d.z<0. || pos2d.x<-bounds || pos2d.x>bounds || pos2d.y<-bounds || pos2d.y>bounds) {return vec4f(0.0,0.0,2.0,1.0);}
-let Vrk=mat3x3<f32>(
-covA.x,covA.y,covA.z,
-covA.y,covB.x,covB.y,
-covA.z,covB.y,covB.z
-);let J=mat3x3<f32>(
-focal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),
-0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
-0.0,0.0,0.0
-);let invy=mat3x3<f32>(
-1.0,0.0,0.0,
-0.0,-1.0,0.0,
-0.0,0.0,1.0
-);let T=invy*transpose(mat3x3<f32>(
-modelView[0].xyz,
-modelView[1].xyz,
-modelView[2].xyz))*J;let cov2d=transpose(T)*Vrk*T;let mid=(cov2d[0][0]+cov2d[1][1])/2.0;let radius=length(vec2<f32>((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));let lambda1=mid+radius;let lambda2=mid-radius;if (lambda2<0.0) {return vec4f(0.0,0.0,2.0,1.0);}
-let diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);let vCenter=vec2<f32>(pos2d.x,pos2d.y);return vec4f(
-vCenter+((meshPos.x*majorAxis+meshPos.y*minorAxis)*invViewport*pos2d.w)*scale,
-pos2d.z,
-pos2d.w
-);}
-`;
-// Sideeffect
-ShaderStore.IncludesShadersStoreWGSL[name$1] = shader$1;
-
-// Do not edit.
-const name = "gaussianSplattingVertexShader";
-const shader = `#include<sceneUboDeclaration>
-#include<meshUboDeclaration>
-#include<clipPlaneVertexDeclaration>
-#include<fogVertexDeclaration>
-#include<logDepthDeclaration>
-attribute splatIndex: f32;attribute position: vec2f;uniform invViewport: vec2f;uniform dataTextureSize: vec2f;uniform focal: vec2f;var covariancesATexture: texture_2d<f32>;var covariancesBTexture: texture_2d<f32>;var centersTexture: texture_2d<f32>;var colorsTexture: texture_2d<f32>;
-#if SH_DEGREE>0
-var shTexture0: texture_2d<u32>;
-#endif
-#if SH_DEGREE>1
-var shTexture1: texture_2d<u32>;
-#endif
-#if SH_DEGREE>2
-var shTexture2: texture_2d<u32>;
-#endif
-varying vColor: vec4f;varying vPosition: vec2f;
-#include<gaussianSplatting>
-@vertex
-fn main(input : VertexInputs)->FragmentInputs {var splat: Splat=readSplat(input.splatIndex,uniforms.dataTextureSize);var covA: vec3f=splat.covA.xyz;var covB: vec3f=vec3f(splat.covA.w,splat.covB.xy);let worldPos: vec4f=mesh.world*vec4f(splat.center.xyz,1.0);vertexOutputs.vPosition=input.position;
-#if SH_DEGREE>0
-let dir: vec3f=normalize(worldPos.xyz-scene.vEyePosition.xyz);vertexOutputs.vColor=vec4f(computeSH(splat,splat.color.xyz,dir),1.0);
-#else
-vertexOutputs.vColor=splat.color;
-#endif
-vertexOutputs.position=gaussianSplatting(input.position,worldPos.xyz,vec2f(1.0,1.0),covA,covB,mesh.world,scene.view,scene.projection,uniforms.focal,uniforms.invViewport);
-#include<clipPlaneVertex>
-#include<fogVertex>
-#include<logDepthVertex>
-}
-`;
-// Sideeffect
-ShaderStore.ShadersStoreWGSL[name] = shader;
-/** @internal */
-const gaussianSplattingVertexShaderWGSL = { name, shader };
-
-var gaussianSplatting_vertex = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    gaussianSplattingVertexShaderWGSL: gaussianSplattingVertexShaderWGSL
-});
-
-/**
- * @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.SH_DEGREE = 0;
-        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);
-        // SH is disabled for webGL1
-        if (engine.version > 1 || engine.isWebGPU) {
-            defines["SH_DEGREE"] = mesh.shDegree;
-        }
-        // 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", "vEyePosition"];
-            const samplers = ["covariancesATexture", "covariancesBTexture", "centersTexture", "colorsTexture", "shTexture0", "shTexture1", "shTexture2"];
-            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,
-                indexParameters: {},
-                shaderLanguage: this._shaderLanguage,
-                extraInitializationsAsync: async () => {
-                    if (this._shaderLanguage === 1 /* ShaderLanguage.WGSL */) {
-                        await Promise.all([Promise.resolve().then(function () { return gaussianSplatting_fragment; }), Promise.resolve().then(function () { return gaussianSplatting_vertex; })]);
-                    }
-                    else {
-                        await Promise.all([Promise.resolve().then(function () { return gaussianSplatting_fragment$1; }), Promise.resolve().then(function () { return gaussianSplatting_vertex$1; })]);
-                    }
-                },
-            }, 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;
-    }
-    /**
-     * Bind material effect for a specific Gaussian Splatting mesh
-     * @param mesh Gaussian splatting mesh
-     * @param effect Splatting material or node material
-     * @param scene scene that contains mesh and camera used for rendering
-     */
-    static BindEffect(mesh, effect, scene) {
-        const engine = scene.getEngine();
-        const camera = scene.activeCamera;
-        const renderWidth = engine.getRenderWidth();
-        const renderHeight = engine.getRenderHeight();
-        // check if rigcamera, get number of rigs
-        const numberOfRigs = camera?.rigParent?.rigCameras.length || 1;
-        effect.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;
-            }
-        }
-        effect.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);
-            if (gsMesh.shTextures) {
-                for (let i = 0; i < gsMesh.shTextures?.length; i++) {
-                    effect.setTexture(`shTexture${i}`, gsMesh.shTextures[i]);
-                }
-            }
-        }
-    }
-    /**
-     * 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);
-            GaussianSplattingMaterial.BindEffect(mesh, this._activeEffect, scene);
-            // 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);
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const HCF = HighestCommonFactor;
-/**
- * Scalar computation library
- */
-const Scalar = {
-    ...functions,
-    /**
-     * Two pi constants convenient for computation.
-     */
-    TwoPi: Math.PI * 2,
-    /**
-     * Returns -1 if value is negative and +1 is value is positive.
-     * @param value the value
-     * @returns the value itself if it's equal to zero.
-     */
-    Sign: Math.sign,
-    /**
-     * the log2 of value.
-     * @param value the value to compute log2 of
-     * @returns the log2 of value.
-     */
-    Log2: Math.log2,
-    /**
-     * Returns the highest common factor of two integers.
-     * @param a first parameter
-     * @param b second parameter
-     * @returns HCF of a and b
-     */
-    HCF,
-};
-/* eslint-enable @typescript-eslint/naming-convention */
-
-// @internal
-const unpackUnorm = (value, bits) => {
-    const t = (1 << bits) - 1;
-    return (value & t) / t;
-};
-// @internal
-const unpack111011 = (value, result) => {
-    result.x = unpackUnorm(value >>> 21, 11);
-    result.y = unpackUnorm(value >>> 11, 10);
-    result.z = unpackUnorm(value, 11);
-};
-// @internal
-const unpack8888 = (value, result) => {
-    result[0] = unpackUnorm(value >>> 24, 8) * 255;
-    result[1] = unpackUnorm(value >>> 16, 8) * 255;
-    result[2] = unpackUnorm(value >>> 8, 8) * 255;
-    result[3] = unpackUnorm(value, 8) * 255;
-};
-// @internal
-// unpack quaternion with 2,10,10,10 format (largest element, 3x10bit element)
-const unpackRot = (value, result) => {
-    const norm = 1.0 / (Math.sqrt(2) * 0.5);
-    const a = (unpackUnorm(value >>> 20, 10) - 0.5) * norm;
-    const b = (unpackUnorm(value >>> 10, 10) - 0.5) * norm;
-    const c = (unpackUnorm(value, 10) - 0.5) * norm;
-    const m = Math.sqrt(1.0 - (a * a + b * b + c * c));
-    switch (value >>> 30) {
-        case 0:
-            result.set(m, a, b, c);
-            break;
-        case 1:
-            result.set(a, m, b, c);
-            break;
-        case 2:
-            result.set(a, b, m, c);
-            break;
-        case 3:
-            result.set(a, b, c, m);
-            break;
-    }
-};
-/**
- * Representation of the types
- */
-var PLYType;
-(function (PLYType) {
-    PLYType[PLYType["FLOAT"] = 0] = "FLOAT";
-    PLYType[PLYType["INT"] = 1] = "INT";
-    PLYType[PLYType["UINT"] = 2] = "UINT";
-    PLYType[PLYType["DOUBLE"] = 3] = "DOUBLE";
-    PLYType[PLYType["UCHAR"] = 4] = "UCHAR";
-    PLYType[PLYType["UNDEFINED"] = 5] = "UNDEFINED";
-})(PLYType || (PLYType = {}));
-/**
- * Usage types of the PLY values
- */
-var PLYValue;
-(function (PLYValue) {
-    PLYValue[PLYValue["MIN_X"] = 0] = "MIN_X";
-    PLYValue[PLYValue["MIN_Y"] = 1] = "MIN_Y";
-    PLYValue[PLYValue["MIN_Z"] = 2] = "MIN_Z";
-    PLYValue[PLYValue["MAX_X"] = 3] = "MAX_X";
-    PLYValue[PLYValue["MAX_Y"] = 4] = "MAX_Y";
-    PLYValue[PLYValue["MAX_Z"] = 5] = "MAX_Z";
-    PLYValue[PLYValue["MIN_SCALE_X"] = 6] = "MIN_SCALE_X";
-    PLYValue[PLYValue["MIN_SCALE_Y"] = 7] = "MIN_SCALE_Y";
-    PLYValue[PLYValue["MIN_SCALE_Z"] = 8] = "MIN_SCALE_Z";
-    PLYValue[PLYValue["MAX_SCALE_X"] = 9] = "MAX_SCALE_X";
-    PLYValue[PLYValue["MAX_SCALE_Y"] = 10] = "MAX_SCALE_Y";
-    PLYValue[PLYValue["MAX_SCALE_Z"] = 11] = "MAX_SCALE_Z";
-    PLYValue[PLYValue["PACKED_POSITION"] = 12] = "PACKED_POSITION";
-    PLYValue[PLYValue["PACKED_ROTATION"] = 13] = "PACKED_ROTATION";
-    PLYValue[PLYValue["PACKED_SCALE"] = 14] = "PACKED_SCALE";
-    PLYValue[PLYValue["PACKED_COLOR"] = 15] = "PACKED_COLOR";
-    PLYValue[PLYValue["X"] = 16] = "X";
-    PLYValue[PLYValue["Y"] = 17] = "Y";
-    PLYValue[PLYValue["Z"] = 18] = "Z";
-    PLYValue[PLYValue["SCALE_0"] = 19] = "SCALE_0";
-    PLYValue[PLYValue["SCALE_1"] = 20] = "SCALE_1";
-    PLYValue[PLYValue["SCALE_2"] = 21] = "SCALE_2";
-    PLYValue[PLYValue["DIFFUSE_RED"] = 22] = "DIFFUSE_RED";
-    PLYValue[PLYValue["DIFFUSE_GREEN"] = 23] = "DIFFUSE_GREEN";
-    PLYValue[PLYValue["DIFFUSE_BLUE"] = 24] = "DIFFUSE_BLUE";
-    PLYValue[PLYValue["OPACITY"] = 25] = "OPACITY";
-    PLYValue[PLYValue["F_DC_0"] = 26] = "F_DC_0";
-    PLYValue[PLYValue["F_DC_1"] = 27] = "F_DC_1";
-    PLYValue[PLYValue["F_DC_2"] = 28] = "F_DC_2";
-    PLYValue[PLYValue["F_DC_3"] = 29] = "F_DC_3";
-    PLYValue[PLYValue["ROT_0"] = 30] = "ROT_0";
-    PLYValue[PLYValue["ROT_1"] = 31] = "ROT_1";
-    PLYValue[PLYValue["ROT_2"] = 32] = "ROT_2";
-    PLYValue[PLYValue["ROT_3"] = 33] = "ROT_3";
-    PLYValue[PLYValue["UNDEFINED"] = 34] = "UNDEFINED";
-})(PLYValue || (PLYValue = {}));
-/**
- * Class used to render a gaussian splatting mesh
- */
-class GaussianSplattingMesh extends Mesh {
-    /**
-     * SH degree. 0 = no sh (default). 1 = 3 parameters. 2 = 8 parameters. 3 = 15 parameters.
-     */
-    get shDegree() {
-        return this._shDegree;
-    }
-    /**
-     * Gets the covariancesA texture
-     */
-    get covariancesATexture() {
-        return this._covariancesATexture;
-    }
-    /**
-     * Gets the covariancesB texture
-     */
-    get covariancesBTexture() {
-        return this._covariancesBTexture;
-    }
-    /**
-     * Gets the centers texture
-     */
-    get centersTexture() {
-        return this._centersTexture;
-    }
-    /**
-     * Gets the colors texture
-     */
-    get colorsTexture() {
-        return this._colorsTexture;
-    }
-    /**
-     * Gets the SH textures
-     */
-    get shTextures() {
-        return this._shTextures;
-    }
-    /**
-     * set rendering material
-     */
-    set material(value) {
-        this._material = value;
-        this._material.backFaceCulling = true;
-        this._material.cullBackFaces = false;
-        value.resetDrawCache();
-    }
-    /**
-     * get rendering material
-     */
-    get material() {
-        return this._material;
-    }
-    /**
-     * 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;
-        this._shTextures = null;
-        //@ts-expect-error
-        this._covariancesA = null;
-        //@ts-expect-error
-        this._covariancesB = null;
-        //@ts-expect-error
-        this._colors = null;
-        this._sh = null;
-        this._keepInRam = false;
-        this._delayedTextureUpdate = null;
-        this._oldDirection = new Vector3();
-        this._useRGBACovariants = false;
-        this._material = null;
-        this._tmpCovariances = [0, 0, 0, 0, 0, 0];
-        this._sortIsDirty = false;
-        this._shDegree = 0;
-        const vertexData = new VertexData();
-        // Use an intanced quad or triangle. Triangle might be a bit faster because of less shader invocation but I didn't see any difference.
-        // Keeping both and use triangle for now.
-        // for quad, use following lines
-        //vertexData.positions = [-2, -2, 0, 2, -2, 0, 2, 2, 0, -2, 2, 0];
-        //vertexData.indices = [0, 1, 2, 0, 2, 3];
-        vertexData.positions = [-3, -2, 0, 3, -2, 0, 0, 4, 0];
-        vertexData.indices = [0, 1, 2];
-        vertexData.applyToMesh(this);
-        this.subMeshes = [];
-        // for quad, use following line
-        //new SubMesh(0, 0, 4, 0, 6, this);
-        new SubMesh(0, 0, 3, 0, 3, this);
-        this.setEnabled(false);
-        // webGL2 and webGPU support for RG texture with float16 is fine. not webGL1
-        this._useRGBACovariants = !this.getEngine().isWebGPU && this.getEngine().version === 1.0;
-        this._keepInRam = keepInRam;
-        if (url) {
-            this.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;
-    }
-    /** @internal */
-    _postToWorker(forced = false) {
-        const frameId = this.getScene().getFrameId();
-        if ((forced || 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);
-    }
-    static _TypeNameToEnum(name) {
-        switch (name) {
-            case "float":
-                return 0 /* PLYType.FLOAT */;
-            case "int":
-                return 1 /* PLYType.INT */;
-            case "uint":
-                return 2 /* PLYType.UINT */;
-            case "double":
-                return 3 /* PLYType.DOUBLE */;
-            case "uchar":
-                return 4 /* PLYType.UCHAR */;
-        }
-        return 5 /* PLYType.UNDEFINED */;
-    }
-    static _ValueNameToEnum(name) {
-        switch (name) {
-            case "min_x":
-                return 0 /* PLYValue.MIN_X */;
-            case "min_y":
-                return 1 /* PLYValue.MIN_Y */;
-            case "min_z":
-                return 2 /* PLYValue.MIN_Z */;
-            case "max_x":
-                return 3 /* PLYValue.MAX_X */;
-            case "max_y":
-                return 4 /* PLYValue.MAX_Y */;
-            case "max_z":
-                return 5 /* PLYValue.MAX_Z */;
-            case "min_scale_x":
-                return 6 /* PLYValue.MIN_SCALE_X */;
-            case "min_scale_y":
-                return 7 /* PLYValue.MIN_SCALE_Y */;
-            case "min_scale_z":
-                return 8 /* PLYValue.MIN_SCALE_Z */;
-            case "max_scale_x":
-                return 9 /* PLYValue.MAX_SCALE_X */;
-            case "max_scale_y":
-                return 10 /* PLYValue.MAX_SCALE_Y */;
-            case "max_scale_z":
-                return 11 /* PLYValue.MAX_SCALE_Z */;
-            case "packed_position":
-                return 12 /* PLYValue.PACKED_POSITION */;
-            case "packed_rotation":
-                return 13 /* PLYValue.PACKED_ROTATION */;
-            case "packed_scale":
-                return 14 /* PLYValue.PACKED_SCALE */;
-            case "packed_color":
-                return 15 /* PLYValue.PACKED_COLOR */;
-            case "x":
-                return 16 /* PLYValue.X */;
-            case "y":
-                return 17 /* PLYValue.Y */;
-            case "z":
-                return 18 /* PLYValue.Z */;
-            case "scale_0":
-                return 19 /* PLYValue.SCALE_0 */;
-            case "scale_1":
-                return 20 /* PLYValue.SCALE_1 */;
-            case "scale_2":
-                return 21 /* PLYValue.SCALE_2 */;
-            case "diffuse_red":
-            case "red":
-                return 22 /* PLYValue.DIFFUSE_RED */;
-            case "diffuse_green":
-            case "green":
-                return 23 /* PLYValue.DIFFUSE_GREEN */;
-            case "diffuse_blue":
-            case "blue":
-                return 24 /* PLYValue.DIFFUSE_BLUE */;
-            case "f_dc_0":
-                return 26 /* PLYValue.F_DC_0 */;
-            case "f_dc_1":
-                return 27 /* PLYValue.F_DC_1 */;
-            case "f_dc_2":
-                return 28 /* PLYValue.F_DC_2 */;
-            case "f_dc_3":
-                return 29 /* PLYValue.F_DC_3 */;
-            case "opacity":
-                return 25 /* PLYValue.OPACITY */;
-            case "rot_0":
-                return 30 /* PLYValue.ROT_0 */;
-            case "rot_1":
-                return 31 /* PLYValue.ROT_1 */;
-            case "rot_2":
-                return 32 /* PLYValue.ROT_2 */;
-            case "rot_3":
-                return 33 /* PLYValue.ROT_3 */;
-        }
-        return 34 /* PLYValue.UNDEFINED */;
-    }
-    /**
-     * Parse a PLY file header and returns metas infos on splats and chunks
-     * @param data the loaded buffer
-     * @returns a PLYHeader
-     */
-    static ParseHeader(data) {
-        const ubuf = new Uint8Array(data);
-        const header = new TextDecoder().decode(ubuf.slice(0, 1024 * 10));
-        const headerEnd = "end_header\n";
-        const headerEndIndex = header.indexOf(headerEnd);
-        if (headerEndIndex < 0 || !header) {
-            // standard splat
-            return null;
-        }
-        const vertexCount = parseInt(/element vertex (\d+)\n/.exec(header)[1]);
-        const chunkElement = /element chunk (\d+)\n/.exec(header);
-        let chunkCount = 0;
-        if (chunkElement) {
-            chunkCount = parseInt(chunkElement[1]);
-        }
-        let rowVertexOffset = 0;
-        let rowChunkOffset = 0;
-        const offsets = {
-            double: 8,
-            int: 4,
-            uint: 4,
-            float: 4,
-            short: 2,
-            ushort: 2,
-            uchar: 1,
-            list: 0,
-        };
-        let ElementMode;
-        (function (ElementMode) {
-            ElementMode[ElementMode["Vertex"] = 0] = "Vertex";
-            ElementMode[ElementMode["Chunk"] = 1] = "Chunk";
-        })(ElementMode || (ElementMode = {}));
-        let chunkMode = 1 /* ElementMode.Chunk */;
-        const vertexProperties = [];
-        const chunkProperties = [];
-        const filtered = header.slice(0, headerEndIndex).split("\n");
-        for (const prop of filtered) {
-            if (prop.startsWith("property ")) {
-                const [, typeName, name] = prop.split(" ");
-                const value = GaussianSplattingMesh._ValueNameToEnum(name);
-                const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
-                if (chunkMode == 1 /* ElementMode.Chunk */) {
-                    chunkProperties.push({ value, type, offset: rowChunkOffset });
-                    rowChunkOffset += offsets[typeName];
-                }
-                else if (chunkMode == 0 /* ElementMode.Vertex */) {
-                    vertexProperties.push({ value, type, offset: rowVertexOffset });
-                    rowVertexOffset += offsets[typeName];
-                }
-                if (!offsets[typeName]) {
-                    Logger.Warn(`Unsupported property type: ${typeName}.`);
-                }
-            }
-            else if (prop.startsWith("element ")) {
-                const [, type] = prop.split(" ");
-                if (type == "chunk") {
-                    chunkMode = 1 /* ElementMode.Chunk */;
-                }
-                else if (type == "vertex") {
-                    chunkMode = 0 /* ElementMode.Vertex */;
-                }
-            }
-        }
-        const dataView = new DataView(data, headerEndIndex + headerEnd.length);
-        const buffer = new ArrayBuffer(GaussianSplattingMesh._RowOutputLength * vertexCount);
-        return {
-            vertexCount: vertexCount,
-            chunkCount: chunkCount,
-            rowVertexLength: rowVertexOffset,
-            rowChunkLength: rowChunkOffset,
-            vertexProperties: vertexProperties,
-            chunkProperties: chunkProperties,
-            dataView: dataView,
-            buffer: buffer,
-        };
-    }
-    static _GetCompressedChunks(header, offset) {
-        if (!header.chunkCount) {
-            return null;
-        }
-        const dataView = header.dataView;
-        const compressedChunks = new Array(header.chunkCount);
-        for (let i = 0; i < header.chunkCount; i++) {
-            const currentChunk = { min: new Vector3(), max: new Vector3(), minScale: new Vector3(), maxScale: new Vector3() };
-            compressedChunks[i] = currentChunk;
-            for (let propertyIndex = 0; propertyIndex < header.chunkProperties.length; propertyIndex++) {
-                const property = header.chunkProperties[propertyIndex];
-                let value;
-                switch (property.type) {
-                    case 0 /* PLYType.FLOAT */:
-                        value = dataView.getFloat32(property.offset + offset.value, true);
-                        break;
-                    default:
-                        continue;
-                }
-                switch (property.value) {
-                    case 0 /* PLYValue.MIN_X */:
-                        currentChunk.min.x = value;
-                        break;
-                    case 1 /* PLYValue.MIN_Y */:
-                        currentChunk.min.y = value;
-                        break;
-                    case 2 /* PLYValue.MIN_Z */:
-                        currentChunk.min.z = value;
-                        break;
-                    case 3 /* PLYValue.MAX_X */:
-                        currentChunk.max.x = value;
-                        break;
-                    case 4 /* PLYValue.MAX_Y */:
-                        currentChunk.max.y = value;
-                        break;
-                    case 5 /* PLYValue.MAX_Z */:
-                        currentChunk.max.z = value;
-                        break;
-                    case 6 /* PLYValue.MIN_SCALE_X */:
-                        currentChunk.minScale.x = value;
-                        break;
-                    case 7 /* PLYValue.MIN_SCALE_Y */:
-                        currentChunk.minScale.y = value;
-                        break;
-                    case 8 /* PLYValue.MIN_SCALE_Z */:
-                        currentChunk.minScale.z = value;
-                        break;
-                    case 9 /* PLYValue.MAX_SCALE_X */:
-                        currentChunk.maxScale.x = value;
-                        break;
-                    case 10 /* PLYValue.MAX_SCALE_Y */:
-                        currentChunk.maxScale.y = value;
-                        break;
-                    case 11 /* PLYValue.MAX_SCALE_Z */:
-                        currentChunk.maxScale.z = value;
-                        break;
-                }
-            }
-            offset.value += header.rowChunkLength;
-        }
-        return compressedChunks;
-    }
-    static _GetSplat(header, index, compressedChunks, offset) {
-        const q = TmpVectors.Quaternion[0];
-        const temp3 = TmpVectors.Vector3[0];
-        const rowOutputLength = GaussianSplattingMesh._RowOutputLength;
-        const buffer = header.buffer;
-        const dataView = header.dataView;
-        const position = new Float32Array(buffer, index * rowOutputLength, 3);
-        const scale = new Float32Array(buffer, index * rowOutputLength + 12, 3);
-        const rgba = new Uint8ClampedArray(buffer, index * rowOutputLength + 24, 4);
-        const rot = new Uint8ClampedArray(buffer, index * rowOutputLength + 28, 4);
-        const chunkIndex = index >> 8;
-        let r0 = 255;
-        let r1 = 0;
-        let r2 = 0;
-        let r3 = 0;
-        for (let propertyIndex = 0; propertyIndex < header.vertexProperties.length; propertyIndex++) {
-            const property = header.vertexProperties[propertyIndex];
-            let value;
-            switch (property.type) {
-                case 0 /* PLYType.FLOAT */:
-                    value = dataView.getFloat32(offset.value + property.offset, true);
-                    break;
-                case 1 /* PLYType.INT */:
-                    value = dataView.getInt32(offset.value + property.offset, true);
-                    break;
-                case 2 /* PLYType.UINT */:
-                    value = dataView.getUint32(offset.value + property.offset, true);
-                    break;
-                case 3 /* PLYType.DOUBLE */:
-                    value = dataView.getFloat64(offset.value + property.offset, true);
-                    break;
-                case 4 /* PLYType.UCHAR */:
-                    value = dataView.getUint8(offset.value + property.offset);
-                    break;
-                default:
-                    continue;
-            }
-            switch (property.value) {
-                case 12 /* PLYValue.PACKED_POSITION */:
-                    {
-                        const compressedChunk = compressedChunks[chunkIndex];
-                        unpack111011(value, temp3);
-                        position[0] = Scalar.Lerp(compressedChunk.min.x, compressedChunk.max.x, temp3.x);
-                        position[1] = -Scalar.Lerp(compressedChunk.min.y, compressedChunk.max.y, temp3.y);
-                        position[2] = Scalar.Lerp(compressedChunk.min.z, compressedChunk.max.z, temp3.z);
-                    }
-                    break;
-                case 13 /* PLYValue.PACKED_ROTATION */:
-                    {
-                        unpackRot(value, q);
-                        r0 = q.w;
-                        r1 = q.z;
-                        r2 = q.y;
-                        r3 = q.x;
-                    }
-                    break;
-                case 14 /* PLYValue.PACKED_SCALE */:
-                    {
-                        const compressedChunk = compressedChunks[chunkIndex];
-                        unpack111011(value, temp3);
-                        scale[0] = Math.exp(Scalar.Lerp(compressedChunk.minScale.x, compressedChunk.maxScale.x, temp3.x));
-                        scale[1] = Math.exp(Scalar.Lerp(compressedChunk.minScale.y, compressedChunk.maxScale.y, temp3.y));
-                        scale[2] = Math.exp(Scalar.Lerp(compressedChunk.minScale.z, compressedChunk.maxScale.z, temp3.z));
-                    }
-                    break;
-                case 15 /* PLYValue.PACKED_COLOR */:
-                    unpack8888(value, rgba);
-                    break;
-                case 16 /* PLYValue.X */:
-                    position[0] = value;
-                    break;
-                case 17 /* PLYValue.Y */:
-                    position[1] = value;
-                    break;
-                case 18 /* PLYValue.Z */:
-                    position[2] = value;
-                    break;
-                case 19 /* PLYValue.SCALE_0 */:
-                    scale[0] = Math.exp(value);
-                    break;
-                case 20 /* PLYValue.SCALE_1 */:
-                    scale[1] = Math.exp(value);
-                    break;
-                case 21 /* PLYValue.SCALE_2 */:
-                    scale[2] = Math.exp(value);
-                    break;
-                case 22 /* PLYValue.DIFFUSE_RED */:
-                    rgba[0] = value;
-                    break;
-                case 23 /* PLYValue.DIFFUSE_GREEN */:
-                    rgba[1] = value;
-                    break;
-                case 24 /* PLYValue.DIFFUSE_BLUE */:
-                    rgba[2] = value;
-                    break;
-                case 26 /* PLYValue.F_DC_0 */:
-                    rgba[0] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 27 /* PLYValue.F_DC_1 */:
-                    rgba[1] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 28 /* PLYValue.F_DC_2 */:
-                    rgba[2] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 29 /* PLYValue.F_DC_3 */:
-                    rgba[3] = (0.5 + GaussianSplattingMesh._SH_C0 * value) * 255;
-                    break;
-                case 25 /* PLYValue.OPACITY */:
-                    rgba[3] = (1 / (1 + Math.exp(-value))) * 255;
-                    break;
-                case 30 /* PLYValue.ROT_0 */:
-                    r0 = value;
-                    break;
-                case 31 /* PLYValue.ROT_1 */:
-                    r1 = value;
-                    break;
-                case 32 /* PLYValue.ROT_2 */:
-                    r2 = value;
-                    break;
-                case 33 /* PLYValue.ROT_3 */:
-                    r3 = value;
-                    break;
-            }
-        }
-        q.set(r1, r2, r3, r0);
-        q.normalize();
-        rot[0] = q.w * 128 + 128;
-        rot[1] = q.x * 128 + 128;
-        rot[2] = q.y * 128 + 128;
-        rot[3] = q.z * 128 + 128;
-        offset.value += header.rowVertexLength;
-    }
-    /**
-     * Converts a .ply data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @param useCoroutine use coroutine and yield
-     * @returns the loaded splat buffer
-     */
-    static *ConvertPLYToSplat(data, useCoroutine = false) {
-        const header = GaussianSplattingMesh.ParseHeader(data);
-        if (!header) {
-            return data;
-        }
-        const offset = { value: 0 };
-        const compressedChunks = GaussianSplattingMesh._GetCompressedChunks(header, offset);
-        for (let i = 0; i < header.vertexCount; i++) {
-            GaussianSplattingMesh._GetSplat(header, i, compressedChunks, offset);
-            if (i % GaussianSplattingMesh._PlyConversionBatchSize === 0 && useCoroutine) {
-                yield;
-            }
-        }
-        return header.buffer;
-    }
-    /**
-     * Converts a .ply data array buffer to splat
-     * if data array buffer is not ply, returns the original buffer
-     * @param data the .ply data to load
-     * @returns the loaded splat buffer
-     */
-    static async ConvertPLYToSplatAsync(data) {
-        return runCoroutineAsync(GaussianSplattingMesh.ConvertPLYToSplat(data, true), createYieldingScheduler());
-    }
-    /**
-     * Loads a .splat Gaussian Splatting array buffer asynchronously
-     * @param data arraybuffer containing splat file
-     * @returns a promise that resolves when the operation is complete
-     */
-    loadDataAsync(data) {
-        return this.updateDataAsync(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(async (plyBuffer) => {
-            GaussianSplattingMesh.ConvertPLYToSplatAsync(plyBuffer).then((splatsData) => {
-                this.updateDataAsync(splatsData);
-            });
-        });
-    }
-    /**
-     * 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();
-        if (this._shTextures) {
-            this._shTextures.forEach((shTexture) => {
-                shTexture.dispose();
-            });
-        }
-        this._covariancesATexture = null;
-        this._covariancesBTexture = null;
-        this._centersTexture = null;
-        this._colorsTexture = null;
-        this._shTextures = 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();
-        if (source._shTextures) {
-            this._shTextures = [];
-            this._shTextures.forEach((shTexture) => {
-                this._shTextures?.push(shTexture.clone());
-            });
-        }
-    }
-    /**
-     * Returns a new Mesh object generated from the current mesh properties.
-     * @param name is a string, the name given to the new mesh
-     * @returns a new Gaussian Splatting Mesh
-     */
-    clone(name = "") {
-        const newGS = new GaussianSplattingMesh(name, undefined, this.getScene());
-        newGS._copySource(this);
-        newGS.makeGeometryUnique();
-        newGS._vertexCount = this._vertexCount;
-        newGS._copyTextures(this);
-        newGS._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;
-    }
-    _makeSplat(sourceIndex, destinationIndex, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum) {
-        const matrixRotation = TmpVectors.Matrix[0];
-        const matrixScale = TmpVectors.Matrix[1];
-        const quaternion = TmpVectors.Quaternion[0];
-        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
-        const x = fBuffer[8 * sourceIndex + 0];
-        const y = -fBuffer[8 * sourceIndex + 1];
-        const z = fBuffer[8 * sourceIndex + 2];
-        this._splatPositions[4 * sourceIndex + 0] = x;
-        this._splatPositions[4 * sourceIndex + 1] = y;
-        this._splatPositions[4 * sourceIndex + 2] = z;
-        minimum.minimizeInPlaceFromFloats(x, y, z);
-        maximum.maximizeInPlaceFromFloats(x, y, z);
-        quaternion.set((uBuffer[32 * sourceIndex + 28 + 1] - 128) / 128, (uBuffer[32 * sourceIndex + 28 + 2] - 128) / 128, (uBuffer[32 * sourceIndex + 28 + 3] - 128) / 128, -(uBuffer[32 * sourceIndex + 28 + 0] - 128) / 128);
-        quaternion.toRotationMatrix(matrixRotation);
-        Matrix.ScalingToRef(fBuffer[8 * sourceIndex + 3 + 0] * 2, fBuffer[8 * sourceIndex + 3 + 1] * 2, fBuffer[8 * sourceIndex + 3 + 2] * 2, matrixScale);
-        const M = matrixRotation.multiplyToRef(matrixScale, TmpVectors.Matrix[0]).m;
-        const covariances = this._tmpCovariances;
-        covariances[0] = M[0] * M[0] + M[1] * M[1] + M[2] * M[2];
-        covariances[1] = M[0] * M[4] + M[1] * M[5] + M[2] * M[6];
-        covariances[2] = M[0] * M[8] + M[1] * M[9] + M[2] * M[10];
-        covariances[3] = M[4] * M[4] + M[5] * M[5] + M[6] * M[6];
-        covariances[4] = M[4] * M[8] + M[5] * M[9] + M[6] * M[10];
-        covariances[5] = M[8] * M[8] + M[9] * M[9] + M[10] * M[10];
-        // normalize covA, covB
-        let factor = -10000;
-        for (let covIndex = 0; covIndex < 6; covIndex++) {
-            factor = Math.max(factor, Math.abs(covariances[covIndex]));
-        }
-        this._splatPositions[4 * sourceIndex + 3] = factor;
-        const transform = factor;
-        covA[destinationIndex * 4 + 0] = ToHalfFloat(covariances[0] / transform);
-        covA[destinationIndex * 4 + 1] = ToHalfFloat(covariances[1] / transform);
-        covA[destinationIndex * 4 + 2] = ToHalfFloat(covariances[2] / transform);
-        covA[destinationIndex * 4 + 3] = ToHalfFloat(covariances[3] / transform);
-        covB[destinationIndex * covBSItemSize + 0] = ToHalfFloat(covariances[4] / transform);
-        covB[destinationIndex * covBSItemSize + 1] = ToHalfFloat(covariances[5] / transform);
-        // colors
-        colorArray[destinationIndex * 4 + 0] = uBuffer[32 * sourceIndex + 24 + 0];
-        colorArray[destinationIndex * 4 + 1] = uBuffer[32 * sourceIndex + 24 + 1];
-        colorArray[destinationIndex * 4 + 2] = uBuffer[32 * sourceIndex + 24 + 2];
-        colorArray[destinationIndex * 4 + 3] = uBuffer[32 * sourceIndex + 24 + 3];
-    }
-    _updateTextures(covA, covB, colorArray, sh) {
-        const textureSize = this._getTextureSize(this._vertexCount);
-        // Update the textures
-        const createTextureFromData = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, Constants.TEXTURE_BILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_FLOAT);
-        };
-        const createTextureFromDataU8 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, Constants.TEXTURE_BILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_UNSIGNED_BYTE);
-        };
-        const createTextureFromDataU32 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, Constants.TEXTURE_NEAREST_SAMPLINGMODE, Constants.TEXTURETYPE_UNSIGNED_INTEGER);
-        };
-        const createTextureFromDataF16 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, Constants.TEXTURE_BILINEAR_SAMPLINGMODE, Constants.TEXTURETYPE_HALF_FLOAT);
-        };
-        if (this._keepInRam) {
-            this._covariancesA = covA;
-            this._covariancesB = covB;
-            this._colors = colorArray;
-            if (sh) {
-                this._sh = sh;
-            }
-        }
-        if (this._covariancesATexture) {
-            this._delayedTextureUpdate = { covA: covA, covB: covB, colors: colorArray, centers: this._splatPositions, sh: sh };
-            const positions = Float32Array.from(this._splatPositions);
-            const vertexCount = this._vertexCount;
-            this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
-            this._postToWorker(true);
-        }
-        else {
-            this._covariancesATexture = createTextureFromDataF16(covA, textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
-            this._covariancesBTexture = createTextureFromDataF16(covB, textureSize.x, textureSize.y, this._useRGBACovariants ? Constants.TEXTUREFORMAT_RGBA : Constants.TEXTUREFORMAT_RG);
-            this._centersTexture = createTextureFromData(this._splatPositions, textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
-            this._colorsTexture = createTextureFromDataU8(colorArray, textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA);
-            if (sh) {
-                this._shTextures = [];
-                sh.forEach((shData) => {
-                    const buffer = new Uint32Array(shData.buffer);
-                    const shTexture = createTextureFromDataU32(buffer, textureSize.x, textureSize.y, Constants.TEXTUREFORMAT_RGBA_INTEGER);
-                    shTexture.wrapU = Constants.TEXTURE_CLAMP_ADDRESSMODE;
-                    shTexture.wrapV = Constants.TEXTURE_CLAMP_ADDRESSMODE;
-                    this._shTextures.push(shTexture);
-                });
-            }
-            this._instanciateWorker();
-        }
-    }
-    *_updateData(data, isAsync, sh) {
-        // 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 vertexCount = uBuffer.length / GaussianSplattingMesh._RowOutputLength;
-        if (vertexCount != this._vertexCount) {
-            this._updateSplatIndexBuffer(vertexCount);
-        }
-        this._vertexCount = vertexCount;
-        // degree == 1 for 1 texture (3 terms), 2 for 2 textures(8 terms) and 3 for 3 textures (15 terms)
-        this._shDegree = sh ? sh.length : 0;
-        const textureSize = this._getTextureSize(vertexCount);
-        const textureLength = textureSize.x * textureSize.y;
-        const lineCountUpdate = GaussianSplattingMesh.ProgressiveUpdateAmount ?? textureSize.y;
-        const textureLengthPerUpdate = textureSize.x * lineCountUpdate;
-        this._splatPositions = new Float32Array(4 * textureLength);
-        const covA = new Uint16Array(textureLength * 4);
-        const covB = new Uint16Array((this._useRGBACovariants ? 4 : 2) * textureLength);
-        const colorArray = new Uint8Array(textureLength * 4);
-        const minimum = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE);
-        const maximum = new Vector3(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
-        if (GaussianSplattingMesh.ProgressiveUpdateAmount) {
-            // create textures with not filled-yet array, then update directly portions of it
-            this._updateTextures(covA, covB, colorArray, sh);
-            this.setEnabled(true);
-            const partCount = Math.ceil(textureSize.y / lineCountUpdate);
-            for (let partIndex = 0; partIndex < partCount; partIndex++) {
-                const updateLine = partIndex * lineCountUpdate;
-                const splatIndexBase = updateLine * textureSize.x;
-                for (let i = 0; i < textureLengthPerUpdate; i++) {
-                    this._makeSplat(splatIndexBase + i, splatIndexBase + i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
-                }
-                this._updateSubTextures(this._splatPositions, covA, covB, colorArray, updateLine, Math.min(lineCountUpdate, textureSize.y - updateLine));
-                // Update the binfo
-                this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
-                if (isAsync) {
-                    yield;
-                }
-            }
-            // sort will be dirty here as just finished filled positions will not be sorted
-            const positions = Float32Array.from(this._splatPositions);
-            const vertexCount = this._vertexCount;
-            this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
-            this._sortIsDirty = true;
-        }
-        else {
-            for (let i = 0; i < vertexCount; i++) {
-                this._makeSplat(i, i, fBuffer, uBuffer, covA, covB, colorArray, minimum, maximum);
-                if (isAsync && i % GaussianSplattingMesh._SplatBatchSize === 0) {
-                    yield;
-                }
-            }
-            // textures
-            this._updateTextures(covA, covB, colorArray, sh);
-            // Update the binfo
-            this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
-            this.setEnabled(true);
-        }
-        this._postToWorker(true);
-    }
-    /**
-     * Update asynchronously the buffer
-     * @param data array buffer containing center, color, orientation and scale of splats
-     * @param sh optional array of uint8 array for SH data
-     * @returns a promise
-     */
-    async updateDataAsync(data, sh) {
-        return runCoroutineAsync(this._updateData(data, true, sh), createYieldingScheduler());
-    }
-    /**
-     * @experimental
-     * Update data from GS (position, orientation, color, scaling)
-     * @param data array that contain all the datas
-     * @param sh optional array of uint8 array for SH data
-     */
-    updateData(data, sh) {
-        runCoroutineSync(this._updateData(data, false, sh));
-    }
-    // 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;
-    }
-    _updateSubTextures(centers, covA, covB, colors, lineStart, lineCount, sh) {
-        const updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
-            this.getEngine().updateTextureData(texture.getInternalTexture(), data, 0, lineStart, width, lineCount, 0, 0, false);
-        };
-        const textureSize = this._getTextureSize(this._vertexCount);
-        const covBSItemSize = this._useRGBACovariants ? 4 : 2;
-        const texelStart = lineStart * textureSize.x;
-        const texelCount = lineCount * textureSize.x;
-        const covAView = new Uint16Array(covA.buffer, texelStart * 4 * Uint16Array.BYTES_PER_ELEMENT, texelCount * 4);
-        const covBView = new Uint16Array(covB.buffer, texelStart * covBSItemSize * Uint16Array.BYTES_PER_ELEMENT, texelCount * covBSItemSize);
-        const colorsView = new Uint8Array(colors.buffer, texelStart * 4, texelCount * 4);
-        const centersView = new Float32Array(centers.buffer, texelStart * 4 * Float32Array.BYTES_PER_ELEMENT, texelCount * 4);
-        updateTextureFromData(this._covariancesATexture, covAView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._covariancesBTexture, covBView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._centersTexture, centersView, textureSize.x, lineStart, lineCount);
-        updateTextureFromData(this._colorsTexture, colorsView, textureSize.x, lineStart, lineCount);
-        if (sh) {
-            for (let i = 0; i < sh.length; i++) {
-                const componentCount = 4;
-                const shView = new Uint8Array(this._sh[i].buffer, texelStart * componentCount, texelCount * componentCount);
-                updateTextureFromData(this._shTextures[i], shView, textureSize.x, lineStart, lineCount);
-            }
-        }
-    }
-    _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 textureSize = this._getTextureSize(vertexCount);
-                this._updateSubTextures(this._delayedTextureUpdate.centers, this._delayedTextureUpdate.covA, this._delayedTextureUpdate.covB, this._delayedTextureUpdate.colors, 0, textureSize.y, this._delayedTextureUpdate.sh);
-                this._delayedTextureUpdate = null;
-            }
-            this.thinInstanceBufferUpdated("splatIndex");
-            this._canPostToWorker = true;
-            this._readyToDisplay = true;
-            // sort is dirty when GS is visible for progressive update with a this message arriving but positions were partially filled
-            // another update needs to be kicked. The kick can't happen just when the position buffer is ready because _canPostToWorker might be false.
-            if (this._sortIsDirty) {
-                this._postToWorker(true);
-                this._sortIsDirty = false;
-            }
-        };
-    }
-    _getTextureSize(length) {
-        const engine = this._scene.getEngine();
-        const width = engine.getCaps().maxTextureSize;
-        let height = 1;
-        if (engine.version === 1 && !engine.isWebGPU) {
-            while (width * height < length) {
-                height *= 2;
-            }
-        }
-        else {
-            height = Math.ceil(length / width);
-        }
-        if (height > width) {
-            Logger.Error("GaussianSplatting texture size: (" + width + ", " + height + "), maxTextureSize: " + width);
-            height = width;
-        }
-        return new Vector2(width, height);
-    }
-}
-GaussianSplattingMesh._RowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
-GaussianSplattingMesh._SH_C0 = 0.28209479177387814;
-// batch size between 2 yield calls. This value is a tradeoff between updates overhead and framerate hiccups
-// This step is faster the PLY conversion. So batch size can be bigger
-GaussianSplattingMesh._SplatBatchSize = 327680;
-// batch size between 2 yield calls during the PLY to splat conversion.
-GaussianSplattingMesh._PlyConversionBatchSize = 32768;
-/**
- * Set the number of batch (a batch is 16384 splats) after which a display update is performed
- * A value of 0 (default) means display update will not happens before splat is ready.
- */
-GaussianSplattingMesh.ProgressiveUpdateAmount = 0;
-GaussianSplattingMesh._CreateWorker = function (self) {
-    let 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[4 * j + 0] + viewProj[6] * positions[4 * j + 1] + viewProj[10] * positions[4 * j + 2]) * depthFactor;
-            }
-            depthMix.sort();
-            self.postMessage({ depthMix }, [depthMix.buffer]);
-        }
-    };
-};
-
-/**
- * Represents one particle of a points cloud system.
- */
-class CloudPoint {
-    /**
-     * Creates a Point Cloud object.
-     * Don't create particles manually, use instead the PCS internal tools like _addParticle()
-     * @param particleIndex (integer) is the particle index in the PCS pool. It's also the particle identifier.
-     * @param group (PointsGroup) is the group the particle belongs to
-     * @param groupId (integer) is the group identifier in the PCS.
-     * @param idxInGroup (integer) is the index of the particle in the current point group (ex: the 10th point of addPoints(30))
-     * @param pcs defines the PCS it is associated to
-     */
-    constructor(particleIndex, group, groupId, idxInGroup, pcs) {
-        /**
-         * particle global index
-         */
-        this.idx = 0;
-        /**
-         * The color of the particle
-         */
-        this.color = new Color4(1.0, 1.0, 1.0, 1.0);
-        /**
-         * The world space position of the particle.
-         */
-        this.position = Vector3.Zero();
-        /**
-         * The world space rotation of the particle. (Not use if rotationQuaternion is set)
-         */
-        this.rotation = Vector3.Zero();
-        /**
-         * The uv of the particle.
-         */
-        this.uv = new Vector2(0.0, 0.0);
-        /**
-         * The current speed of the particle.
-         */
-        this.velocity = Vector3.Zero();
-        /**
-         * The pivot point in the particle local space.
-         */
-        this.pivot = Vector3.Zero();
-        /**
-         * Must the particle be translated from its pivot point in its local space ?
-         * In this case, the pivot point is set at the origin of the particle local space and the particle is translated.
-         * Default : false
-         */
-        this.translateFromPivot = false;
-        /**
-         * Index of this particle in the global "positions" array (Internal use)
-         * @internal
-         */
-        this._pos = 0;
-        /**
-         * @internal Index of this particle in the global "indices" array (Internal use)
-         */
-        this._ind = 0;
-        /**
-         * Group id of this particle
-         */
-        this.groupId = 0;
-        /**
-         * Index of the particle in its group id (Internal use)
-         */
-        this.idxInGroup = 0;
-        /**
-         * @internal Still set as invisible in order to skip useless computations (Internal use)
-         */
-        this._stillInvisible = false;
-        /**
-         * @internal Last computed particle rotation matrix
-         */
-        this._rotationMatrix = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
-        /**
-         * Parent particle Id, if any.
-         * Default null.
-         */
-        this.parentId = null;
-        /**
-         * @internal Internal global position in the PCS.
-         */
-        this._globalPosition = Vector3.Zero();
-        this.idx = particleIndex;
-        this._group = group;
-        this.groupId = groupId;
-        this.idxInGroup = idxInGroup;
-        this._pcs = pcs;
-    }
-    /**
-     * get point size
-     */
-    get size() {
-        return this.size;
-    }
-    /**
-     * Set point size
-     */
-    set size(scale) {
-        this.size = scale;
-    }
-    /**
-     * Legacy support, changed quaternion to rotationQuaternion
-     */
-    get quaternion() {
-        return this.rotationQuaternion;
-    }
-    /**
-     * Legacy support, changed quaternion to rotationQuaternion
-     */
-    set quaternion(q) {
-        this.rotationQuaternion = q;
-    }
-    /**
-     * Returns a boolean. True if the particle intersects a mesh, else false
-     * The intersection is computed on the particle position and Axis Aligned Bounding Box (AABB) or Sphere
-     * @param target is the object (point or mesh) what the intersection is computed against
-     * @param isSphere is boolean flag when false (default) bounding box of mesh is used, when true the bounding sphere is used
-     * @returns true if it intersects
-     */
-    intersectsMesh(target, isSphere) {
-        if (!target.hasBoundingInfo) {
-            return false;
-        }
-        if (!this._pcs.mesh) {
-            throw new Error("Point Cloud System doesnt contain the Mesh");
-        }
-        if (isSphere) {
-            return target.getBoundingInfo().boundingSphere.intersectsPoint(this.position.add(this._pcs.mesh.position));
-        }
-        const bbox = target.getBoundingInfo().boundingBox;
-        const maxX = bbox.maximumWorld.x;
-        const minX = bbox.minimumWorld.x;
-        const maxY = bbox.maximumWorld.y;
-        const minY = bbox.minimumWorld.y;
-        const maxZ = bbox.maximumWorld.z;
-        const minZ = bbox.minimumWorld.z;
-        const x = this.position.x + this._pcs.mesh.position.x;
-        const y = this.position.y + this._pcs.mesh.position.y;
-        const z = this.position.z + this._pcs.mesh.position.z;
-        return minX <= x && x <= maxX && minY <= y && y <= maxY && minZ <= z && z <= maxZ;
-    }
-    /**
-     * get the rotation matrix of the particle
-     * @internal
-     */
-    getRotationMatrix(m) {
-        let quaternion;
-        if (this.rotationQuaternion) {
-            quaternion = this.rotationQuaternion;
-        }
-        else {
-            quaternion = TmpVectors.Quaternion[0];
-            const rotation = this.rotation;
-            Quaternion.RotationYawPitchRollToRef(rotation.y, rotation.x, rotation.z, quaternion);
-        }
-        quaternion.toRotationMatrix(m);
-    }
-}
-/**
- * Represents a group of points in a points cloud system
- *  * PCS internal tool, don't use it manually.
- */
-class PointsGroup {
-    /**
-     * Get or set the groupId
-     * @deprecated Please use groupId instead
-     */
-    get groupID() {
-        return this.groupId;
-    }
-    set groupID(groupID) {
-        this.groupId = groupID;
-    }
-    /**
-     * Creates a points group object. This is an internal reference to produce particles for the PCS.
-     * PCS internal tool, don't use it manually.
-     * @internal
-     */
-    constructor(id, posFunction) {
-        this.groupId = id;
-        this._positionFunction = posFunction;
-    }
-}
-
-/**
- * Class representing a ray with position and direction
- */
-class Ray {
-    /**
-     * Creates a new ray
-     * @param origin origin point
-     * @param direction direction
-     * @param length length of the ray
-     * @param epsilon The epsilon value to use when calculating the ray/triangle intersection (default: 0)
-     */
-    constructor(
-    /** origin point */
-    origin, 
-    /** direction */
-    direction, 
-    /** [Number.MAX_VALUE] length of the ray */
-    length = Number.MAX_VALUE, 
-    /** [Epsilon] The epsilon value to use when calculating the ray/triangle intersection (default: Epsilon from math constants) */
-    epsilon = Epsilon) {
-        this.origin = origin;
-        this.direction = direction;
-        this.length = length;
-        this.epsilon = epsilon;
-    }
-    // Methods
-    /**
-     * Clone the current ray
-     * @returns a new ray
-     */
-    clone() {
-        return new Ray(this.origin.clone(), this.direction.clone(), this.length);
-    }
-    /**
-     * Checks if the ray intersects a box
-     * This does not account for the ray length by design to improve perfs.
-     * @param minimum bound of the box
-     * @param maximum bound of the box
-     * @param intersectionTreshold extra extend to be added to the box in all direction
-     * @returns if the box was hit
-     */
-    intersectsBoxMinMax(minimum, maximum, intersectionTreshold = 0) {
-        const newMinimum = Ray._TmpVector3[0].copyFromFloats(minimum.x - intersectionTreshold, minimum.y - intersectionTreshold, minimum.z - intersectionTreshold);
-        const newMaximum = Ray._TmpVector3[1].copyFromFloats(maximum.x + intersectionTreshold, maximum.y + intersectionTreshold, maximum.z + intersectionTreshold);
-        let d = 0.0;
-        let maxValue = Number.MAX_VALUE;
-        let inv;
-        let min;
-        let max;
-        let temp;
-        if (Math.abs(this.direction.x) < 0.0000001) {
-            if (this.origin.x < newMinimum.x || this.origin.x > newMaximum.x) {
-                return false;
-            }
-        }
-        else {
-            inv = 1.0 / this.direction.x;
-            min = (newMinimum.x - this.origin.x) * inv;
-            max = (newMaximum.x - this.origin.x) * inv;
-            if (max === -Infinity) {
-                max = Infinity;
-            }
-            if (min > max) {
-                temp = min;
-                min = max;
-                max = temp;
-            }
-            d = Math.max(min, d);
-            maxValue = Math.min(max, maxValue);
-            if (d > maxValue) {
-                return false;
-            }
-        }
-        if (Math.abs(this.direction.y) < 0.0000001) {
-            if (this.origin.y < newMinimum.y || this.origin.y > newMaximum.y) {
-                return false;
-            }
-        }
-        else {
-            inv = 1.0 / this.direction.y;
-            min = (newMinimum.y - this.origin.y) * inv;
-            max = (newMaximum.y - this.origin.y) * inv;
-            if (max === -Infinity) {
-                max = Infinity;
-            }
-            if (min > max) {
-                temp = min;
-                min = max;
-                max = temp;
-            }
-            d = Math.max(min, d);
-            maxValue = Math.min(max, maxValue);
-            if (d > maxValue) {
-                return false;
-            }
-        }
-        if (Math.abs(this.direction.z) < 0.0000001) {
-            if (this.origin.z < newMinimum.z || this.origin.z > newMaximum.z) {
-                return false;
-            }
-        }
-        else {
-            inv = 1.0 / this.direction.z;
-            min = (newMinimum.z - this.origin.z) * inv;
-            max = (newMaximum.z - this.origin.z) * inv;
-            if (max === -Infinity) {
-                max = Infinity;
-            }
-            if (min > max) {
-                temp = min;
-                min = max;
-                max = temp;
-            }
-            d = Math.max(min, d);
-            maxValue = Math.min(max, maxValue);
-            if (d > maxValue) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Checks if the ray intersects a box
-     * This does not account for the ray lenght by design to improve perfs.
-     * @param box the bounding box to check
-     * @param intersectionTreshold extra extend to be added to the BoundingBox in all direction
-     * @returns if the box was hit
-     */
-    intersectsBox(box, intersectionTreshold = 0) {
-        return this.intersectsBoxMinMax(box.minimum, box.maximum, intersectionTreshold);
-    }
-    /**
-     * If the ray hits a sphere
-     * @param sphere the bounding sphere to check
-     * @param intersectionTreshold extra extend to be added to the BoundingSphere in all direction
-     * @returns true if it hits the sphere
-     */
-    intersectsSphere(sphere, intersectionTreshold = 0) {
-        const x = sphere.center.x - this.origin.x;
-        const y = sphere.center.y - this.origin.y;
-        const z = sphere.center.z - this.origin.z;
-        const pyth = x * x + y * y + z * z;
-        const radius = sphere.radius + intersectionTreshold;
-        const rr = radius * radius;
-        if (pyth <= rr) {
-            return true;
-        }
-        const dot = x * this.direction.x + y * this.direction.y + z * this.direction.z;
-        if (dot < 0.0) {
-            return false;
-        }
-        const temp = pyth - dot * dot;
-        return temp <= rr;
-    }
-    /**
-     * If the ray hits a triange
-     * @param vertex0 triangle vertex
-     * @param vertex1 triangle vertex
-     * @param vertex2 triangle vertex
-     * @returns intersection information if hit
-     */
-    intersectsTriangle(vertex0, vertex1, vertex2) {
-        const edge1 = Ray._TmpVector3[0];
-        const edge2 = Ray._TmpVector3[1];
-        const pvec = Ray._TmpVector3[2];
-        const tvec = Ray._TmpVector3[3];
-        const qvec = Ray._TmpVector3[4];
-        vertex1.subtractToRef(vertex0, edge1);
-        vertex2.subtractToRef(vertex0, edge2);
-        Vector3.CrossToRef(this.direction, edge2, pvec);
-        const det = Vector3.Dot(edge1, pvec);
-        if (det === 0) {
-            return null;
-        }
-        const invdet = 1 / det;
-        this.origin.subtractToRef(vertex0, tvec);
-        const bv = Vector3.Dot(tvec, pvec) * invdet;
-        if (bv < -this.epsilon || bv > 1.0 + this.epsilon) {
-            return null;
-        }
-        Vector3.CrossToRef(tvec, edge1, qvec);
-        const bw = Vector3.Dot(this.direction, qvec) * invdet;
-        if (bw < -this.epsilon || bv + bw > 1.0 + this.epsilon) {
-            return null;
-        }
-        //check if the distance is longer than the predefined length.
-        const distance = Vector3.Dot(edge2, qvec) * invdet;
-        if (distance > this.length) {
-            return null;
-        }
-        return new IntersectionInfo(1 - bv - bw, bv, distance);
-    }
-    /**
-     * Checks if ray intersects a plane
-     * @param plane the plane to check
-     * @returns the distance away it was hit
-     */
-    intersectsPlane(plane) {
-        let distance;
-        const result1 = Vector3.Dot(plane.normal, this.direction);
-        if (Math.abs(result1) < 9.99999997475243e-7) {
-            return null;
-        }
-        else {
-            const result2 = Vector3.Dot(plane.normal, this.origin);
-            distance = (-plane.d - result2) / result1;
-            if (distance < 0.0) {
-                if (distance < -9.99999997475243e-7) {
-                    return null;
-                }
-                else {
-                    return 0;
-                }
-            }
-            return distance;
-        }
-    }
-    /**
-     * Calculate the intercept of a ray on a given axis
-     * @param axis to check 'x' | 'y' | 'z'
-     * @param offset from axis interception (i.e. an offset of 1y is intercepted above ground)
-     * @returns a vector containing the coordinates where 'axis' is equal to zero (else offset), or null if there is no intercept.
-     */
-    intersectsAxis(axis, offset = 0) {
-        switch (axis) {
-            case "y": {
-                const t = (this.origin.y - offset) / this.direction.y;
-                if (t > 0) {
-                    return null;
-                }
-                return new Vector3(this.origin.x + this.direction.x * -t, offset, this.origin.z + this.direction.z * -t);
-            }
-            case "x": {
-                const t = (this.origin.x - offset) / this.direction.x;
-                if (t > 0) {
-                    return null;
-                }
-                return new Vector3(offset, this.origin.y + this.direction.y * -t, this.origin.z + this.direction.z * -t);
-            }
-            case "z": {
-                const t = (this.origin.z - offset) / this.direction.z;
-                if (t > 0) {
-                    return null;
-                }
-                return new Vector3(this.origin.x + this.direction.x * -t, this.origin.y + this.direction.y * -t, offset);
-            }
-            default:
-                return null;
-        }
-    }
-    /**
-     * Checks if ray intersects a mesh. The ray is defined in WORLD space. A mesh triangle can be picked both from its front and back sides,
-     * irrespective of orientation.
-     * @param mesh the mesh to check
-     * @param fastCheck defines if the first intersection will be used (and not the closest)
-     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
-     * @param onlyBoundingInfo defines a boolean indicating if picking should only happen using bounding info (false by default)
-     * @param worldToUse defines the world matrix to use to get the world coordinate of the intersection point
-     * @param skipBoundingInfo a boolean indicating if we should skip the bounding info check
-     * @returns picking info of the intersection
-     */
-    intersectsMesh(mesh, fastCheck, trianglePredicate, onlyBoundingInfo = false, worldToUse, skipBoundingInfo = false) {
-        const tm = TmpVectors.Matrix[0];
-        mesh.getWorldMatrix().invertToRef(tm);
-        if (this._tmpRay) {
-            Ray.TransformToRef(this, tm, this._tmpRay);
-        }
-        else {
-            this._tmpRay = Ray.Transform(this, tm);
-        }
-        return mesh.intersects(this._tmpRay, fastCheck, trianglePredicate, onlyBoundingInfo, worldToUse, skipBoundingInfo);
-    }
-    /**
-     * Checks if ray intersects a mesh
-     * @param meshes the meshes to check
-     * @param fastCheck defines if the first intersection will be used (and not the closest)
-     * @param results array to store result in
-     * @returns Array of picking infos
-     */
-    intersectsMeshes(meshes, fastCheck, results) {
-        if (results) {
-            results.length = 0;
-        }
-        else {
-            results = [];
-        }
-        for (let i = 0; i < meshes.length; i++) {
-            const pickInfo = this.intersectsMesh(meshes[i], fastCheck);
-            if (pickInfo.hit) {
-                results.push(pickInfo);
-            }
-        }
-        results.sort(this._comparePickingInfo);
-        return results;
-    }
-    _comparePickingInfo(pickingInfoA, pickingInfoB) {
-        if (pickingInfoA.distance < pickingInfoB.distance) {
-            return -1;
-        }
-        else if (pickingInfoA.distance > pickingInfoB.distance) {
-            return 1;
-        }
-        else {
-            return 0;
-        }
-    }
-    /**
-     * Intersection test between the ray and a given segment within a given tolerance (threshold)
-     * @param sega the first point of the segment to test the intersection against
-     * @param segb the second point of the segment to test the intersection against
-     * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
-     * @returns the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
-     */
-    intersectionSegment(sega, segb, threshold) {
-        const o = this.origin;
-        const u = TmpVectors.Vector3[0];
-        const rsegb = TmpVectors.Vector3[1];
-        const v = TmpVectors.Vector3[2];
-        const w = TmpVectors.Vector3[3];
-        segb.subtractToRef(sega, u);
-        this.direction.scaleToRef(Ray._Rayl, v);
-        o.addToRef(v, rsegb);
-        sega.subtractToRef(o, w);
-        const a = Vector3.Dot(u, u); // always >= 0
-        const b = Vector3.Dot(u, v);
-        const c = Vector3.Dot(v, v); // always >= 0
-        const d = Vector3.Dot(u, w);
-        const e = Vector3.Dot(v, w);
-        const D = a * c - b * b; // always >= 0
-        let sN, sD = D; // sc = sN / sD, default sD = D >= 0
-        let tN, tD = D; // tc = tN / tD, default tD = D >= 0
-        // compute the line parameters of the two closest points
-        if (D < Ray._Smallnum) {
-            // the lines are almost parallel
-            sN = 0.0; // force using point P0 on segment S1
-            sD = 1.0; // to prevent possible division by 0.0 later
-            tN = e;
-            tD = c;
-        }
-        else {
-            // get the closest points on the infinite lines
-            sN = b * e - c * d;
-            tN = a * e - b * d;
-            if (sN < 0.0) {
-                // sc < 0 => the s=0 edge is visible
-                sN = 0.0;
-                tN = e;
-                tD = c;
-            }
-            else if (sN > sD) {
-                // sc > 1 => the s=1 edge is visible
-                sN = sD;
-                tN = e + b;
-                tD = c;
-            }
-        }
-        if (tN < 0.0) {
-            // tc < 0 => the t=0 edge is visible
-            tN = 0.0;
-            // recompute sc for this edge
-            if (-d < 0.0) {
-                sN = 0.0;
-            }
-            else if (-d > a) {
-                sN = sD;
-            }
-            else {
-                sN = -d;
-                sD = a;
-            }
-        }
-        else if (tN > tD) {
-            // tc > 1 => the t=1 edge is visible
-            tN = tD;
-            // recompute sc for this edge
-            if (-d + b < 0.0) {
-                sN = 0;
-            }
-            else if (-d + b > a) {
-                sN = sD;
-            }
-            else {
-                sN = -d + b;
-                sD = a;
-            }
-        }
-        // finally do the division to get sc and tc
-        const sc = Math.abs(sN) < Ray._Smallnum ? 0.0 : sN / sD;
-        const tc = Math.abs(tN) < Ray._Smallnum ? 0.0 : tN / tD;
-        // get the difference of the two closest points
-        const qtc = TmpVectors.Vector3[4];
-        v.scaleToRef(tc, qtc);
-        const qsc = TmpVectors.Vector3[5];
-        u.scaleToRef(sc, qsc);
-        qsc.addInPlace(w);
-        const dP = TmpVectors.Vector3[6];
-        qsc.subtractToRef(qtc, dP); // = S1(sc) - S2(tc)
-        const isIntersected = tc > 0 && tc <= this.length && dP.lengthSquared() < threshold * threshold; // return intersection result
-        if (isIntersected) {
-            return qsc.length();
-        }
-        return -1;
-    }
-    /**
-     * Update the ray from viewport position
-     * @param x position
-     * @param y y position
-     * @param viewportWidth viewport width
-     * @param viewportHeight viewport height
-     * @param world world matrix
-     * @param view view matrix
-     * @param projection projection matrix
-     * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
-     * @returns this ray updated
-     */
-    update(x, y, viewportWidth, viewportHeight, world, view, projection, enableDistantPicking = false) {
-        if (enableDistantPicking) {
-            // With world matrices having great values (like 8000000000 on 1 or more scaling or position axis),
-            // multiplying view/projection/world and doing invert will result in loss of float precision in the matrix.
-            // One way to fix it is to compute the ray with world at identity then transform the ray in object space.
-            // This is slower (2 matrix inverts instead of 1) but precision is preserved.
-            // This is hidden behind `EnableDistantPicking` flag (default is false)
-            if (!Ray._RayDistant) {
-                Ray._RayDistant = Ray.Zero();
-            }
-            Ray._RayDistant.unprojectRayToRef(x, y, viewportWidth, viewportHeight, Matrix.IdentityReadOnly, view, projection);
-            const tm = TmpVectors.Matrix[0];
-            world.invertToRef(tm);
-            Ray.TransformToRef(Ray._RayDistant, tm, this);
-        }
-        else {
-            this.unprojectRayToRef(x, y, viewportWidth, viewportHeight, world, view, projection);
-        }
-        return this;
-    }
-    // Statics
-    /**
-     * Creates a ray with origin and direction of 0,0,0
-     * @returns the new ray
-     */
-    static Zero() {
-        return new Ray(Vector3.Zero(), Vector3.Zero());
-    }
-    /**
-     * Creates a new ray from screen space and viewport
-     * @param x position
-     * @param y y position
-     * @param viewportWidth viewport width
-     * @param viewportHeight viewport height
-     * @param world world matrix
-     * @param view view matrix
-     * @param projection projection matrix
-     * @returns new ray
-     */
-    static CreateNew(x, y, viewportWidth, viewportHeight, world, view, projection) {
-        const result = Ray.Zero();
-        return result.update(x, y, viewportWidth, viewportHeight, world, view, projection);
-    }
-    /**
-     * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
-     * transformed to the given world matrix.
-     * @param origin The origin point
-     * @param end The end point
-     * @param world a matrix to transform the ray to. Default is the identity matrix.
-     * @returns the new ray
-     */
-    static CreateNewFromTo(origin, end, world = Matrix.IdentityReadOnly) {
-        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));
-        return Ray.CreateFromToToRef(origin, end, result, world);
-    }
-    /**
-     * Function will update a transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
-     * transformed to the given world matrix.
-     * @param origin The origin point
-     * @param end The end point
-     * @param result the object to store the result
-     * @param world a matrix to transform the ray to. Default is the identity matrix.
-     * @returns the ref ray
-     */
-    static CreateFromToToRef(origin, end, result, world = Matrix.IdentityReadOnly) {
-        result.origin.copyFrom(origin);
-        const direction = end.subtractToRef(origin, result.direction);
-        const length = Math.sqrt(direction.x * direction.x + direction.y * direction.y + direction.z * direction.z);
-        result.length = length;
-        result.direction.normalize();
-        return Ray.TransformToRef(result, world, result);
-    }
-    /**
-     * Transforms a ray by a matrix
-     * @param ray ray to transform
-     * @param matrix matrix to apply
-     * @returns the resulting new ray
-     */
-    static Transform(ray, matrix) {
-        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));
-        Ray.TransformToRef(ray, matrix, result);
-        return result;
-    }
-    /**
-     * Transforms a ray by a matrix
-     * @param ray ray to transform
-     * @param matrix matrix to apply
-     * @param result ray to store result in
-     * @returns the updated result ray
-     */
-    static TransformToRef(ray, matrix, result) {
-        Vector3.TransformCoordinatesToRef(ray.origin, matrix, result.origin);
-        Vector3.TransformNormalToRef(ray.direction, matrix, result.direction);
-        result.length = ray.length;
-        result.epsilon = ray.epsilon;
-        const dir = result.direction;
-        const len = dir.length();
-        if (!(len === 0 || len === 1)) {
-            const num = 1.0 / len;
-            dir.x *= num;
-            dir.y *= num;
-            dir.z *= num;
-            result.length *= len;
-        }
-        return result;
-    }
-    /**
-     * Unproject a ray from screen space to object space
-     * @param sourceX defines the screen space x coordinate to use
-     * @param sourceY defines the screen space y coordinate to use
-     * @param viewportWidth defines the current width of the viewport
-     * @param viewportHeight defines the current height of the viewport
-     * @param world defines the world matrix to use (can be set to Identity to go to world space)
-     * @param view defines the view matrix to use
-     * @param projection defines the projection matrix to use
-     */
-    unprojectRayToRef(sourceX, sourceY, viewportWidth, viewportHeight, world, view, projection) {
-        const matrix = TmpVectors.Matrix[0];
-        world.multiplyToRef(view, matrix);
-        matrix.multiplyToRef(projection, matrix);
-        matrix.invert();
-        const engine = EngineStore.LastCreatedEngine;
-        const nearScreenSource = TmpVectors.Vector3[0];
-        nearScreenSource.x = (sourceX / viewportWidth) * 2 - 1;
-        nearScreenSource.y = -((sourceY / viewportHeight) * 2 - 1);
-        nearScreenSource.z = engine?.useReverseDepthBuffer ? 1 : engine?.isNDCHalfZRange ? 0 : -1;
-        // far Z need to be close but < to 1 or camera projection matrix with maxZ = 0 will NaN
-        const farScreenSource = TmpVectors.Vector3[1].copyFromFloats(nearScreenSource.x, nearScreenSource.y, 1.0 - 1e-8);
-        const nearVec3 = TmpVectors.Vector3[2];
-        const farVec3 = TmpVectors.Vector3[3];
-        Vector3._UnprojectFromInvertedMatrixToRef(nearScreenSource, matrix, nearVec3);
-        Vector3._UnprojectFromInvertedMatrixToRef(farScreenSource, matrix, farVec3);
-        this.origin.copyFrom(nearVec3);
-        farVec3.subtractToRef(nearVec3, this.direction);
-        this.direction.normalize();
-    }
-}
-Ray._TmpVector3 = BuildArray(6, Vector3.Zero);
-Ray._RayDistant = Ray.Zero();
-Ray._Smallnum = 0.00000001;
-Ray._Rayl = 10e8;
-/**
- * Creates a ray that can be used to pick in the scene
- * @param scene defines the scene to use for the picking
- * @param x defines the x coordinate of the origin (on-screen)
- * @param y defines the y coordinate of the origin (on-screen)
- * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
- * @param camera defines the camera to use for the picking
- * @param cameraViewSpace defines if picking will be done in view space (false by default)
- * @returns a Ray
- */
-function CreatePickingRay(scene, x, y, world, camera, cameraViewSpace = false) {
-    const result = Ray.Zero();
-    CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace);
-    return result;
-}
-/**
- * Creates a ray that can be used to pick in the scene
- * @param scene defines the scene to use for the picking
- * @param x defines the x coordinate of the origin (on-screen)
- * @param y defines the y coordinate of the origin (on-screen)
- * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
- * @param result defines the ray where to store the picking ray
- * @param camera defines the camera to use for the picking
- * @param cameraViewSpace defines if picking will be done in view space (false by default)
- * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
- * @returns the current scene
- */
-function CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {
-    const engine = scene.getEngine();
-    if (!camera && !(camera = scene.activeCamera)) {
-        return scene;
-    }
-    const cameraViewport = camera.viewport;
-    const renderHeight = engine.getRenderHeight();
-    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);
-    // Moving coordinates to local viewport world
-    const levelInv = 1 / engine.getHardwareScalingLevel();
-    x = x * levelInv - vx;
-    y = y * levelInv - (renderHeight - vy - height);
-    result.update(x, y, width, height, world ? world : Matrix.IdentityReadOnly, cameraViewSpace ? Matrix.IdentityReadOnly : camera.getViewMatrix(), camera.getProjectionMatrix(), enableDistantPicking);
-    return scene;
-}
-/**
- * Creates a ray that can be used to pick in the scene
- * @param scene defines the scene to use for the picking
- * @param x defines the x coordinate of the origin (on-screen)
- * @param y defines the y coordinate of the origin (on-screen)
- * @param camera defines the camera to use for the picking
- * @returns a Ray
- */
-function CreatePickingRayInCameraSpace(scene, x, y, camera) {
-    const result = Ray.Zero();
-    CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera);
-    return result;
-}
-/**
- * Creates a ray that can be used to pick in the scene
- * @param scene defines the scene to use for the picking
- * @param x defines the x coordinate of the origin (on-screen)
- * @param y defines the y coordinate of the origin (on-screen)
- * @param result defines the ray where to store the picking ray
- * @param camera defines the camera to use for the picking
- * @returns the current scene
- */
-function CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera) {
-    if (!PickingInfo) {
-        return scene;
-    }
-    const engine = scene.getEngine();
-    if (!camera && !(camera = scene.activeCamera)) {
-        throw new Error("Active camera not set");
-    }
-    const cameraViewport = camera.viewport;
-    const renderHeight = engine.getRenderHeight();
-    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);
-    const identity = Matrix.Identity();
-    // Moving coordinates to local viewport world
-    const levelInv = 1 / engine.getHardwareScalingLevel();
-    x = x * levelInv - vx;
-    y = y * levelInv - (renderHeight - vy - height);
-    result.update(x, y, width, height, identity, identity, camera.getProjectionMatrix());
-    return scene;
-}
-function InternalPickForMesh(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate, skipBoundingInfo) {
-    const ray = rayFunction(world, mesh.enableDistantPicking);
-    const result = mesh.intersects(ray, fastCheck, trianglePredicate, onlyBoundingInfo, world, skipBoundingInfo);
-    if (!result || !result.hit) {
-        return null;
-    }
-    if (!fastCheck && pickingInfo != null && result.distance >= pickingInfo.distance) {
-        return null;
-    }
-    return result;
-}
-function InternalPick(scene, rayFunction, predicate, fastCheck, onlyBoundingInfo, trianglePredicate) {
-    let pickingInfo = null;
-    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);
-    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;
-    const picker = InternalPickForMesh;
-    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {
-        const mesh = scene.meshes[meshIndex];
-        if (predicate) {
-            if (!predicate(mesh, -1)) {
-                continue;
-            }
-        }
-        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {
-            continue;
-        }
-        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();
-        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);
-        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {
-            // first check if the ray intersects the whole bounding box/sphere of the mesh
-            const result = picker(pickingInfo, rayFunction, mesh, world, true, true, trianglePredicate);
-            if (result) {
-                if (onlyBoundingInfo) {
-                    // the user only asked for a bounding info check so we can return
-                    return result;
-                }
-                const tmpMatrix = TmpVectors.Matrix[1];
-                const thinMatrices = mesh.thinInstanceGetWorldMatrices();
-                for (let index = 0; index < thinMatrices.length; index++) {
-                    if (predicate && !predicate(mesh, index)) {
-                        continue;
-                    }
-                    const thinMatrix = thinMatrices[index];
-                    thinMatrix.multiplyToRef(world, tmpMatrix);
-                    const result = picker(pickingInfo, rayFunction, mesh, tmpMatrix, fastCheck, onlyBoundingInfo, trianglePredicate, true);
-                    if (result) {
-                        pickingInfo = result;
-                        pickingInfo.thinInstanceIndex = index;
-                        if (fastCheck) {
-                            return pickingInfo;
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            const result = picker(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate);
-            if (result) {
-                pickingInfo = result;
-                if (fastCheck) {
-                    return pickingInfo;
-                }
-            }
-        }
-    }
-    return pickingInfo || new PickingInfo();
-}
-function InternalMultiPick(scene, rayFunction, predicate, trianglePredicate) {
-    if (!PickingInfo) {
-        return null;
-    }
-    const pickingInfos = [];
-    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);
-    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;
-    const picker = InternalPickForMesh;
-    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {
-        const mesh = scene.meshes[meshIndex];
-        if (predicate) {
-            if (!predicate(mesh, -1)) {
-                continue;
-            }
-        }
-        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {
-            continue;
-        }
-        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();
-        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);
-        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {
-            const result = picker(null, rayFunction, mesh, world, true, true, trianglePredicate);
-            if (result) {
-                const tmpMatrix = TmpVectors.Matrix[1];
-                const thinMatrices = mesh.thinInstanceGetWorldMatrices();
-                for (let index = 0; index < thinMatrices.length; index++) {
-                    if (predicate && !predicate(mesh, index)) {
-                        continue;
-                    }
-                    const thinMatrix = thinMatrices[index];
-                    thinMatrix.multiplyToRef(world, tmpMatrix);
-                    const result = picker(null, rayFunction, mesh, tmpMatrix, false, false, trianglePredicate, true);
-                    if (result) {
-                        result.thinInstanceIndex = index;
-                        pickingInfos.push(result);
-                    }
-                }
-            }
-        }
-        else {
-            const result = picker(null, rayFunction, mesh, world, false, false, trianglePredicate);
-            if (result) {
-                pickingInfos.push(result);
-            }
-        }
-    }
-    return pickingInfos;
-}
-/** Launch a ray to try to pick a mesh in the scene using only bounding information of the main mesh (not using submeshes)
- * @param scene defines the scene to use for the picking
- * @param x position on screen
- * @param y position on screen
- * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
- * @param fastCheck defines if the first intersection will be used (and not the closest)
- * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
- * @returns a PickingInfo (Please note that some info will not be set like distance, bv, bu and everything that cannot be capture by only using bounding infos)
- */
-function PickWithBoundingInfo(scene, x, y, predicate, fastCheck, camera) {
-    if (!PickingInfo) {
-        return null;
-    }
-    const result = InternalPick(scene, (world) => {
-        if (!scene._tempPickingRay) {
-            scene._tempPickingRay = Ray.Zero();
-        }
-        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null);
-        return scene._tempPickingRay;
-    }, predicate, fastCheck, true);
-    if (result) {
-        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);
-    }
-    return result;
-}
-/** Launch a ray to try to pick a mesh in the scene
- * @param scene defines the scene to use for the picking
- * @param x position on screen
- * @param y position on screen
- * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
- * @param fastCheck defines if the first intersection will be used (and not the closest)
- * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
- * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
- * @param _enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
- * @returns a PickingInfo
- */
-function Pick(scene, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {
-    const result = InternalPick(scene, (world, enableDistantPicking) => {
-        if (!scene._tempPickingRay) {
-            scene._tempPickingRay = Ray.Zero();
-        }
-        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null, false, enableDistantPicking);
-        return scene._tempPickingRay;
-    }, predicate, fastCheck, false, trianglePredicate);
-    if (result) {
-        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);
-    }
-    return result;
-}
-/**
- * Use the given ray to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
- * irrespective of orientation.
- * @param scene defines the scene to use for the picking
- * @param ray The ray to use to pick meshes
- * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must have isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
- * @param fastCheck defines if the first intersection will be used (and not the closest)
- * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
- * @returns a PickingInfo
- */
-function PickWithRay(scene, ray, predicate, fastCheck, trianglePredicate) {
-    const result = InternalPick(scene, (world) => {
-        if (!scene._pickWithRayInverseMatrix) {
-            scene._pickWithRayInverseMatrix = Matrix.Identity();
-        }
-        world.invertToRef(scene._pickWithRayInverseMatrix);
-        if (!scene._cachedRayForTransform) {
-            scene._cachedRayForTransform = Ray.Zero();
-        }
-        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);
-        return scene._cachedRayForTransform;
-    }, predicate, fastCheck, false, trianglePredicate);
-    if (result) {
-        result.ray = ray;
-    }
-    return result;
-}
-/**
- * Launch a ray to try to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
- * irrespective of orientation.
- * @param scene defines the scene to use for the picking
- * @param x X position on screen
- * @param y Y position on screen
- * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
- * @param camera camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
- * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
- * @returns an array of PickingInfo
- */
-function MultiPick(scene, x, y, predicate, camera, trianglePredicate) {
-    return InternalMultiPick(scene, (world) => CreatePickingRay(scene, x, y, world, camera || null), predicate, trianglePredicate);
-}
-/**
- * Launch a ray to try to pick a mesh in the scene
- * @param scene defines the scene to use for the picking
- * @param ray Ray to use
- * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced
- * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
- * @returns an array of PickingInfo
- */
-function MultiPickWithRay(scene, ray, predicate, trianglePredicate) {
-    return InternalMultiPick(scene, (world) => {
-        if (!scene._pickWithRayInverseMatrix) {
-            scene._pickWithRayInverseMatrix = Matrix.Identity();
-        }
-        world.invertToRef(scene._pickWithRayInverseMatrix);
-        if (!scene._cachedRayForTransform) {
-            scene._cachedRayForTransform = Ray.Zero();
-        }
-        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);
-        return scene._cachedRayForTransform;
-    }, predicate, trianglePredicate);
-}
-/**
- * Gets a ray in the forward direction from the camera.
- * @param camera Defines the camera to use to get the ray from
- * @param refRay the ray to (re)use when setting the values
- * @param length Defines the length of the ray to create
- * @param transform Defines the transform to apply to the ray, by default the world matrx is used to create a workd space ray
- * @param origin Defines the start point of the ray which defaults to the camera position
- * @returns the forward ray
- */
-function GetForwardRayToRef(camera, refRay, length = 100, transform, origin) {
-    if (!transform) {
-        transform = camera.getWorldMatrix();
-    }
-    refRay.length = length;
-    if (origin) {
-        refRay.origin.copyFrom(origin);
-    }
-    else {
-        refRay.origin.copyFrom(camera.position);
-    }
-    const forward = TmpVectors.Vector3[2];
-    forward.set(0, 0, camera._scene.useRightHandedSystem ? -1 : 1);
-    const worldForward = TmpVectors.Vector3[3];
-    Vector3.TransformNormalToRef(forward, transform, worldForward);
-    Vector3.NormalizeToRef(worldForward, refRay.direction);
-    return refRay;
-}
-/**
- * Initialize the minimal interdependecies between the Ray and Scene and Camera
- * @param sceneClass defines the scene prototype to use
- * @param cameraClass defines the camera prototype to use
- */
-function AddRayExtensions(sceneClass, cameraClass) {
-    if (cameraClass) {
-        cameraClass.prototype.getForwardRay = function (length = 100, transform, origin) {
-            return GetForwardRayToRef(this, new Ray(Vector3.Zero(), Vector3.Zero(), length), length, transform, origin);
-        };
-        cameraClass.prototype.getForwardRayToRef = function (refRay, length = 100, transform, origin) {
-            return GetForwardRayToRef(this, refRay, length, transform, origin);
-        };
-    }
-    if (!sceneClass) {
-        return;
-    }
-    _ImportHelper._IsPickingAvailable = true;
-    sceneClass.prototype.createPickingRay = function (x, y, world, camera, cameraViewSpace = false) {
-        return CreatePickingRay(this, x, y, world, camera, cameraViewSpace);
-    };
-}
-
-// Picking
-AddRayExtensions(Scene, Camera);
-Scene.prototype.createPickingRayToRef = function (x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {
-    return CreatePickingRayToRef(this, x, y, world, result, camera, cameraViewSpace, enableDistantPicking);
-};
-Scene.prototype.createPickingRayInCameraSpace = function (x, y, camera) {
-    return CreatePickingRayInCameraSpace(this, x, y, camera);
-};
-Scene.prototype.createPickingRayInCameraSpaceToRef = function (x, y, result, camera) {
-    return CreatePickingRayInCameraSpaceToRef(this, x, y, result, camera);
-};
-Scene.prototype.pickWithBoundingInfo = function (x, y, predicate, fastCheck, camera) {
-    return PickWithBoundingInfo(this, x, y, predicate, fastCheck, camera);
-};
-Scene.prototype.pick = function (x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {
-    return Pick(this, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking);
-};
-Scene.prototype.pickWithRay = function (ray, predicate, fastCheck, trianglePredicate) {
-    return PickWithRay(this, ray, predicate, fastCheck, trianglePredicate);
-};
-Scene.prototype.multiPick = function (x, y, predicate, camera, trianglePredicate) {
-    return MultiPick(this, x, y, predicate, camera, trianglePredicate);
-};
-Scene.prototype.multiPickWithRay = function (ray, predicate, trianglePredicate) {
-    return MultiPickWithRay(this, ray, predicate, trianglePredicate);
-};
-
-/** Defines the 4 color options */
-var PointColor;
-(function (PointColor) {
-    /** color value */
-    PointColor[PointColor["Color"] = 2] = "Color";
-    /** uv value */
-    PointColor[PointColor["UV"] = 1] = "UV";
-    /** random value */
-    PointColor[PointColor["Random"] = 0] = "Random";
-    /** stated value */
-    PointColor[PointColor["Stated"] = 3] = "Stated";
-})(PointColor || (PointColor = {}));
-/**
- * The PointCloudSystem (PCS) is a single updatable mesh. The points corresponding to the vertices of this big mesh.
- * As it is just a mesh, the PointCloudSystem has all the same properties as any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
-
- * The PointCloudSystem is also a particle system, with each point being a particle. It provides some methods to manage the particles.
- * However it is behavior agnostic. This means it has no emitter, no particle physics, no particle recycler. You have to implement your own behavior.
- *
- * Full documentation here : TO BE ENTERED
- */
-class PointsCloudSystem {
-    /**
-     * Gets the particle positions computed by the Point Cloud System
-     */
-    get positions() {
-        return this._positions32;
-    }
-    /**
-     * Gets the particle colors computed by the Point Cloud System
-     */
-    get colors() {
-        return this._colors32;
-    }
-    /**
-     * Gets the particle uvs computed by the Point Cloud System
-     */
-    get uvs() {
-        return this._uvs32;
-    }
-    /**
-     * Creates a PCS (Points Cloud System) object
-     * @param name (String) is the PCS name, this will be the underlying mesh name
-     * @param pointSize (number) is the size for each point. Has no effect on a WebGPU engine.
-     * @param scene (Scene) is the scene in which the PCS is added
-     * @param options defines the options of the PCS e.g.
-     * * updatable (optional boolean, default true) : if the PCS must be updatable or immutable
-     */
-    constructor(name, pointSize, scene, options) {
-        /**
-         *  The PCS array of cloud point objects. Just access each particle as with any classic array.
-         *  Example : var p = SPS.particles[i];
-         */
-        this.particles = new Array();
-        /**
-         * The PCS total number of particles. Read only. Use PCS.counter instead if you need to set your own value.
-         */
-        this.nbParticles = 0;
-        /**
-         * This a counter for your own usage. It's not set by any SPS functions.
-         */
-        this.counter = 0;
-        /**
-         * This empty object is intended to store some PCS specific or temporary values in order to lower the Garbage Collector activity.
-         * Please read :
-         */
-        this.vars = {};
-        this._promises = [];
-        this._positions = new Array();
-        this._indices = new Array();
-        this._normals = new Array();
-        this._colors = new Array();
-        this._uvs = new Array();
-        this._updatable = true;
-        this._isVisibilityBoxLocked = false;
-        this._alwaysVisible = false;
-        this._groups = new Array(); //start indices for each group of particles
-        this._groupCounter = 0;
-        this._computeParticleColor = true;
-        this._computeParticleTexture = true;
-        this._computeParticleRotation = true;
-        this._computeBoundingBox = false;
-        this._isReady = false;
-        this.name = name;
-        this._size = pointSize;
-        this._scene = scene || EngineStore.LastCreatedScene;
-        if (options && options.updatable !== undefined) {
-            this._updatable = options.updatable;
-        }
-        else {
-            this._updatable = true;
-        }
-    }
-    /**
-     * Builds the PCS underlying mesh. Returns a standard Mesh.
-     * If no points were added to the PCS, the returned mesh is just a single point.
-     * @param material The material to use to render the mesh. If not provided, will create a default one
-     * @returns a promise for the created mesh
-     */
-    buildMeshAsync(material) {
-        return Promise.all(this._promises).then(() => {
-            this._isReady = true;
-            return this._buildMesh(material);
-        });
-    }
-    /**
-     * @internal
-     */
-    _buildMesh(material) {
-        if (this.nbParticles === 0) {
-            this.addPoints(1);
-        }
-        this._positions32 = new Float32Array(this._positions);
-        this._uvs32 = new Float32Array(this._uvs);
-        this._colors32 = new Float32Array(this._colors);
-        const vertexData = new VertexData();
-        vertexData.set(this._positions32, VertexBuffer.PositionKind);
-        if (this._uvs32.length > 0) {
-            vertexData.set(this._uvs32, VertexBuffer.UVKind);
-        }
-        let ec = 0; //emissive color value 0 for UVs, 1 for color
-        if (this._colors32.length > 0) {
-            ec = 1;
-            vertexData.set(this._colors32, VertexBuffer.ColorKind);
-        }
-        const mesh = new Mesh(this.name, this._scene);
-        vertexData.applyToMesh(mesh, this._updatable);
-        this.mesh = mesh;
-        // free memory
-        this._positions = null;
-        this._uvs = null;
-        this._colors = null;
-        if (!this._updatable) {
-            this.particles.length = 0;
-        }
-        let mat = material;
-        if (!mat) {
-            mat = new StandardMaterial("point cloud material", this._scene);
-            mat.emissiveColor = new Color3(ec, ec, ec);
-            mat.disableLighting = true;
-            mat.pointsCloud = true;
-            mat.pointSize = this._size;
-        }
-        mesh.material = mat;
-        return new Promise((resolve) => resolve(mesh));
-    }
-    // adds a new particle object in the particles array
-    _addParticle(idx, group, groupId, idxInGroup) {
-        const cp = new CloudPoint(idx, group, groupId, idxInGroup, this);
-        this.particles.push(cp);
-        return cp;
-    }
-    _randomUnitVector(particle) {
-        particle.position = new Vector3(Math.random(), Math.random(), Math.random());
-        particle.color = new Color4(1, 1, 1, 1);
-    }
-    _getColorIndicesForCoord(pointsGroup, x, y, width) {
-        const imageData = pointsGroup._groupImageData;
-        const color = y * (width * 4) + x * 4;
-        const colorIndices = [color, color + 1, color + 2, color + 3];
-        const redIndex = colorIndices[0];
-        const greenIndex = colorIndices[1];
-        const blueIndex = colorIndices[2];
-        const alphaIndex = colorIndices[3];
-        const redForCoord = imageData[redIndex];
-        const greenForCoord = imageData[greenIndex];
-        const blueForCoord = imageData[blueIndex];
-        const alphaForCoord = imageData[alphaIndex];
-        return new Color4(redForCoord / 255, greenForCoord / 255, blueForCoord / 255, alphaForCoord);
-    }
-    _setPointsColorOrUV(mesh, pointsGroup, isVolume, colorFromTexture, hasTexture, color, range, uvSetIndex) {
-        uvSetIndex = uvSetIndex ?? 0;
-        if (isVolume) {
-            mesh.updateFacetData();
-        }
-        const boundInfo = mesh.getBoundingInfo();
-        const diameter = 2 * boundInfo.boundingSphere.radius;
-        let meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
-        const meshInd = mesh.getIndices();
-        const meshUV = mesh.getVerticesData(VertexBuffer.UVKind + (uvSetIndex ? uvSetIndex + 1 : ""));
-        const meshCol = mesh.getVerticesData(VertexBuffer.ColorKind);
-        const place = Vector3.Zero();
-        mesh.computeWorldMatrix();
-        const meshMatrix = mesh.getWorldMatrix();
-        if (!meshMatrix.isIdentity()) {
-            meshPos = meshPos.slice(0);
-            for (let p = 0; p < meshPos.length / 3; p++) {
-                Vector3.TransformCoordinatesFromFloatsToRef(meshPos[3 * p], meshPos[3 * p + 1], meshPos[3 * p + 2], meshMatrix, place);
-                meshPos[3 * p] = place.x;
-                meshPos[3 * p + 1] = place.y;
-                meshPos[3 * p + 2] = place.z;
-            }
-        }
-        let idxPoints = 0;
-        let id0 = 0;
-        let id1 = 0;
-        let id2 = 0;
-        let v0X = 0;
-        let v0Y = 0;
-        let v0Z = 0;
-        let v1X = 0;
-        let v1Y = 0;
-        let v1Z = 0;
-        let v2X = 0;
-        let v2Y = 0;
-        let v2Z = 0;
-        const vertex0 = Vector3.Zero();
-        const vertex1 = Vector3.Zero();
-        const vertex2 = Vector3.Zero();
-        const vec0 = Vector3.Zero();
-        const vec1 = Vector3.Zero();
-        let uv0X = 0;
-        let uv0Y = 0;
-        let uv1X = 0;
-        let uv1Y = 0;
-        let uv2X = 0;
-        let uv2Y = 0;
-        const uv0 = Vector2.Zero();
-        const uv1 = Vector2.Zero();
-        const uv2 = Vector2.Zero();
-        const uvec0 = Vector2.Zero();
-        const uvec1 = Vector2.Zero();
-        let col0X = 0;
-        let col0Y = 0;
-        let col0Z = 0;
-        let col0A = 0;
-        let col1X = 0;
-        let col1Y = 0;
-        let col1Z = 0;
-        let col1A = 0;
-        let col2X = 0;
-        let col2Y = 0;
-        let col2Z = 0;
-        let col2A = 0;
-        const col0 = Vector4.Zero();
-        const col1 = Vector4.Zero();
-        const col2 = Vector4.Zero();
-        const colvec0 = Vector4.Zero();
-        const colvec1 = Vector4.Zero();
-        let lamda = 0;
-        let mu = 0;
-        range = range ? range : 0;
-        let facetPoint;
-        let uvPoint;
-        let colPoint = new Vector4(0, 0, 0, 0);
-        let norm = Vector3.Zero();
-        let tang = Vector3.Zero();
-        let biNorm = Vector3.Zero();
-        let angle = 0;
-        let facetPlaneVec = Vector3.Zero();
-        let gap = 0;
-        let distance = 0;
-        const ray = new Ray(Vector3.Zero(), new Vector3(1, 0, 0));
-        let pickInfo;
-        let direction = Vector3.Zero();
-        for (let index = 0; index < meshInd.length / 3; index++) {
-            id0 = meshInd[3 * index];
-            id1 = meshInd[3 * index + 1];
-            id2 = meshInd[3 * index + 2];
-            v0X = meshPos[3 * id0];
-            v0Y = meshPos[3 * id0 + 1];
-            v0Z = meshPos[3 * id0 + 2];
-            v1X = meshPos[3 * id1];
-            v1Y = meshPos[3 * id1 + 1];
-            v1Z = meshPos[3 * id1 + 2];
-            v2X = meshPos[3 * id2];
-            v2Y = meshPos[3 * id2 + 1];
-            v2Z = meshPos[3 * id2 + 2];
-            vertex0.set(v0X, v0Y, v0Z);
-            vertex1.set(v1X, v1Y, v1Z);
-            vertex2.set(v2X, v2Y, v2Z);
-            vertex1.subtractToRef(vertex0, vec0);
-            vertex2.subtractToRef(vertex1, vec1);
-            if (meshUV) {
-                uv0X = meshUV[2 * id0];
-                uv0Y = meshUV[2 * id0 + 1];
-                uv1X = meshUV[2 * id1];
-                uv1Y = meshUV[2 * id1 + 1];
-                uv2X = meshUV[2 * id2];
-                uv2Y = meshUV[2 * id2 + 1];
-                uv0.set(uv0X, uv0Y);
-                uv1.set(uv1X, uv1Y);
-                uv2.set(uv2X, uv2Y);
-                uv1.subtractToRef(uv0, uvec0);
-                uv2.subtractToRef(uv1, uvec1);
-            }
-            if (meshCol && colorFromTexture) {
-                col0X = meshCol[4 * id0];
-                col0Y = meshCol[4 * id0 + 1];
-                col0Z = meshCol[4 * id0 + 2];
-                col0A = meshCol[4 * id0 + 3];
-                col1X = meshCol[4 * id1];
-                col1Y = meshCol[4 * id1 + 1];
-                col1Z = meshCol[4 * id1 + 2];
-                col1A = meshCol[4 * id1 + 3];
-                col2X = meshCol[4 * id2];
-                col2Y = meshCol[4 * id2 + 1];
-                col2Z = meshCol[4 * id2 + 2];
-                col2A = meshCol[4 * id2 + 3];
-                col0.set(col0X, col0Y, col0Z, col0A);
-                col1.set(col1X, col1Y, col1Z, col1A);
-                col2.set(col2X, col2Y, col2Z, col2A);
-                col1.subtractToRef(col0, colvec0);
-                col2.subtractToRef(col1, colvec1);
-            }
-            let width;
-            let height;
-            let deltaS;
-            let deltaV;
-            let h;
-            let s;
-            let v;
-            let hsvCol;
-            const statedColor = new Color3(0, 0, 0);
-            const colPoint3 = new Color3(0, 0, 0);
-            let pointColors;
-            let particle;
-            for (let i = 0; i < pointsGroup._groupDensity[index]; i++) {
-                idxPoints = this.particles.length;
-                this._addParticle(idxPoints, pointsGroup, this._groupCounter, index + i);
-                particle = this.particles[idxPoints];
-                //form a point inside the facet v0, v1, v2;
-                lamda = Math.sqrt(RandomRange(0, 1));
-                mu = RandomRange(0, 1);
-                facetPoint = vertex0.add(vec0.scale(lamda)).add(vec1.scale(lamda * mu));
-                if (isVolume) {
-                    norm = mesh.getFacetNormal(index).normalize().scale(-1);
-                    tang = vec0.clone().normalize();
-                    biNorm = Vector3.Cross(norm, tang);
-                    angle = RandomRange(0, 2 * Math.PI);
-                    facetPlaneVec = tang.scale(Math.cos(angle)).add(biNorm.scale(Math.sin(angle)));
-                    angle = RandomRange(0.1, Math.PI / 2);
-                    direction = facetPlaneVec.scale(Math.cos(angle)).add(norm.scale(Math.sin(angle)));
-                    ray.origin = facetPoint.add(direction.scale(0.00001));
-                    ray.direction = direction;
-                    ray.length = diameter;
-                    pickInfo = ray.intersectsMesh(mesh);
-                    if (pickInfo.hit) {
-                        distance = pickInfo.pickedPoint.subtract(facetPoint).length();
-                        gap = RandomRange(0, 1) * distance;
-                        facetPoint.addInPlace(direction.scale(gap));
-                    }
-                }
-                particle.position = facetPoint.clone();
-                this._positions.push(particle.position.x, particle.position.y, particle.position.z);
-                if (colorFromTexture !== undefined) {
-                    if (meshUV) {
-                        uvPoint = uv0.add(uvec0.scale(lamda)).add(uvec1.scale(lamda * mu));
-                        if (colorFromTexture) {
-                            //Set particle color to texture color
-                            if (hasTexture && pointsGroup._groupImageData !== null) {
-                                width = pointsGroup._groupImgWidth;
-                                height = pointsGroup._groupImgHeight;
-                                pointColors = this._getColorIndicesForCoord(pointsGroup, Math.round(uvPoint.x * width), Math.round(uvPoint.y * height), width);
-                                particle.color = pointColors;
-                                this._colors.push(pointColors.r, pointColors.g, pointColors.b, pointColors.a);
-                            }
-                            else {
-                                if (meshCol) {
-                                    //failure in texture and colors available
-                                    colPoint = col0.add(colvec0.scale(lamda)).add(colvec1.scale(lamda * mu));
-                                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                                }
-                                else {
-                                    colPoint = col0.set(Math.random(), Math.random(), Math.random(), 1);
-                                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                                }
-                            }
-                        }
-                        else {
-                            //Set particle uv based on a mesh uv
-                            particle.uv = uvPoint.clone();
-                            this._uvs.push(particle.uv.x, particle.uv.y);
-                        }
-                    }
-                }
-                else {
-                    if (color) {
-                        statedColor.set(color.r, color.g, color.b);
-                        deltaS = RandomRange(-range, range);
-                        deltaV = RandomRange(-range, range);
-                        hsvCol = statedColor.toHSV();
-                        h = hsvCol.r;
-                        s = hsvCol.g + deltaS;
-                        v = hsvCol.b + deltaV;
-                        if (s < 0) {
-                            s = 0;
-                        }
-                        if (s > 1) {
-                            s = 1;
-                        }
-                        if (v < 0) {
-                            v = 0;
-                        }
-                        if (v > 1) {
-                            v = 1;
-                        }
-                        Color3.HSVtoRGBToRef(h, s, v, colPoint3);
-                        colPoint.set(colPoint3.r, colPoint3.g, colPoint3.b, 1);
-                    }
-                    else {
-                        colPoint = col0.set(Math.random(), Math.random(), Math.random(), 1);
-                    }
-                    particle.color = new Color4(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                    this._colors.push(colPoint.x, colPoint.y, colPoint.z, colPoint.w);
-                }
-            }
-        }
-    }
-    // stores mesh texture in dynamic texture for color pixel retrieval
-    // when pointColor type is color for surface points
-    _colorFromTexture(mesh, pointsGroup, isVolume) {
-        if (mesh.material === null) {
-            Logger.Warn(mesh.name + "has no material.");
-            pointsGroup._groupImageData = null;
-            this._setPointsColorOrUV(mesh, pointsGroup, isVolume, true, false);
-            return;
-        }
-        const mat = mesh.material;
-        const textureList = mat.getActiveTextures();
-        if (textureList.length === 0) {
-            Logger.Warn(mesh.name + "has no usable texture.");
-            pointsGroup._groupImageData = null;
-            this._setPointsColorOrUV(mesh, pointsGroup, isVolume, true, false);
-            return;
-        }
-        const clone = mesh.clone();
-        clone.setEnabled(false);
-        this._promises.push(new Promise((resolve) => {
-            BaseTexture.WhenAllReady(textureList, () => {
-                let n = pointsGroup._textureNb;
-                if (n < 0) {
-                    n = 0;
-                }
-                if (n > textureList.length - 1) {
-                    n = textureList.length - 1;
-                }
-                const finalize = () => {
-                    pointsGroup._groupImgWidth = textureList[n].getSize().width;
-                    pointsGroup._groupImgHeight = textureList[n].getSize().height;
-                    this._setPointsColorOrUV(clone, pointsGroup, isVolume, true, true, undefined, undefined, textureList[n].coordinatesIndex);
-                    clone.dispose();
-                    resolve();
-                };
-                pointsGroup._groupImageData = null;
-                const dataPromise = textureList[n].readPixels();
-                if (!dataPromise) {
-                    finalize();
-                }
-                else {
-                    dataPromise.then((data) => {
-                        pointsGroup._groupImageData = data;
-                        finalize();
-                    });
-                }
-            });
-        }));
-    }
-    // calculates the point density per facet of a mesh for surface points
-    _calculateDensity(nbPoints, positions, indices) {
-        let id0;
-        let id1;
-        let id2;
-        let v0X;
-        let v0Y;
-        let v0Z;
-        let v1X;
-        let v1Y;
-        let v1Z;
-        let v2X;
-        let v2Y;
-        let v2Z;
-        const vertex0 = Vector3.Zero();
-        const vertex1 = Vector3.Zero();
-        const vertex2 = Vector3.Zero();
-        const vec0 = Vector3.Zero();
-        const vec1 = Vector3.Zero();
-        const normal = Vector3.Zero();
-        let area;
-        const cumulativeAreas = [];
-        let surfaceArea = 0;
-        const nbFacets = indices.length / 3;
-        //surface area
-        for (let index = 0; index < nbFacets; index++) {
-            id0 = indices[3 * index];
-            id1 = indices[3 * index + 1];
-            id2 = indices[3 * index + 2];
-            v0X = positions[3 * id0];
-            v0Y = positions[3 * id0 + 1];
-            v0Z = positions[3 * id0 + 2];
-            v1X = positions[3 * id1];
-            v1Y = positions[3 * id1 + 1];
-            v1Z = positions[3 * id1 + 2];
-            v2X = positions[3 * id2];
-            v2Y = positions[3 * id2 + 1];
-            v2Z = positions[3 * id2 + 2];
-            vertex0.set(v0X, v0Y, v0Z);
-            vertex1.set(v1X, v1Y, v1Z);
-            vertex2.set(v2X, v2Y, v2Z);
-            vertex1.subtractToRef(vertex0, vec0);
-            vertex2.subtractToRef(vertex1, vec1);
-            Vector3.CrossToRef(vec0, vec1, normal);
-            area = 0.5 * normal.length();
-            surfaceArea += area;
-            cumulativeAreas[index] = surfaceArea;
-        }
-        const density = new Array(nbFacets);
-        let remainingPoints = nbPoints;
-        for (let index = nbFacets - 1; index > 0; index--) {
-            const cumulativeArea = cumulativeAreas[index];
-            if (cumulativeArea === 0) {
-                // avoiding division by 0 upon degenerate triangles
-                density[index] = 0;
-            }
-            else {
-                const area = cumulativeArea - cumulativeAreas[index - 1];
-                const facetPointsWithFraction = (area / cumulativeArea) * remainingPoints;
-                const floored = Math.floor(facetPointsWithFraction);
-                const fraction = facetPointsWithFraction - floored;
-                const extraPoint = Number(Math.random() < fraction);
-                const facetPoints = floored + extraPoint;
-                density[index] = facetPoints;
-                remainingPoints -= facetPoints;
-            }
-        }
-        density[0] = remainingPoints;
-        return density;
-    }
-    /**
-     * Adds points to the PCS in random positions within a unit sphere
-     * @param nb (positive integer) the number of particles to be created from this model
-     * @param pointFunction is an optional javascript function to be called for each particle on PCS creation
-     * @returns the number of groups in the system
-     */
-    addPoints(nb, pointFunction = this._randomUnitVector) {
-        const pointsGroup = new PointsGroup(this._groupCounter, pointFunction);
-        let cp;
-        // particles
-        let idx = this.nbParticles;
-        for (let i = 0; i < nb; i++) {
-            cp = this._addParticle(idx, pointsGroup, this._groupCounter, i);
-            if (pointsGroup && pointsGroup._positionFunction) {
-                pointsGroup._positionFunction(cp, idx, i);
-            }
-            this._positions.push(cp.position.x, cp.position.y, cp.position.z);
-            if (cp.color) {
-                this._colors.push(cp.color.r, cp.color.g, cp.color.b, cp.color.a);
-            }
-            if (cp.uv) {
-                this._uvs.push(cp.uv.x, cp.uv.y);
-            }
-            idx++;
-        }
-        this.nbParticles += nb;
-        this._groupCounter++;
-        return this._groupCounter;
-    }
-    /**
-     * Adds points to the PCS from the surface of the model shape
-     * @param mesh is any Mesh object that will be used as a surface model for the points
-     * @param nb (positive integer) the number of particles to be created from this model
-     * @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
-     * @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
-     * @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
-     * @returns the number of groups in the system
-     */
-    addSurfacePoints(mesh, nb, colorWith, color, range) {
-        let colored = colorWith ? colorWith : 0 /* PointColor.Random */;
-        if (isNaN(colored) || colored < 0 || colored > 3) {
-            colored = 0 /* PointColor.Random */;
-        }
-        const meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
-        const meshInd = mesh.getIndices();
-        this._groups.push(this._groupCounter);
-        const pointsGroup = new PointsGroup(this._groupCounter, null);
-        pointsGroup._groupDensity = this._calculateDensity(nb, meshPos, meshInd);
-        if (colored === 2 /* PointColor.Color */) {
-            pointsGroup._textureNb = color ? color : 0;
-        }
-        else {
-            color = color ? color : new Color4(1, 1, 1, 1);
-        }
-        switch (colored) {
-            case 2 /* PointColor.Color */:
-                this._colorFromTexture(mesh, pointsGroup, false);
-                break;
-            case 1 /* PointColor.UV */:
-                this._setPointsColorOrUV(mesh, pointsGroup, false, false, false);
-                break;
-            case 0 /* PointColor.Random */:
-                this._setPointsColorOrUV(mesh, pointsGroup, false);
-                break;
-            case 3 /* PointColor.Stated */:
-                this._setPointsColorOrUV(mesh, pointsGroup, false, undefined, undefined, color, range);
-                break;
-        }
-        this.nbParticles += nb;
-        this._groupCounter++;
-        return this._groupCounter - 1;
-    }
-    /**
-     * Adds points to the PCS inside the model shape
-     * @param mesh is any Mesh object that will be used as a surface model for the points
-     * @param nb (positive integer) the number of particles to be created from this model
-     * @param colorWith determines whether a point is colored using color (default), uv, random, stated or none (invisible)
-     * @param color (color4) to be used when colorWith is stated or color (number) when used to specify texture position
-     * @param range (number from 0 to 1) to determine the variation in shape and tone for a stated color
-     * @returns the number of groups in the system
-     */
-    addVolumePoints(mesh, nb, colorWith, color, range) {
-        let colored = colorWith ? colorWith : 0 /* PointColor.Random */;
-        if (isNaN(colored) || colored < 0 || colored > 3) {
-            colored = 0 /* PointColor.Random */;
-        }
-        const meshPos = mesh.getVerticesData(VertexBuffer.PositionKind);
-        const meshInd = mesh.getIndices();
-        this._groups.push(this._groupCounter);
-        const pointsGroup = new PointsGroup(this._groupCounter, null);
-        pointsGroup._groupDensity = this._calculateDensity(nb, meshPos, meshInd);
-        if (colored === 2 /* PointColor.Color */) {
-            pointsGroup._textureNb = color ? color : 0;
-        }
-        else {
-            color = color ? color : new Color4(1, 1, 1, 1);
-        }
-        switch (colored) {
-            case 2 /* PointColor.Color */:
-                this._colorFromTexture(mesh, pointsGroup, true);
-                break;
-            case 1 /* PointColor.UV */:
-                this._setPointsColorOrUV(mesh, pointsGroup, true, false, false);
-                break;
-            case 0 /* PointColor.Random */:
-                this._setPointsColorOrUV(mesh, pointsGroup, true);
-                break;
-            case 3 /* PointColor.Stated */:
-                this._setPointsColorOrUV(mesh, pointsGroup, true, undefined, undefined, color, range);
-                break;
-        }
-        this.nbParticles += nb;
-        this._groupCounter++;
-        return this._groupCounter - 1;
-    }
-    /**
-     *  Sets all the particles : this method actually really updates the mesh according to the particle positions, rotations, colors, textures, etc.
-     *  This method calls `updateParticle()` for each particle of the SPS.
-     *  For an animated SPS, it is usually called within the render loop.
-     * @param start The particle index in the particle array where to start to compute the particle property values _(default 0)_
-     * @param end The particle index in the particle array where to stop to compute the particle property values _(default nbParticle - 1)_
-     * @param update If the mesh must be finally updated on this call after all the particle computations _(default true)_
-     * @returns the PCS.
-     */
-    setParticles(start = 0, end = this.nbParticles - 1, update = true) {
-        if (!this._updatable || !this._isReady) {
-            return this;
-        }
-        // custom beforeUpdate
-        this.beforeUpdateParticles(start, end, update);
-        const rotMatrix = TmpVectors.Matrix[0];
-        const mesh = this.mesh;
-        const colors32 = this._colors32;
-        const positions32 = this._positions32;
-        const uvs32 = this._uvs32;
-        const tempVectors = TmpVectors.Vector3;
-        const camAxisX = tempVectors[5].copyFromFloats(1.0, 0.0, 0.0);
-        const camAxisY = tempVectors[6].copyFromFloats(0.0, 1.0, 0.0);
-        const camAxisZ = tempVectors[7].copyFromFloats(0.0, 0.0, 1.0);
-        const minimum = tempVectors[8].setAll(Number.MAX_VALUE);
-        const maximum = tempVectors[9].setAll(-Number.MAX_VALUE);
-        Matrix.IdentityToRef(rotMatrix);
-        let idx = 0; // current index of the particle
-        if (this.mesh?.isFacetDataEnabled) {
-            this._computeBoundingBox = true;
-        }
-        end = end >= this.nbParticles ? this.nbParticles - 1 : end;
-        if (this._computeBoundingBox) {
-            if (start != 0 || end != this.nbParticles - 1) {
-                // only some particles are updated, then use the current existing BBox basis. Note : it can only increase.
-                const boundingInfo = this.mesh?.getBoundingInfo();
-                if (boundingInfo) {
-                    minimum.copyFrom(boundingInfo.minimum);
-                    maximum.copyFrom(boundingInfo.maximum);
-                }
-            }
-        }
-        idx = 0; // particle index
-        let pindex = 0; //index in positions array
-        let cindex = 0; //index in color array
-        let uindex = 0; //index in uv array
-        // particle loop
-        for (let p = start; p <= end; p++) {
-            const particle = this.particles[p];
-            idx = particle.idx;
-            pindex = 3 * idx;
-            cindex = 4 * idx;
-            uindex = 2 * idx;
-            // call to custom user function to update the particle properties
-            this.updateParticle(particle);
-            const particleRotationMatrix = particle._rotationMatrix;
-            const particlePosition = particle.position;
-            const particleGlobalPosition = particle._globalPosition;
-            if (this._computeParticleRotation) {
-                particle.getRotationMatrix(rotMatrix);
-            }
-            const particleHasParent = particle.parentId !== null;
-            if (particleHasParent) {
-                const parent = this.particles[particle.parentId];
-                const parentRotationMatrix = parent._rotationMatrix;
-                const parentGlobalPosition = parent._globalPosition;
-                const rotatedY = particlePosition.x * parentRotationMatrix[1] + particlePosition.y * parentRotationMatrix[4] + particlePosition.z * parentRotationMatrix[7];
-                const rotatedX = particlePosition.x * parentRotationMatrix[0] + particlePosition.y * parentRotationMatrix[3] + particlePosition.z * parentRotationMatrix[6];
-                const rotatedZ = particlePosition.x * parentRotationMatrix[2] + particlePosition.y * parentRotationMatrix[5] + particlePosition.z * parentRotationMatrix[8];
-                particleGlobalPosition.x = parentGlobalPosition.x + rotatedX;
-                particleGlobalPosition.y = parentGlobalPosition.y + rotatedY;
-                particleGlobalPosition.z = parentGlobalPosition.z + rotatedZ;
-                if (this._computeParticleRotation) {
-                    const rotMatrixValues = rotMatrix.m;
-                    particleRotationMatrix[0] =
-                        rotMatrixValues[0] * parentRotationMatrix[0] + rotMatrixValues[1] * parentRotationMatrix[3] + rotMatrixValues[2] * parentRotationMatrix[6];
-                    particleRotationMatrix[1] =
-                        rotMatrixValues[0] * parentRotationMatrix[1] + rotMatrixValues[1] * parentRotationMatrix[4] + rotMatrixValues[2] * parentRotationMatrix[7];
-                    particleRotationMatrix[2] =
-                        rotMatrixValues[0] * parentRotationMatrix[2] + rotMatrixValues[1] * parentRotationMatrix[5] + rotMatrixValues[2] * parentRotationMatrix[8];
-                    particleRotationMatrix[3] =
-                        rotMatrixValues[4] * parentRotationMatrix[0] + rotMatrixValues[5] * parentRotationMatrix[3] + rotMatrixValues[6] * parentRotationMatrix[6];
-                    particleRotationMatrix[4] =
-                        rotMatrixValues[4] * parentRotationMatrix[1] + rotMatrixValues[5] * parentRotationMatrix[4] + rotMatrixValues[6] * parentRotationMatrix[7];
-                    particleRotationMatrix[5] =
-                        rotMatrixValues[4] * parentRotationMatrix[2] + rotMatrixValues[5] * parentRotationMatrix[5] + rotMatrixValues[6] * parentRotationMatrix[8];
-                    particleRotationMatrix[6] =
-                        rotMatrixValues[8] * parentRotationMatrix[0] + rotMatrixValues[9] * parentRotationMatrix[3] + rotMatrixValues[10] * parentRotationMatrix[6];
-                    particleRotationMatrix[7] =
-                        rotMatrixValues[8] * parentRotationMatrix[1] + rotMatrixValues[9] * parentRotationMatrix[4] + rotMatrixValues[10] * parentRotationMatrix[7];
-                    particleRotationMatrix[8] =
-                        rotMatrixValues[8] * parentRotationMatrix[2] + rotMatrixValues[9] * parentRotationMatrix[5] + rotMatrixValues[10] * parentRotationMatrix[8];
-                }
-            }
-            else {
-                particleGlobalPosition.x = 0;
-                particleGlobalPosition.y = 0;
-                particleGlobalPosition.z = 0;
-                if (this._computeParticleRotation) {
-                    const rotMatrixValues = rotMatrix.m;
-                    particleRotationMatrix[0] = rotMatrixValues[0];
-                    particleRotationMatrix[1] = rotMatrixValues[1];
-                    particleRotationMatrix[2] = rotMatrixValues[2];
-                    particleRotationMatrix[3] = rotMatrixValues[4];
-                    particleRotationMatrix[4] = rotMatrixValues[5];
-                    particleRotationMatrix[5] = rotMatrixValues[6];
-                    particleRotationMatrix[6] = rotMatrixValues[8];
-                    particleRotationMatrix[7] = rotMatrixValues[9];
-                    particleRotationMatrix[8] = rotMatrixValues[10];
-                }
-            }
-            const pivotBackTranslation = tempVectors[11];
-            if (particle.translateFromPivot) {
-                pivotBackTranslation.setAll(0.0);
-            }
-            else {
-                pivotBackTranslation.copyFrom(particle.pivot);
-            }
-            // positions
-            const tmpVertex = tempVectors[0];
-            tmpVertex.copyFrom(particle.position);
-            const vertexX = tmpVertex.x - particle.pivot.x;
-            const vertexY = tmpVertex.y - particle.pivot.y;
-            const vertexZ = tmpVertex.z - particle.pivot.z;
-            let rotatedX = vertexX * particleRotationMatrix[0] + vertexY * particleRotationMatrix[3] + vertexZ * particleRotationMatrix[6];
-            let rotatedY = vertexX * particleRotationMatrix[1] + vertexY * particleRotationMatrix[4] + vertexZ * particleRotationMatrix[7];
-            let rotatedZ = vertexX * particleRotationMatrix[2] + vertexY * particleRotationMatrix[5] + vertexZ * particleRotationMatrix[8];
-            rotatedX += pivotBackTranslation.x;
-            rotatedY += pivotBackTranslation.y;
-            rotatedZ += pivotBackTranslation.z;
-            const px = (positions32[pindex] = particleGlobalPosition.x + camAxisX.x * rotatedX + camAxisY.x * rotatedY + camAxisZ.x * rotatedZ);
-            const py = (positions32[pindex + 1] = particleGlobalPosition.y + camAxisX.y * rotatedX + camAxisY.y * rotatedY + camAxisZ.y * rotatedZ);
-            const pz = (positions32[pindex + 2] = particleGlobalPosition.z + camAxisX.z * rotatedX + camAxisY.z * rotatedY + camAxisZ.z * rotatedZ);
-            if (this._computeBoundingBox) {
-                minimum.minimizeInPlaceFromFloats(px, py, pz);
-                maximum.maximizeInPlaceFromFloats(px, py, pz);
-            }
-            if (this._computeParticleColor && particle.color) {
-                const color = particle.color;
-                const colors32 = this._colors32;
-                colors32[cindex] = color.r;
-                colors32[cindex + 1] = color.g;
-                colors32[cindex + 2] = color.b;
-                colors32[cindex + 3] = color.a;
-            }
-            if (this._computeParticleTexture && particle.uv) {
-                const uv = particle.uv;
-                const uvs32 = this._uvs32;
-                uvs32[uindex] = uv.x;
-                uvs32[uindex + 1] = uv.y;
-            }
-        }
-        // if the VBO must be updated
-        if (mesh) {
-            if (update) {
-                if (this._computeParticleColor) {
-                    mesh.updateVerticesData(VertexBuffer.ColorKind, colors32, false, false);
-                }
-                if (this._computeParticleTexture) {
-                    mesh.updateVerticesData(VertexBuffer.UVKind, uvs32, false, false);
-                }
-                mesh.updateVerticesData(VertexBuffer.PositionKind, positions32, false, false);
-            }
-            if (this._computeBoundingBox) {
-                if (mesh.hasBoundingInfo) {
-                    mesh.getBoundingInfo().reConstruct(minimum, maximum, mesh._worldMatrix);
-                }
-                else {
-                    mesh.buildBoundingInfo(minimum, maximum, mesh._worldMatrix);
-                }
-            }
-        }
-        this.afterUpdateParticles(start, end, update);
-        return this;
-    }
-    /**
-     * Disposes the PCS.
-     */
-    dispose() {
-        this.mesh?.dispose();
-        this.vars = null;
-        // drop references to internal big arrays for the GC
-        this._positions = null;
-        this._indices = null;
-        this._normals = null;
-        this._uvs = null;
-        this._colors = null;
-        this._indices32 = null;
-        this._positions32 = null;
-        this._uvs32 = null;
-        this._colors32 = null;
-    }
-    /**
-     * Visibility helper : Recomputes the visible size according to the mesh bounding box
-     * doc :
-     * @returns the PCS.
-     */
-    refreshVisibleSize() {
-        if (!this._isVisibilityBoxLocked) {
-            this.mesh?.refreshBoundingInfo();
-        }
-        return this;
-    }
-    /**
-     * Visibility helper : Sets the size of a visibility box, this sets the underlying mesh bounding box.
-     * @param size the size (float) of the visibility box
-     * note : this doesn't lock the PCS mesh bounding box.
-     * doc :
-     */
-    setVisibilityBox(size) {
-        if (!this.mesh) {
-            return;
-        }
-        const vis = size / 2;
-        this.mesh.buildBoundingInfo(new Vector3(-vis, -vis, -vis), new Vector3(vis, vis, vis));
-    }
-    /**
-     * Gets whether the PCS is always visible or not
-     * doc :
-     */
-    get isAlwaysVisible() {
-        return this._alwaysVisible;
-    }
-    /**
-     * Sets the PCS as always visible or not
-     * doc :
-     */
-    set isAlwaysVisible(val) {
-        if (!this.mesh) {
-            return;
-        }
-        this._alwaysVisible = val;
-        this.mesh.alwaysSelectAsActiveMesh = val;
-    }
-    /**
-     * Tells to `setParticles()` to compute the particle rotations or not
-     * Default value : false. The PCS is faster when it's set to false
-     * Note : particle rotations are only applied to parent particles
-     * Note : the particle rotations aren't stored values, so setting `computeParticleRotation` to false will prevents the particle to rotate
-     */
-    set computeParticleRotation(val) {
-        this._computeParticleRotation = val;
-    }
-    /**
-     * Tells to `setParticles()` to compute the particle colors or not.
-     * Default value : true. The PCS is faster when it's set to false.
-     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
-     */
-    set computeParticleColor(val) {
-        this._computeParticleColor = val;
-    }
-    set computeParticleTexture(val) {
-        this._computeParticleTexture = val;
-    }
-    /**
-     * Gets if `setParticles()` computes the particle colors or not.
-     * Default value : false. The PCS is faster when it's set to false.
-     * Note : the particle colors are stored values, so setting `computeParticleColor` to false will keep yet the last colors set.
-     */
-    get computeParticleColor() {
-        return this._computeParticleColor;
-    }
-    /**
-     * Gets if `setParticles()` computes the particle textures or not.
-     * Default value : false. The PCS is faster when it's set to false.
-     * Note : the particle textures are stored values, so setting `computeParticleTexture` to false will keep yet the last colors set.
-     */
-    get computeParticleTexture() {
-        return this._computeParticleTexture;
-    }
-    /**
-     * Tells to `setParticles()` to compute or not the mesh bounding box when computing the particle positions.
-     */
-    set computeBoundingBox(val) {
-        this._computeBoundingBox = val;
-    }
-    /**
-     * Gets if `setParticles()` computes or not the mesh bounding box when computing the particle positions.
-     */
-    get computeBoundingBox() {
-        return this._computeBoundingBox;
-    }
-    // =======================================================================
-    // Particle behavior logic
-    // these following methods may be overwritten by users to fit their needs
-    /**
-     * This function does nothing. It may be overwritten to set all the particle first values.
-     * The PCS doesn't call this function, you may have to call it by your own.
-     * doc :
-     */
-    initParticles() { }
-    /**
-     * This function does nothing. It may be overwritten to recycle a particle
-     * The PCS doesn't call this function, you can to call it
-     * doc :
-     * @param particle The particle to recycle
-     * @returns the recycled particle
-     */
-    recycleParticle(particle) {
-        return particle;
-    }
-    /**
-     * Updates a particle : this function should  be overwritten by the user.
-     * It is called on each particle by `setParticles()`. This is the place to code each particle behavior.
-     * doc :
-     * @example : just set a particle position or velocity and recycle conditions
-     * @param particle The particle to update
-     * @returns the updated particle
-     */
-    updateParticle(particle) {
-        return particle;
-    }
-    /**
-     * This will be called before any other treatment by `setParticles()` and will be passed three parameters.
-     * This does nothing and may be overwritten by the user.
-     * @param start the particle index in the particle array where to start to iterate, same than the value passed to setParticle()
-     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
-     * @param update the boolean update value actually passed to setParticles()
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    beforeUpdateParticles(start, stop, update) { }
-    /**
-     * This will be called  by `setParticles()` after all the other treatments and just before the actual mesh update.
-     * This will be passed three parameters.
-     * This does nothing and may be overwritten by the user.
-     * @param start the particle index in the particle array where to start to iterate, same than the value passed to setParticle()
-     * @param stop the particle index in the particle array where to stop to iterate, same than the value passed to setParticle()
-     * @param update the boolean update value actually passed to setParticles()
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    afterUpdateParticles(start, stop, update) { }
-}
-
-/**
- * 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["Reject"] = 3] = "Reject";
-})(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;
-    }
-    _parseSPZ(data, scene) {
-        const ubuf = new Uint8Array(data);
-        const ubufu32 = new Uint32Array(data);
-        // debug infos
-        //Logger.Log(`SPZ version ${ubufu32[1]}`);
-        //Logger.Log(`num points ${ubufu32[2]}`);
-        const splatCount = ubufu32[2];
-        const shDegree = ubuf[12];
-        const fractionalBits = ubuf[13];
-        //const flags = ubuf[14];
-        const reserved = ubuf[15];
-        // check magic and version
-        if (reserved || ubufu32[0] != 0x5053474e || ubufu32[1] != 2) {
-            // reserved must be 0
-            return new Promise((resolve) => {
-                resolve({ mode: 3 /* Mode.Reject */, data: buffer, hasVertexColors: false });
-            });
-        }
-        const rowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // 32
-        const buffer = new ArrayBuffer(rowOutputLength * splatCount);
-        const positionScale = 1.0 / (1 << fractionalBits);
-        const int32View = new Int32Array(1);
-        const uint8View = new Uint8Array(int32View.buffer);
-        const read24bComponent = function (u8, offset) {
-            uint8View[0] = u8[offset + 0];
-            uint8View[1] = u8[offset + 1];
-            uint8View[2] = u8[offset + 2];
-            uint8View[3] = u8[offset + 2] & 0x80 ? 0xff : 0x00;
-            return int32View[0] * positionScale;
-        };
-        let byteOffset = 16;
-        const position = new Float32Array(buffer);
-        const scale = new Float32Array(buffer);
-        const rgba = new Uint8ClampedArray(buffer);
-        const rot = new Uint8ClampedArray(buffer);
-        // positions
-        for (let i = 0; i < splatCount; i++) {
-            position[i * 8 + 0] = read24bComponent(ubuf, byteOffset + 0);
-            position[i * 8 + 1] = -read24bComponent(ubuf, byteOffset + 3);
-            position[i * 8 + 2] = read24bComponent(ubuf, byteOffset + 6);
-            byteOffset += 9;
-        }
-        // colors
-        for (let i = 0; i < splatCount; i++) {
-            rgba[i * 32 + 24 + 0] = ubuf[byteOffset + splatCount + i * 3 + 0];
-            rgba[i * 32 + 24 + 1] = ubuf[byteOffset + splatCount + i * 3 + 1];
-            rgba[i * 32 + 24 + 2] = ubuf[byteOffset + splatCount + i * 3 + 2];
-            rgba[i * 32 + 24 + 3] = ubuf[byteOffset + i];
-        }
-        byteOffset += splatCount * 4;
-        // scales
-        for (let i = 0; i < splatCount; i++) {
-            scale[i * 8 + 3 + 0] = Math.exp(ubuf[byteOffset + 0] / 16.0 - 10.0);
-            scale[i * 8 + 3 + 1] = Math.exp(ubuf[byteOffset + 1] / 16.0 - 10.0);
-            scale[i * 8 + 3 + 2] = Math.exp(ubuf[byteOffset + 2] / 16.0 - 10.0);
-            byteOffset += 3;
-        }
-        // rotations
-        for (let i = 0; i < splatCount; i++) {
-            const x = ubuf[byteOffset + 0];
-            const y = ubuf[byteOffset + 1];
-            const z = ubuf[byteOffset + 2];
-            const nx = x / 127.5 - 1;
-            const ny = y / 127.5 - 1;
-            const nz = z / 127.5 - 1;
-            rot[i * 32 + 28 + 1] = x;
-            rot[i * 32 + 28 + 2] = y;
-            rot[i * 32 + 28 + 3] = z;
-            rot[i * 32 + 28 + 0] = (1 - Math.sqrt(nx * nx + ny * ny + nz * nz)) * 127.5 + 127.5;
-            byteOffset += 3;
-        }
-        //SH
-        if (shDegree) {
-            // shVectorCount is : 3 for dim = 1, 8 for dim = 2 and 15 for dim = 3
-            // number of vec3 vector needed per splat
-            const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1; // minus 1 because sh0 is color
-            // number of component values : 3 per vector3 (45)
-            const shComponentCount = shVectorCount * 3;
-            const textureCount = Math.ceil(shComponentCount / 16); // 4 components can be stored per texture, 4 sh per component
-            let shIndexRead = byteOffset;
-            // sh is an array of uint8array that will be used to create sh textures
-            const sh = [];
-            const engine = scene.getEngine();
-            const width = engine.getCaps().maxTextureSize;
-            const height = Math.ceil(splatCount / width);
-            // create array for the number of textures needed.
-            for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
-                const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
-                sh.push(texture);
-            }
-            for (let i = 0; i < splatCount; i++) {
-                for (let shIndexWrite = 0; shIndexWrite < shComponentCount; shIndexWrite++) {
-                    const shValue = ubuf[shIndexRead++];
-                    const textureIndex = Math.floor(shIndexWrite / 16);
-                    const shArray = sh[textureIndex];
-                    const byteIndexInTexture = shIndexWrite % 16; // [0..15]
-                    const offsetPerSplat = i * 16; // 16 sh values per texture per splat.
-                    shArray[byteIndexInTexture + offsetPerSplat] = shValue;
-                }
-            }
-            return new Promise((resolve) => {
-                resolve({ mode: 0 /* Mode.Splat */, data: buffer, hasVertexColors: false, sh: sh });
-            });
-        }
-        return new Promise((resolve) => {
-            resolve({ mode: 0 /* Mode.Splat */, data: buffer, hasVertexColors: false });
-        });
-    }
-    _parse(meshesNames, scene, data, rootUrl) {
-        const babylonMeshesArray = []; //The mesh for babylon
-        const readableStream = new ReadableStream({
-            start(controller) {
-                controller.enqueue(new Uint8Array(data)); // Enqueue the ArrayBuffer as a Uint8Array
-                controller.close();
-            },
-        });
-        // Use GZip DecompressionStream
-        const decompressionStream = new DecompressionStream("gzip");
-        const decompressedStream = readableStream.pipeThrough(decompressionStream);
-        return new Promise((resolve) => {
-            new Response(decompressedStream)
-                .arrayBuffer()
-                .then((buffer) => {
-                this._parseSPZ(buffer, scene).then((parsedSPZ) => {
-                    const gaussianSplatting = new GaussianSplattingMesh("GaussianSplatting", null, scene, this._loadingOptions.keepInRam);
-                    gaussianSplatting._parentContainer = this._assetContainer;
-                    babylonMeshesArray.push(gaussianSplatting);
-                    gaussianSplatting.updateData(parsedSPZ.data, parsedSPZ.sh);
-                });
-                resolve(babylonMeshesArray);
-            })
-                .catch(() => {
-                // Catch any decompression errors
-                SPLATFileLoader._ConvertPLYToSplat(data).then(async (parsedPLY) => {
-                    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.updateData(parsedPLY.data);
-                            }
-                            break;
-                        case 1 /* Mode.PointCloud */:
-                            {
-                                const pointcloud = new PointsCloudSystem("PointCloud", 1, scene);
-                                if (SPLATFileLoader._BuildPointCloud(pointcloud, parsedPLY.data)) {
-                                    await pointcloud.buildMeshAsync().then((mesh) => {
-                                        babylonMeshesArray.push(mesh);
-                                    });
-                                }
-                                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");
-                    }
-                });
-                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 new Promise((resolve) => {
-                resolve({ 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]);
-        }
-        const chunkElement = /element chunk (\d+)\n/.exec(header);
-        let chunkCount = 0;
-        if (chunkElement) {
-            chunkCount = parseInt(chunkElement[1]);
-        }
-        let rowVertexOffset = 0;
-        let rowChunkOffset = 0;
-        const offsets = {
-            double: 8,
-            int: 4,
-            uint: 4,
-            float: 4,
-            short: 2,
-            ushort: 2,
-            uchar: 1,
-            list: 0,
-        };
-        let ElementMode;
-        (function (ElementMode) {
-            ElementMode[ElementMode["Vertex"] = 0] = "Vertex";
-            ElementMode[ElementMode["Chunk"] = 1] = "Chunk";
-        })(ElementMode || (ElementMode = {}));
-        let chunkMode = 1 /* ElementMode.Chunk */;
-        const vertexProperties = [];
-        const filtered = header.slice(0, headerEndIndex).split("\n");
-        for (const prop of filtered) {
-            if (prop.startsWith("property ")) {
-                const [, type, name] = prop.split(" ");
-                if (chunkMode == 1 /* ElementMode.Chunk */) {
-                    rowChunkOffset += offsets[type];
-                }
-                else if (chunkMode == 0 /* ElementMode.Vertex */) {
-                    vertexProperties.push({ name, type, offset: rowVertexOffset });
-                    rowVertexOffset += offsets[type];
-                }
-                if (!offsets[type]) {
-                    Logger.Warn(`Unsupported property type: ${type}.`);
-                }
-            }
-            else if (prop.startsWith("element ")) {
-                const [, type] = prop.split(" ");
-                if (type == "chunk") {
-                    chunkMode = 1 /* ElementMode.Chunk */;
-                }
-                else if (type == "vertex") {
-                    chunkMode = 0 /* ElementMode.Vertex */;
-                }
-            }
-        }
-        const rowVertexLength = rowVertexOffset;
-        const rowChunkLength = rowChunkOffset;
-        return GaussianSplattingMesh.ConvertPLYToSplatAsync(data).then((buffer) => {
-            const dataView = new DataView(data, headerEndIndex + headerEnd.length);
-            let offset = rowChunkLength * chunkCount + rowVertexLength * vertexCount;
-            // faces
-            const faces = [];
-            if (faceCount) {
-                for (let i = 0; i < faceCount; i++) {
-                    const faceVertexCount = dataView.getUint8(offset);
-                    if (faceVertexCount != 3) {
-                        continue; // only support triangles
-                    }
-                    offset += 1;
-                    for (let j = 0; j < faceVertexCount; j++) {
-                        const vertexIndex = dataView.getUint32(offset + (2 - j) * 4, true); // change face winding
-                        faces.push(vertexIndex);
-                    }
-                    offset += 12;
-                }
-            }
-            // early exit for chunked/quantized ply
-            if (chunkCount) {
-                return new Promise((resolve) => {
-                    resolve({ mode: 0 /* Mode.Splat */, data: buffer, faces: faces, hasVertexColors: false });
-                });
-            }
-            // count available properties. if all necessary are present then it's a splat. Otherwise, it's a point cloud
-            // if faces are found, then it's a standard mesh
-            let propertyCount = 0;
-            let propertyColorCount = 0;
-            const splatProperties = ["x", "y", "z", "scale_0", "scale_1", "scale_2", "opacity", "rot_0", "rot_1", "rot_2", "rot_3"];
-            const splatColorProperties = ["red", "green", "blue", "f_dc_0", "f_dc_1", "f_dc_2"];
-            for (let propertyIndex = 0; propertyIndex < vertexProperties.length; propertyIndex++) {
-                const property = vertexProperties[propertyIndex];
-                if (splatProperties.includes(property.name)) {
-                    propertyCount++;
-                }
-                if (splatColorProperties.includes(property.name)) {
-                    propertyColorCount++;
-                }
-            }
-            const hasMandatoryProperties = propertyCount == splatProperties.length && propertyColorCount == 3;
-            const currentMode = faceCount ? 2 /* Mode.Mesh */ : hasMandatoryProperties ? 0 /* Mode.Splat */ : 1 /* Mode.PointCloud */;
-            // parsed ready ready to be used as a splat
-            return new Promise((resolve) => {
-                resolve({ 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-CCCmIOu_.esm.js.map