@babylonjs/viewer 7.42.0 → 7.44.0

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

@@ -0,0 +1,3660 @@
+import { g as ShaderStore, K as RegisterClass, N as PushMaterial, Q as PrepareDefinesForMisc, W as PrepareDefinesForFrameBoundValues, X as PrepareDefinesForAttributes, Y as PrepareAttributesForInstances, Z as PrepareUniformsAndSamplersList, $ as addClipPlaneUniforms, a0 as Camera, a1 as bindClipPlane, a2 as BindFogParameters, a3 as BindLogDepth, a4 as SerializationHelper, a5 as MaterialDefines, V as VertexBuffer, a6 as functions, a7 as HighestCommonFactor, M as Mesh, a8 as Matrix, y as Vector3, H as VertexData, a9 as SubMesh, aa as TmpVectors, L as Logger, ab as EngineStore, ac as runCoroutineAsync, T as Tools, ad as ToHalfFloat, C as Constants, ae as runCoroutineSync, x as Vector2, af as createYieldingScheduler, k as Color4, ag as Quaternion, v as Color3, ah as Vector4, ai as RandomRange, aj as BaseTexture, ak as SPLATFileLoaderMetadata, J as registerSceneLoaderPlugin } from './index-D46Rc8Qa.esm.js';
+import './fogFragment-DwdRh83Z.esm.js';
+import './logDepthDeclaration-Co9yKHfe.esm.js';
+import './logDepthVertex-BBDSLJJg.esm.js';
+import './fogFragment-Ct0roave.esm.js';
+import './logDepthDeclaration-KzS73dPG.esm.js';
+import './meshUboDeclaration-D7vtpetW.esm.js';
+import './logDepthVertex-DKTOhgu8.esm.js';
+import { R as RawTexture } from './rawTexture-Dh4jdTlv.esm.js';
+import './thinInstanceMesh-tQGPk8rE.esm.js';
+import { A as AssetContainer } from './assetContainer-Cx2Wvxkg.esm.js';
+import { Ray } from './ray-QR2k6aJd.esm.js';
+import { S as StandardMaterial } from './standardMaterial-BRKRGk7c.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.0*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.0*xx-yy)*sh[9] +
+SH_C3[1]*xy*z*sh[10] +
+SH_C3[2]*y*(4.0*zz-xx-yy)*sh[11] +
+SH_C3[3]*z*(2.0*zz-3.0*xx-3.0*yy)*sh[12] +
+SH_C3[4]*x*(4.0*zz-xx-yy)*sh[13] +
+SH_C3[5]*z*(xx-yy)*sh[14] +
+SH_C3[6]*x*(xx-3.0*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);dir.y*=-1.; 
+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["MIN_COLOR_R"] = 34] = "MIN_COLOR_R";
+    PLYValue[PLYValue["MIN_COLOR_G"] = 35] = "MIN_COLOR_G";
+    PLYValue[PLYValue["MIN_COLOR_B"] = 36] = "MIN_COLOR_B";
+    PLYValue[PLYValue["MAX_COLOR_R"] = 37] = "MAX_COLOR_R";
+    PLYValue[PLYValue["MAX_COLOR_G"] = 38] = "MAX_COLOR_G";
+    PLYValue[PLYValue["MAX_COLOR_B"] = 39] = "MAX_COLOR_B";
+    PLYValue[PLYValue["SH_0"] = 40] = "SH_0";
+    PLYValue[PLYValue["SH_1"] = 41] = "SH_1";
+    PLYValue[PLYValue["SH_2"] = 42] = "SH_2";
+    PLYValue[PLYValue["SH_3"] = 43] = "SH_3";
+    PLYValue[PLYValue["SH_4"] = 44] = "SH_4";
+    PLYValue[PLYValue["SH_5"] = 45] = "SH_5";
+    PLYValue[PLYValue["SH_6"] = 46] = "SH_6";
+    PLYValue[PLYValue["SH_7"] = 47] = "SH_7";
+    PLYValue[PLYValue["SH_8"] = 48] = "SH_8";
+    PLYValue[PLYValue["SH_9"] = 49] = "SH_9";
+    PLYValue[PLYValue["SH_10"] = 50] = "SH_10";
+    PLYValue[PLYValue["SH_11"] = 51] = "SH_11";
+    PLYValue[PLYValue["SH_12"] = 52] = "SH_12";
+    PLYValue[PLYValue["SH_13"] = 53] = "SH_13";
+    PLYValue[PLYValue["SH_14"] = 54] = "SH_14";
+    PLYValue[PLYValue["SH_15"] = 55] = "SH_15";
+    PLYValue[PLYValue["SH_16"] = 56] = "SH_16";
+    PLYValue[PLYValue["SH_17"] = 57] = "SH_17";
+    PLYValue[PLYValue["SH_18"] = 58] = "SH_18";
+    PLYValue[PLYValue["SH_19"] = 59] = "SH_19";
+    PLYValue[PLYValue["SH_20"] = 60] = "SH_20";
+    PLYValue[PLYValue["SH_21"] = 61] = "SH_21";
+    PLYValue[PLYValue["SH_22"] = 62] = "SH_22";
+    PLYValue[PLYValue["SH_23"] = 63] = "SH_23";
+    PLYValue[PLYValue["SH_24"] = 64] = "SH_24";
+    PLYValue[PLYValue["SH_25"] = 65] = "SH_25";
+    PLYValue[PLYValue["SH_26"] = 66] = "SH_26";
+    PLYValue[PLYValue["SH_27"] = 67] = "SH_27";
+    PLYValue[PLYValue["SH_28"] = 68] = "SH_28";
+    PLYValue[PLYValue["SH_29"] = 69] = "SH_29";
+    PLYValue[PLYValue["SH_30"] = 70] = "SH_30";
+    PLYValue[PLYValue["SH_31"] = 71] = "SH_31";
+    PLYValue[PLYValue["SH_32"] = 72] = "SH_32";
+    PLYValue[PLYValue["SH_33"] = 73] = "SH_33";
+    PLYValue[PLYValue["SH_34"] = 74] = "SH_34";
+    PLYValue[PLYValue["SH_35"] = 75] = "SH_35";
+    PLYValue[PLYValue["SH_36"] = 76] = "SH_36";
+    PLYValue[PLYValue["SH_37"] = 77] = "SH_37";
+    PLYValue[PLYValue["SH_38"] = 78] = "SH_38";
+    PLYValue[PLYValue["SH_39"] = 79] = "SH_39";
+    PLYValue[PLYValue["SH_40"] = 80] = "SH_40";
+    PLYValue[PLYValue["SH_41"] = 81] = "SH_41";
+    PLYValue[PLYValue["SH_42"] = 82] = "SH_42";
+    PLYValue[PLYValue["SH_43"] = 83] = "SH_43";
+    PLYValue[PLYValue["SH_44"] = 84] = "SH_44";
+    PLYValue[PLYValue["UNDEFINED"] = 85] = "UNDEFINED";
+})(PLYValue || (PLYValue = {}));
+/**
+ * Class used to render a gaussian splatting mesh
+ */
+class GaussianSplattingMesh extends Mesh {
+    /**
+     * SH degree. 0 = no sh (default). 1 = 3 parameters. 2 = 8 parameters. 3 = 15 parameters.
+     */
+    get shDegree() {
+        return this._shDegree;
+    }
+    /**
+     * returns the splats data array buffer that contains in order : postions (3 floats), size (3 floats), color (4 bytes), orientation quaternion (4 bytes)
+     */
+    get splatsData() {
+        return this._splatsData;
+    }
+    /**
+     * 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;
+        this._splatsData = 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 */;
+            case "min_r":
+                return 34 /* PLYValue.MIN_COLOR_R */;
+            case "min_g":
+                return 35 /* PLYValue.MIN_COLOR_G */;
+            case "min_b":
+                return 36 /* PLYValue.MIN_COLOR_B */;
+            case "max_r":
+                return 37 /* PLYValue.MAX_COLOR_R */;
+            case "max_g":
+                return 38 /* PLYValue.MAX_COLOR_G */;
+            case "max_b":
+                return 39 /* PLYValue.MAX_COLOR_B */;
+            case "f_rest_0":
+                return 40 /* PLYValue.SH_0 */;
+            case "f_rest_1":
+                return 41 /* PLYValue.SH_1 */;
+            case "f_rest_2":
+                return 42 /* PLYValue.SH_2 */;
+            case "f_rest_3":
+                return 43 /* PLYValue.SH_3 */;
+            case "f_rest_4":
+                return 44 /* PLYValue.SH_4 */;
+            case "f_rest_5":
+                return 45 /* PLYValue.SH_5 */;
+            case "f_rest_6":
+                return 46 /* PLYValue.SH_6 */;
+            case "f_rest_7":
+                return 47 /* PLYValue.SH_7 */;
+            case "f_rest_8":
+                return 48 /* PLYValue.SH_8 */;
+            case "f_rest_9":
+                return 49 /* PLYValue.SH_9 */;
+            case "f_rest_10":
+                return 50 /* PLYValue.SH_10 */;
+            case "f_rest_11":
+                return 51 /* PLYValue.SH_11 */;
+            case "f_rest_12":
+                return 52 /* PLYValue.SH_12 */;
+            case "f_rest_13":
+                return 53 /* PLYValue.SH_13 */;
+            case "f_rest_14":
+                return 54 /* PLYValue.SH_14 */;
+            case "f_rest_15":
+                return 55 /* PLYValue.SH_15 */;
+            case "f_rest_16":
+                return 56 /* PLYValue.SH_16 */;
+            case "f_rest_17":
+                return 57 /* PLYValue.SH_17 */;
+            case "f_rest_18":
+                return 58 /* PLYValue.SH_18 */;
+            case "f_rest_19":
+                return 59 /* PLYValue.SH_19 */;
+            case "f_rest_20":
+                return 60 /* PLYValue.SH_20 */;
+            case "f_rest_21":
+                return 61 /* PLYValue.SH_21 */;
+            case "f_rest_22":
+                return 62 /* PLYValue.SH_22 */;
+            case "f_rest_23":
+                return 63 /* PLYValue.SH_23 */;
+            case "f_rest_24":
+                return 64 /* PLYValue.SH_24 */;
+            case "f_rest_25":
+                return 65 /* PLYValue.SH_25 */;
+            case "f_rest_26":
+                return 66 /* PLYValue.SH_26 */;
+            case "f_rest_27":
+                return 67 /* PLYValue.SH_27 */;
+            case "f_rest_28":
+                return 68 /* PLYValue.SH_28 */;
+            case "f_rest_29":
+                return 69 /* PLYValue.SH_29 */;
+            case "f_rest_30":
+                return 70 /* PLYValue.SH_30 */;
+            case "f_rest_31":
+                return 71 /* PLYValue.SH_31 */;
+            case "f_rest_32":
+                return 72 /* PLYValue.SH_32 */;
+            case "f_rest_33":
+                return 73 /* PLYValue.SH_33 */;
+            case "f_rest_34":
+                return 74 /* PLYValue.SH_34 */;
+            case "f_rest_35":
+                return 75 /* PLYValue.SH_35 */;
+            case "f_rest_36":
+                return 76 /* PLYValue.SH_36 */;
+            case "f_rest_37":
+                return 77 /* PLYValue.SH_37 */;
+            case "f_rest_38":
+                return 78 /* PLYValue.SH_38 */;
+            case "f_rest_39":
+                return 79 /* PLYValue.SH_39 */;
+            case "f_rest_40":
+                return 80 /* PLYValue.SH_40 */;
+            case "f_rest_41":
+                return 81 /* PLYValue.SH_41 */;
+            case "f_rest_42":
+                return 82 /* PLYValue.SH_42 */;
+            case "f_rest_43":
+                return 83 /* PLYValue.SH_43 */;
+            case "f_rest_44":
+                return 84 /* PLYValue.SH_44 */;
+        }
+        return 85 /* 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");
+        let shDegree = 0;
+        for (const prop of filtered) {
+            if (prop.startsWith("property ")) {
+                const [, typeName, name] = prop.split(" ");
+                const value = GaussianSplattingMesh._ValueNameToEnum(name);
+                // SH degree 1,2 or 3 for 9, 24 or 45 values
+                if (value >= 84 /* PLYValue.SH_44 */) {
+                    shDegree = 3;
+                }
+                else if (value >= 64 /* PLYValue.SH_24 */) {
+                    shDegree = 2;
+                }
+                else if (value >= 48 /* PLYValue.SH_8 */) {
+                    shDegree = 1;
+                }
+                const type = GaussianSplattingMesh._TypeNameToEnum(typeName);
+                if (chunkMode == 1 /* ElementMode.Chunk */) {
+                    chunkProperties.push({ value, type, offset: rowChunkOffset });
+                    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);
+        let shBuffer = null;
+        let shCoefficientCount = 0;
+        if (shDegree) {
+            const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;
+            shCoefficientCount = shVectorCount * 3;
+            shBuffer = new ArrayBuffer(shCoefficientCount * vertexCount);
+        }
+        return {
+            vertexCount: vertexCount,
+            chunkCount: chunkCount,
+            rowVertexLength: rowVertexOffset,
+            rowChunkLength: rowChunkOffset,
+            vertexProperties: vertexProperties,
+            chunkProperties: chunkProperties,
+            dataView: dataView,
+            buffer: buffer,
+            shDegree: shDegree,
+            shCoefficientCount: shCoefficientCount,
+            shBuffer: shBuffer,
+        };
+    }
+    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(),
+                minColor: new Vector3(0, 0, 0),
+                maxColor: new Vector3(1, 1, 1),
+            };
+            compressedChunks[i] = currentChunk;
+            for (let propertyIndex = 0; propertyIndex < header.chunkProperties.length; propertyIndex++) {
+                const property = header.chunkProperties[propertyIndex];
+                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;
+                    case 34 /* PLYValue.MIN_COLOR_R */:
+                        currentChunk.minColor.x = value;
+                        break;
+                    case 35 /* PLYValue.MIN_COLOR_G */:
+                        currentChunk.minColor.y = value;
+                        break;
+                    case 36 /* PLYValue.MIN_COLOR_B */:
+                        currentChunk.minColor.z = value;
+                        break;
+                    case 37 /* PLYValue.MAX_COLOR_R */:
+                        currentChunk.maxColor.x = value;
+                        break;
+                    case 38 /* PLYValue.MAX_COLOR_G */:
+                        currentChunk.maxColor.y = value;
+                        break;
+                    case 39 /* PLYValue.MAX_COLOR_B */:
+                        currentChunk.maxColor.z = value;
+                        break;
+                }
+            }
+            offset.value += header.rowChunkLength;
+        }
+        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);
+        let sh = null;
+        if (header.shBuffer) {
+            sh = new Uint8ClampedArray(header.shBuffer, index * header.shCoefficientCount, header.shCoefficientCount);
+        }
+        const chunkIndex = index >> 8;
+        let r0 = 255;
+        let r1 = 0;
+        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 */:
+                    {
+                        const compressedChunk = compressedChunks[chunkIndex];
+                        unpack8888(value, rgba);
+                        rgba[0] = Scalar.Lerp(compressedChunk.minColor.x, compressedChunk.maxColor.x, rgba[0] / 255) * 255;
+                        rgba[1] = Scalar.Lerp(compressedChunk.minColor.y, compressedChunk.maxColor.y, rgba[1] / 255) * 255;
+                        rgba[2] = Scalar.Lerp(compressedChunk.minColor.z, compressedChunk.maxColor.z, rgba[2] / 255) * 255;
+                    }
+                    break;
+                case 16 /* PLYValue.X */:
+                    position[0] = value;
+                    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;
+            }
+            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
+                const clampedValue = Scalar.Clamp(value * 127.5 + 127.5, 0, 255);
+                const shIndex = property.value - 40 /* PLYValue.SH_0 */;
+                sh[shIndex] = clampedValue;
+            }
+        }
+        q.set(r1, r2, r3, r0);
+        q.normalize();
+        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 with SH coefficients splat
+     * if data array buffer is not ply, returns the original buffer
+     * @param data the .ply data to load
+     * @param useCoroutine use coroutine and yield
+     * @returns the loaded splat buffer and optional array of sh coefficients
+     */
+    static *ConvertPLYWithSHToSplat(data, useCoroutine = false) {
+        const header = GaussianSplattingMesh.ParseHeader(data);
+        if (!header) {
+            return { buffer: data };
+        }
+        const offset = { value: 0 };
+        const compressedChunks = GaussianSplattingMesh._GetCompressedChunks(header, offset);
+        for (let i = 0; i < header.vertexCount; i++) {
+            GaussianSplattingMesh._GetSplat(header, i, compressedChunks, offset);
+            if (i % GaussianSplattingMesh._PlyConversionBatchSize === 0 && useCoroutine) {
+                yield;
+            }
+        }
+        let sh = null;
+        // make SH texture buffers
+        if (header.shDegree && header.shBuffer) {
+            const textureCount = Math.ceil(header.shCoefficientCount / 16); // 4 components can be stored per texture, 4 sh per component
+            let shIndexRead = 0;
+            const ubuf = new Uint8Array(header.shBuffer);
+            // sh is an array of uint8array that will be used to create sh textures
+            sh = [];
+            const splatCount = header.vertexCount;
+            const engine = EngineStore.LastCreatedEngine;
+            if (engine) {
+                const width = engine.getCaps().maxTextureSize;
+                const height = Math.ceil(splatCount / width);
+                // create array for the number of textures needed.
+                for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
+                    const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
+                    sh.push(texture);
+                }
+                for (let i = 0; i < splatCount; i++) {
+                    for (let shIndexWrite = 0; shIndexWrite < header.shCoefficientCount; shIndexWrite++) {
+                        const shValue = ubuf[shIndexRead++];
+                        const textureIndex = Math.floor(shIndexWrite / 16);
+                        const shArray = sh[textureIndex];
+                        const byteIndexInTexture = shIndexWrite % 16; // [0..15]
+                        const offsetPerSplat = i * 16; // 16 sh values per texture per splat.
+                        shArray[byteIndexInTexture + offsetPerSplat] = shValue;
+                    }
+                }
+            }
+        }
+        return { buffer: header.buffer, sh: sh };
+    }
+    /**
+     * Converts a .ply data array buffer to splat
+     * if data array buffer is not ply, returns the original buffer
+     * @param data the .ply data to load
+     * @param useCoroutine use coroutine and yield
+     * @returns the loaded splat buffer without SH coefficient, whether ply contains or not SH.
+     */
+    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());
+    }
+    /**
+     * Converts a .ply with SH data array buffer to splat
+     * if data array buffer is not ply, returns the original buffer
+     * @param data the .ply data to load
+     * @returns the loaded splat buffer with SH
+     */
+    static async ConvertPLYWithSHToSplatAsync(data) {
+        return runCoroutineAsync(GaussianSplattingMesh.ConvertPLYWithSHToSplat(data, true), createYieldingScheduler());
+    }
+    /**
+     * Loads a .splat Gaussian Splatting array buffer asynchronously
+     * @param data arraybuffer containing splat file
+     * @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.ConvertPLYWithSHToSplatAsync(plyBuffer).then((splatsData) => {
+                this.updateDataAsync(splatsData.buffer, splatsData.sh);
+            });
+        });
+    }
+    /**
+     * 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(index, 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 * index + 0];
+        const y = -fBuffer[8 * index + 1];
+        const z = fBuffer[8 * index + 2];
+        this._splatPositions[4 * index + 0] = x;
+        this._splatPositions[4 * index + 1] = y;
+        this._splatPositions[4 * index + 2] = z;
+        minimum.minimizeInPlaceFromFloats(x, y, z);
+        maximum.maximizeInPlaceFromFloats(x, y, z);
+        quaternion.set((uBuffer[32 * index + 28 + 1] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 2] - 127.5) / 127.5, (uBuffer[32 * index + 28 + 3] - 127.5) / 127.5, -(uBuffer[32 * index + 28 + 0] - 127.5) / 127.5);
+        quaternion.toRotationMatrix(matrixRotation);
+        Matrix.ScalingToRef(fBuffer[8 * index + 3 + 0] * 2, fBuffer[8 * index + 3 + 1] * 2, fBuffer[8 * index + 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 * index + 3] = factor;
+        const transform = factor;
+        covA[index * 4 + 0] = ToHalfFloat(covariances[0] / transform);
+        covA[index * 4 + 1] = ToHalfFloat(covariances[1] / transform);
+        covA[index * 4 + 2] = ToHalfFloat(covariances[2] / transform);
+        covA[index * 4 + 3] = ToHalfFloat(covariances[3] / transform);
+        covB[index * covBSItemSize + 0] = ToHalfFloat(covariances[4] / transform);
+        covB[index * covBSItemSize + 1] = ToHalfFloat(covariances[5] / transform);
+        // colors
+        colorArray[index * 4 + 0] = uBuffer[32 * index + 24 + 0];
+        colorArray[index * 4 + 1] = uBuffer[32 * index + 24 + 1];
+        colorArray[index * 4 + 2] = uBuffer[32 * index + 24 + 2];
+        colorArray[index * 4 + 3] = uBuffer[32 * index + 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._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);
+        if (this._keepInRam) {
+            this._splatsData = data;
+            if (sh) {
+                this._sh = sh;
+            }
+        }
+        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, 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, 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));
+    }
+    /**
+     * Refreshes the bounding info, taking into account all the thin instances defined
+     * @returns the current Gaussian Splatting
+     */
+    refreshBoundingInfo() {
+        this.thinInstanceRefreshBoundingInfo(false);
+        return this;
+    }
+    // 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;
+    }
+}
+
+/** 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
+        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
+        const SH_C0 = 0.282;
+        for (let i = 0; i < splatCount; i++) {
+            for (let component = 0; component < 3; component++) {
+                const byteValue = ubuf[byteOffset + splatCount + i * 3 + component];
+                // 0.15 is hard coded value from spz
+                // Scale factor for DC color components. To convert to RGB, we should multiply by 0.282, but it can
+                // be useful to represent base colors that are out of range if the higher spherical harmonics bands
+                // bring them back into range so we multiply by a smaller value.
+                const value = (byteValue - 127.5) / (0.15 * 255);
+                rgba[i * 32 + 24 + component] = Scalar.Clamp((0.5 + SH_C0 * value) * 255, 0, 255);
+            }
+            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;
+        }
+        // convert quaternion
+        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;
+            const v = 1 - (nx * nx + ny * ny + nz * nz);
+            rot[i * 32 + 28 + 0] = 127.5 + Math.sqrt(v < 0 ? 0 : v) * 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.ConvertPLYWithSHToSplatAsync(data).then((splatsData) => {
+            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: splatsData.buffer, sh: splatsData.sh, 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: splatsData.buffer, sh: splatsData.sh, faces: faces, hasVertexColors: !!propertyColorCount });
+            });
+        });
+    }
+}
+SPLATFileLoader._DefaultLoadingOptions = {
+    keepInRam: false,
+};
+// Add this loader into the register plugin
+registerSceneLoaderPlugin(new SPLATFileLoader());
+
+export { SPLATFileLoader };
+//# sourceMappingURL=splatFileLoader-K9RpjB6c.esm.js.map