@uptimizr/dashboard 0.1.2 → 0.2.0

package/out/_next/static/chunks/0sqys6o2pbe1q.js

@@ -0,0 +1,1328 @@
+(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,4357,e=>{"use strict";var t=e.i(12423);let r="helperFunctions",i=`const PI: f32=3.1415926535897932384626433832795;const TWO_PI: f32=6.283185307179586;const HALF_PI: f32=1.5707963267948966;const RECIPROCAL_PI: f32=0.3183098861837907;const RECIPROCAL_PI2: f32=0.15915494309189535;const RECIPROCAL_PI4: f32=0.07957747154594767;const HALF_MIN: f32=5.96046448e-08; 
+const LinearEncodePowerApprox: f32=2.2;const GammaEncodePowerApprox: f32=1.0/LinearEncodePowerApprox;const LuminanceEncodeApprox: vec3f=vec3f(0.2126,0.7152,0.0722);const Epsilon:f32=0.0000001;fn square(x: f32)->f32 {return x*x;}
+fn saturate(x: f32)->f32 {return clamp(x,0.0,1.0);}
+fn saturateVec3(x: vec3f)->vec3f {return clamp(x,vec3f(),vec3f(1.0));}
+fn saturateEps(x: f32)->f32 {return clamp(x,Epsilon,1.0);}
+fn maxEps(x: f32)->f32 {return max(x,Epsilon);}
+fn maxEpsVec3(x: vec3f)->vec3f {return max(x,vec3f(Epsilon));}
+fn absEps(x: f32)->f32 {return abs(x)+Epsilon;}
+fn transposeMat3(inMatrix: mat3x3f)->mat3x3f {let i0: vec3f=inMatrix[0];let i1: vec3f=inMatrix[1];let i2: vec3f=inMatrix[2];let outMatrix:mat3x3f=mat3x3f(
+vec3(i0.x,i1.x,i2.x),
+vec3(i0.y,i1.y,i2.y),
+vec3(i0.z,i1.z,i2.z)
+);return outMatrix;}
+fn inverseMat3(inMatrix: mat3x3f)->mat3x3f {let a00: f32=inMatrix[0][0];let a01: f32=inMatrix[0][1];let a02: f32=inMatrix[0][2];let a10: f32=inMatrix[1][0];let a11: f32=inMatrix[1][1];let a12: f32=inMatrix[1][2];let a20: f32=inMatrix[2][0];let a21: f32=inMatrix[2][1];let a22: f32=inMatrix[2][2];let b01: f32=a22*a11-a12*a21;let b11: f32=-a22*a10+a12*a20;let b21: f32=a21*a10-a11*a20;let det: f32=a00*b01+a01*b11+a02*b21;return mat3x3f(b01/det,(-a22*a01+a02*a21)/det,(a12*a01-a02*a11)/det,
+b11/det,(a22*a00-a02*a20)/det,(-a12*a00+a02*a10)/det,
+b21/det,(-a21*a00+a01*a20)/det,(a11*a00-a01*a10)/det);}
+#if USE_EXACT_SRGB_CONVERSIONS
+fn toLinearSpaceExact(color: vec3f)->vec3f
+{let nearZeroSection: vec3f=0.0773993808*color;let remainingSection: vec3f=pow(0.947867299*(color+vec3f(0.055)),vec3f(2.4));return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.04045)));}
+fn toGammaSpaceExact(color: vec3f)->vec3f
+{let nearZeroSection: vec3f=12.92*color;let remainingSection: vec3f=1.055*pow(color,vec3f(0.41666))-vec3f(0.055);return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.0031308)));}
+#endif
+fn toLinearSpace(color: f32)->f32
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+var nearZeroSection=0.0773993808*color;var remainingSection=pow(0.947867299*(color+0.055),2.4);return select(remainingSection,nearZeroSection,color<=0.04045);
+#else
+return pow(color,LinearEncodePowerApprox);
+#endif
+}
+fn toLinearSpaceVec3(color: vec3f)->vec3f
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toLinearSpaceExact(color);
+#else
+return pow(color,vec3f(LinearEncodePowerApprox));
+#endif
+}
+fn toLinearSpaceVec4(color: vec4<f32>)->vec4<f32>
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4f(toLinearSpaceExact(color.rgb),color.a);
+#else
+return vec4f(pow(color.rgb,vec3f(LinearEncodePowerApprox)),color.a);
+#endif
+}
+fn toGammaSpace(color: vec4<f32>)->vec4<f32>
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4<f32>(toGammaSpaceExact(color.rgb),color.a);
+#else
+return vec4<f32>(pow(color.rgb,vec3f(GammaEncodePowerApprox)),color.a);
+#endif
+}
+fn toGammaSpaceVec3(color: vec3f)->vec3f
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toGammaSpaceExact(color);
+#else
+return pow(color,vec3f(GammaEncodePowerApprox));
+#endif
+}
+fn squareVec3(value: vec3f)->vec3f
+{return value*value;}
+fn pow5(value: f32)->f32 {let sq: f32=value*value;return sq*sq*value;}
+fn double_refract(I: vec3f,N: vec3f,eta: f32)->vec3f {let Tfront: vec3f=refract(I,N,1.0/eta);let Nback: vec3f=normalize(reflect(N,Tfront));return refract(Tfront,-Nback,eta);}
+fn getLuminanceUnclamped(color: vec3f)->f32
+{return dot(color,LuminanceEncodeApprox);}
+fn getLuminance(color: vec3f)->f32
+{return saturate(getLuminanceUnclamped(color));}
+fn getRand(seed: vec2<f32>)->f32 {return fract(sin(dot(seed.xy ,vec2<f32>(12.9898,78.233)))*43758.5453);}
+fn dither(seed: vec2<f32>,varianceAmount: f32)->f32 {let rand: f32=getRand(seed);let normVariance: f32=varianceAmount/255.0;let dither: f32=mix(-normVariance,normVariance,rand);return dither;}
+const rgbdMaxRange: f32=255.0;fn toRGBD(color: vec3f)->vec4<f32> {let maxRGB: f32=max(max(color.r,max(color.g,color.b)),Epsilon);var D: f32 =max(rgbdMaxRange/maxRGB,1.);D =clamp(floor(D)/255.0,0.,1.);var rgb: vec3f =color.rgb*D;rgb=toGammaSpaceVec3(rgb);return vec4<f32>(saturateVec3(rgb),D);}
+fn fromRGBD(rgbd: vec4<f32>)->vec3f {let rgb=toLinearSpaceVec3(rgbd.rgb);return rgb/rgbd.a;}
+fn parallaxCorrectNormal(vertexPos: vec3f,origVec: vec3f,cubeSize: vec3f,cubePos: vec3f)->vec3f {let invOrigVec: vec3f=vec3f(1.)/origVec;let halfSize: vec3f=cubeSize*0.5;let intersecAtMaxPlane: vec3f=(cubePos+halfSize-vertexPos)*invOrigVec;let intersecAtMinPlane: vec3f=(cubePos-halfSize-vertexPos)*invOrigVec;let largestIntersec: vec3f=max(intersecAtMaxPlane,intersecAtMinPlane);let distance: f32=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);let intersectPositionWS: vec3f=vertexPos+origVec*distance;return intersectPositionWS-cubePos;}
+fn equirectangularToCubemapDirection(uv : vec2f)->vec3f {var longitude : f32=uv.x*TWO_PI-PI;var latitude : f32=HALF_PI-uv.y*PI;var direction : vec3f;direction.x=cos(latitude)*sin(longitude);direction.y=sin(latitude);direction.z=cos(latitude)*cos(longitude);return direction;}
+fn sqrtClamped(value: f32)->f32 {return sqrt(max(value,0.));}
+fn avg(value: vec3f)->f32 {return dot(value,vec3f(0.333333333));}
+fn singleScatterToMultiScatterAlbedo(rho_ss: vec3f)->vec3f {let s: vec3f=sqrt(max(vec3f(1.0)-rho_ss,vec3f(0.0)));return (vec3f(1.0)-s)*(vec3f(1.0)-vec3f(0.139)*s)/(vec3f(1.0)+vec3f(1.17)*s);}
+fn multiScatterToSingleScatterAlbedo(rho_ms: vec3f)->vec3f {let s: vec3f=4.09712f+4.20863f*rho_ms-sqrt(9.59217f+41.6808f*rho_ms+17.7126f*rho_ms*rho_ms);return 1.0f-s*s;}
+fn multiScatterToSingleScatterAlbedoWithAniso(rho_ms: vec3f,aniso: f32)->vec3f {let s: vec3f=4.09712+4.20863f*rho_ms-sqrt(9.59217f+41.6808f*rho_ms+17.7126f*rho_ms*rho_ms);return (vec3f(1.0f)-s*s)/maxEpsVec3(vec3f(1.0f)-vec3f(aniso)*s*s);}
+fn min3(v: vec3f)->f32 {return min(v.x,min(v.y,v.z));}
+fn max3(v: vec3f)->f32 {return max(v.x,max(v.y,v.z));}
+fn uint2float(i: u32)->f32 {return bitcast<f32>(0x3F800000u | (i>>9u))-1.0;}
+fn plasticSequence(rstate: u32)->vec2f {return vec2f(uint2float(rstate*3242174889u),
+uint2float(rstate*2447445414u));}
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["helperFunctionsWGSL",0,{name:r,shader:i}])},60106,e=>{"use strict";var t=e.i(12423);let r="sceneUboDeclaration",i=`struct Scene {viewProjection : mat4x4<f32>,
+#ifdef MULTIVIEW
+viewProjectionR : mat4x4<f32>,
+#endif 
+view : mat4x4<f32>,
+projection : mat4x4<f32>,
+vEyePosition : vec4<f32>,
+inverseProjection : mat4x4<f32>,};
+#define SCENE_UBO
+var<uniform> scene : Scene;
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["sceneUboDeclarationWGSL",0,{name:r,shader:i}])},50008,39780,54758,e=>{"use strict";var t=e.i(12423);let r="meshUboDeclaration",i=`struct Mesh {world : mat4x4<f32>,
+visibility : f32,};var<uniform> mesh : Mesh;
+#define WORLD_UBO
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["meshUboDeclarationWGSL",0,{name:r,shader:i}],50008);let n="mainUVVaryingDeclaration",a=`#ifdef MAINUV{X}
+varying vMainUV{X}: vec2f;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["mainUVVaryingDeclarationWGSL",0,{name:n,shader:a}],39780);let f="logDepthDeclaration",o=`#ifdef LOGARITHMICDEPTH
+uniform logarithmicDepthConstant: f32;varying vFragmentDepth: f32;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[f]||(t.ShaderStore.IncludesShadersStoreWGSL[f]=o),e.s(["logDepthDeclarationWGSL",0,{name:f,shader:o}],54758)},99452,e=>{"use strict";var t=e.i(12423);let r="harmonicsFunctions",i=`#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+fn computeEnvironmentIrradiance(normal: vec3f)->vec3f {return uniforms.vSphericalL00
++ uniforms.vSphericalL1_1*(normal.y)
++ uniforms.vSphericalL10*(normal.z)
++ uniforms.vSphericalL11*(normal.x)
++ uniforms.vSphericalL2_2*(normal.y*normal.x)
++ uniforms.vSphericalL2_1*(normal.y*normal.z)
++ uniforms.vSphericalL20*((3.0*normal.z*normal.z)-1.0)
++ uniforms.vSphericalL21*(normal.z*normal.x)
++ uniforms.vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));}
+#else
+fn computeEnvironmentIrradiance(normal: vec3f)->vec3f {var Nx: f32=normal.x;var Ny: f32=normal.y;var Nz: f32=normal.z;var C1: vec3f=uniforms.vSphericalZZ.rgb;var Cx: vec3f=uniforms.vSphericalX.rgb;var Cy: vec3f=uniforms.vSphericalY.rgb;var Cz: vec3f=uniforms.vSphericalZ.rgb;var Cxx_zz: vec3f=uniforms.vSphericalXX_ZZ.rgb;var Cyy_zz: vec3f=uniforms.vSphericalYY_ZZ.rgb;var Cxy: vec3f=uniforms.vSphericalXY.rgb;var Cyz: vec3f=uniforms.vSphericalYZ.rgb;var Czx: vec3f=uniforms.vSphericalZX.rgb;var a1: vec3f=Cyy_zz*Ny+Cy;var a2: vec3f=Cyz*Nz+a1;var b1: vec3f=Czx*Nz+Cx;var b2: vec3f=Cxy*Ny+b1;var b3: vec3f=Cxx_zz*Nx+b2;var t1: vec3f=Cz *Nz+C1;var t2: vec3f=a2 *Ny+t1;var t3: vec3f=b3 *Nx+t2;return t3;}
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["harmonicsFunctionsWGSL",0,{name:r,shader:i}])},61202,e=>{"use strict";var t=e.i(12423);let r="pbrBRDFFunctions",i=`#define FRESNEL_MAXIMUM_ON_ROUGH 0.25
+#define BRDF_DIFFUSE_MODEL_EON 0
+#define BRDF_DIFFUSE_MODEL_BURLEY 1
+#define BRDF_DIFFUSE_MODEL_LAMBERT 2
+#define BRDF_DIFFUSE_MODEL_LEGACY 3
+#define DIELECTRIC_SPECULAR_MODEL_GLTF 0
+#define DIELECTRIC_SPECULAR_MODEL_OPENPBR 1
+#define CONDUCTOR_SPECULAR_MODEL_GLTF 0
+#define CONDUCTOR_SPECULAR_MODEL_OPENPBR 1
+#if !defined(PBR_VERTEX_SHADER) && !defined(OPENPBR_VERTEX_SHADER)
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+fn getEnergyConservationFactor(specularEnvironmentR0: vec3f,environmentBrdf: vec3f)->vec3f {return 1.0+specularEnvironmentR0*(1.0/environmentBrdf.y-1.0);}
+#endif
+#if CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR
+const F82_COS_THETA_MAX: f32 =0.142857143;const F82_ONE_MINUS_CTM_POW5: f32 =0.462664366;const F82_ONE_MINUS_CTM_POW6: f32 =0.396569457;const F82_B_DENOMINATOR_RECIP: f32 =17.6512785;const BRDF_Z_SCALE: f32 =16.0;fn getF82Specular(NdotV: f32,F0: vec3f,edgeTint: vec3f,roughness: f32)->vec3f {let white_minus_F0: vec3f=vec3f(1.0f)-F0;let b_numerator: vec3f=(F0+white_minus_F0*F82_ONE_MINUS_CTM_POW5)*(vec3f(1.0)-edgeTint);let b: vec3f=b_numerator*F82_B_DENOMINATOR_RECIP;let cos_theta: f32=max(roughness,NdotV);let one_minus_cos_theta: f32=1.0-cos_theta;let offset_from_F0: vec3f=(white_minus_F0-b*cos_theta*one_minus_cos_theta)*pow(one_minus_cos_theta,5.0f);return clamp(F0+offset_from_F0,vec3f(0.0f),vec3f(1.0f));}
+fn getF82B(F0: vec3f,edgeTint: vec3f)->vec3f {return (F0+(vec3f(1.0)-F0)*F82_ONE_MINUS_CTM_POW5)*(vec3f(1.0)-edgeTint)*F82_B_DENOMINATOR_RECIP;}
+fn getF82DirectionalAlbedo(F0: vec3f,F90: vec3f,b: vec3f,environmentBrdf: vec3f)->vec3f {return (F90-F0)*environmentBrdf.x+F0*environmentBrdf.y-b*environmentBrdf.z;}
+fn getF82AverageFresnel(F0: vec3f,b: vec3f)->vec3f {return F0+(vec3f(1.0)-F0)/21.0-b/126.0;}
+#endif
+#ifdef FUZZENVIRONMENTBRDF
+fn getFuzzBRDFLookup(NdotV: f32,perceptualRoughness: f32)->vec3f {let UV: vec2f=vec2f(perceptualRoughness,NdotV);var brdfLookup: vec4f=textureSample(environmentFuzzBrdfSampler,environmentFuzzBrdfSamplerSampler,UV);const RiRange: vec2f=vec2f(0.0f,0.75f);const ARange: vec2f=vec2f(0.005f,0.88f);const BRange: vec2f=vec2f(-0.18f,0.002f);brdfLookup.r=mix(ARange.x, ARange.y, brdfLookup.r);brdfLookup.g=mix(BRange.x, BRange.y, brdfLookup.g);brdfLookup.b=mix(RiRange.x,RiRange.y,brdfLookup.b);return brdfLookup.rgb;}
+#endif
+#ifdef ENVIRONMENTBRDF
+fn getBRDFLookup(NdotV: f32,perceptualRoughness: f32)->vec3f {var UV: vec2f= vec2f(NdotV,perceptualRoughness);var brdfLookup: vec4f= textureSample(environmentBrdfSampler,environmentBrdfSamplerSampler,UV);
+#ifdef ENVIRONMENTBRDF_RGBD
+brdfLookup=vec4f(fromRGBD(brdfLookup.rgba),brdfLookup.a);
+#endif
+return brdfLookup.rgb;}
+fn getReflectanceFromBRDFWithEnvLookup(specularEnvironmentR0: vec3f,specularEnvironmentR90: vec3f,environmentBrdf: vec3f)->vec3f {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+var reflectance: vec3f=(specularEnvironmentR90-specularEnvironmentR0)*environmentBrdf.x+specularEnvironmentR0*environmentBrdf.y;
+#else
+var reflectance: vec3f=specularEnvironmentR0*environmentBrdf.x+specularEnvironmentR90*environmentBrdf.y;
+#endif
+return reflectance;}
+fn getReflectanceFromBRDFLookup(specularEnvironmentR0: vec3f,environmentBrdf: vec3f)->vec3f {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+var reflectance: vec3f=mix(environmentBrdf.xxx,environmentBrdf.yyy,specularEnvironmentR0);
+#else
+var reflectance: vec3f=specularEnvironmentR0*environmentBrdf.x+environmentBrdf.y;
+#endif
+return reflectance;}
+#endif
+/* NOT USED
+#if defined(SHEEN) && defined(SHEEN_SOFTER)
+fn getBRDFLookupCharlieSheen(NdotV: f32,perceptualRoughness: f32)->f32
+{var c: f32=1.0-NdotV;var c3: f32=c*c*c;return 0.65584461*c3+1.0/(4.16526551+exp(-7.97291361*perceptualRoughness+6.33516894));}
+#endif
+*/
+#if !defined(ENVIRONMENTBRDF) || defined(REFLECTIONMAP_SKYBOX) || defined(ALPHAFRESNEL)
+fn getReflectanceFromAnalyticalBRDFLookup_Jones(VdotN: f32,reflectance0: vec3f,reflectance90: vec3f,smoothness: f32)->vec3f
+{var weight: f32=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));}
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF)
+/**
+* The sheen BRDF not containing F can be easily stored in the blue channel of the BRDF texture.
+* The blue channel contains DCharlie*VAshikhmin*NdotL as a lokkup table
+*/
+fn getSheenReflectanceFromBRDFLookup(reflectance0: vec3f,environmentBrdf: vec3f)->vec3f {var sheenEnvironmentReflectance: vec3f=reflectance0*environmentBrdf.b;return sheenEnvironmentReflectance;}
+#endif
+fn fresnelSchlickGGXVec3(VdotH: f32,reflectance0: vec3f,reflectance90: vec3f)->vec3f
+{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}
+fn fresnelSchlickGGX(VdotH: f32,reflectance0: f32,reflectance90: f32)->f32
+{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}
+#ifdef CLEARCOAT
+fn getR0RemappedForClearCoat(f0: vec3f)->vec3f {
+#ifdef CLEARCOAT_DEFAULTIOR
+#ifdef MOBILE
+return saturateVec3(f0*(f0*0.526868+0.529324)-0.0482256);
+#else
+return saturateVec3(f0*(f0*(0.941892-0.263008*f0)+0.346479)-0.0285998);
+#endif
+#else
+var s: vec3f=sqrt(f0);var t: vec3f=(uniforms.vClearCoatRefractionParams.z+uniforms.vClearCoatRefractionParams.w*s)/(uniforms.vClearCoatRefractionParams.w+uniforms.vClearCoatRefractionParams.z*s);return squareVec3(t);
+#endif
+}
+#endif
+#ifdef IRIDESCENCE
+const XYZ_TO_REC709: mat3x3f= mat3x3f(
+3.2404542,-0.9692660, 0.0556434,
+-1.5371385, 1.8760108,-0.2040259,
+-0.4985314, 0.0415560, 1.0572252
+);fn getIORTfromAirToSurfaceR0(f0: vec3f)->vec3f {var sqrtF0: vec3f=sqrt(f0);return (1.+sqrtF0)/(1.-sqrtF0);}
+fn getR0fromIORsVec3(iorT: vec3f,iorI: f32)->vec3f {return squareVec3((iorT- vec3f(iorI))/(iorT+ vec3f(iorI)));}
+fn getR0fromIORs(iorT: f32,iorI: f32)->f32 {return square((iorT-iorI)/(iorT+iorI));}
+fn evalSensitivity(opd: f32,shift: vec3f)->vec3f {var phase: f32=2.0*PI*opd*1.0e-9;const val: vec3f= vec3f(5.4856e-13,4.4201e-13,5.2481e-13);const pos: vec3f= vec3f(1.6810e+06,1.7953e+06,2.2084e+06);const vr: vec3f= vec3f(4.3278e+09,9.3046e+09,6.6121e+09);var xyz: vec3f=val*sqrt(2.0*PI*vr)*cos(pos*phase+shift)*exp(-square(phase)*vr);xyz.x+=9.7470e-14*sqrt(2.0*PI*4.5282e+09)*cos(2.2399e+06*phase+shift[0])*exp(-4.5282e+09*square(phase));xyz/=1.0685e-7;var srgb: vec3f=XYZ_TO_REC709*xyz;return srgb;}
+fn evalIridescence(outsideIOR: f32,eta2: f32,cosTheta1: f32,thinFilmThickness: f32,baseF0: vec3f)->vec3f {var I: vec3f= vec3f(1.0);var iridescenceIOR: f32=mix(outsideIOR,eta2,smoothstep(0.0,0.03,thinFilmThickness));var sinTheta2Sq: f32=square(outsideIOR/iridescenceIOR)*(1.0-square(cosTheta1));var cosTheta2Sq: f32=1.0-sinTheta2Sq;if (cosTheta2Sq<0.0) {return I;}
+var cosTheta2: f32=sqrt(cosTheta2Sq);var R0: f32=getR0fromIORs(iridescenceIOR,outsideIOR);var R12: f32=fresnelSchlickGGX(cosTheta1,R0,1.);var R21: f32=R12;var T121: f32=1.0-R12;var phi12: f32=0.0;if (iridescenceIOR<outsideIOR) {phi12=PI;}
+var phi21: f32=PI-phi12;var baseIOR: vec3f=getIORTfromAirToSurfaceR0(clamp(baseF0,vec3f(0.0),vec3f(0.9999))); 
+var R1: vec3f=getR0fromIORsVec3(baseIOR,iridescenceIOR);let maxR1: f32=max(R1.r,max(R1.g,R1.b));if (maxR1<1e-6) {return max(vec3f(R12),vec3f(0.0));}
+var R23: vec3f=fresnelSchlickGGXVec3(cosTheta2,R1,vec3f(1.));var phi23: vec3f=vec3f(0.0);if (baseIOR[0]<iridescenceIOR) {phi23[0]=PI;}
+if (baseIOR[1]<iridescenceIOR) {phi23[1]=PI;}
+if (baseIOR[2]<iridescenceIOR) {phi23[2]=PI;}
+var opd: f32=2.0*iridescenceIOR*thinFilmThickness*cosTheta2;var phi: vec3f=vec3f(phi21)+phi23;var R123: vec3f=clamp(R12*R23,vec3f(1e-5),vec3f(0.9999));var r123: vec3f=sqrt(R123);var Rs: vec3f=(T121*T121)*R23/(vec3f(1.0)-R123);var C0: vec3f=R12+Rs;I=C0;var Cm: vec3f=Rs-T121;for (var m: i32=1; m<=2; m++)
+{Cm*=r123;var Sm: vec3f=2.0*evalSensitivity(f32(m)*opd,f32(m)*phi);I+=Cm*Sm;}
+return max(I,vec3f(0.0));}
+#endif
+fn normalDistributionFunction_TrowbridgeReitzGGX(NdotH: f32,alphaG: f32)->f32
+{var a2: f32=alphaG*alphaG;var d: f32=NdotH*NdotH*(a2-1.0)+1.0;return a2/(PI*d*d);}
+#ifdef SHEEN
+fn normalDistributionFunction_CharlieSheen(NdotH: f32,alphaG: f32)->f32
+{var invR: f32=1./alphaG;var cos2h: f32=NdotH*NdotH;var sin2h: f32=1.-cos2h;return (2.+invR)*pow(sin2h,invR*.5)/(2.*PI);}
+#endif
+#ifdef ANISOTROPIC
+fn normalDistributionFunction_BurleyGGX_Anisotropic(NdotH: f32,TdotH: f32,BdotH: f32,alphaTB: vec2f)->f32 {var a2: f32=alphaTB.x*alphaTB.y;var v: vec3f= vec3f(alphaTB.y*TdotH,alphaTB.x *BdotH,a2*NdotH);var v2: f32=dot(v,v);var w2: f32=a2/v2;return a2*w2*w2*RECIPROCAL_PI;}
+#endif
+#ifdef BRDF_V_HEIGHT_CORRELATED
+fn smithVisibility_GGXCorrelated(NdotL: f32,NdotV: f32,alphaG: f32)->f32 {
+#ifdef MOBILE
+var GGXV: f32=NdotL*(NdotV*(1.0-alphaG)+alphaG);var GGXL: f32=NdotV*(NdotL*(1.0-alphaG)+alphaG);return 0.5/(GGXV+GGXL);
+#else
+var a2: f32=alphaG*alphaG;var GGXV: f32=NdotL*sqrt(NdotV*(NdotV-a2*NdotV)+a2);var GGXL: f32=NdotV*sqrt(NdotL*(NdotL-a2*NdotL)+a2);return 0.5/(GGXV+GGXL);
+#endif
+}
+#else
+fn smithVisibilityG1_TrowbridgeReitzGGXFast(dot: f32,alphaG: f32)->f32
+{
+#ifdef MOBILE
+return 1.0/(dot+alphaG+(1.0-alphaG)*dot ));
+#else
+var alphaSquared: f32=alphaG*alphaG;return 1.0/(dot+sqrt(alphaSquared+(1.0-alphaSquared)*dot*dot));
+#endif
+}
+fn smithVisibility_TrowbridgeReitzGGXFast(NdotL: f32,NdotV: f32,alphaG: f32)->f32
+{var visibility: f32=smithVisibilityG1_TrowbridgeReitzGGXFast(NdotL,alphaG)*smithVisibilityG1_TrowbridgeReitzGGXFast(NdotV,alphaG);return visibility;}
+#endif
+#ifdef ANISOTROPIC
+fn smithVisibility_GGXCorrelated_Anisotropic(NdotL: f32,NdotV: f32,TdotV: f32,BdotV: f32,TdotL: f32,BdotL: f32,alphaTB: vec2f)->f32 {var lambdaV: f32=NdotL*length( vec3f(alphaTB.x*TdotV,alphaTB.y*BdotV,NdotV));var lambdaL: f32=NdotV*length( vec3f(alphaTB.x*TdotL,alphaTB.y*BdotL,NdotL));var v: f32=0.5/(lambdaV+lambdaL);return v;}
+#endif
+#ifdef CLEARCOAT
+fn visibility_Kelemen(VdotH: f32)->f32 {return 0.25/(VdotH*VdotH); }
+#endif
+#ifdef SHEEN
+fn visibility_Ashikhmin(NdotL: f32,NdotV: f32)->f32
+{return 1./(4.*(NdotL+NdotV-NdotL*NdotV));}
+/* NOT USED
+#ifdef SHEEN_SOFTER
+fn l(x: f32,alphaG: f32)->f32
+{var oneMinusAlphaSq: f32=(1.0-alphaG)*(1.0-alphaG);var a: f32=mix(21.5473,25.3245,oneMinusAlphaSq);var b: f32=mix(3.82987,3.32435,oneMinusAlphaSq);var c: f32=mix(0.19823,0.16801,oneMinusAlphaSq);var d: f32=mix(-1.97760,-1.27393,oneMinusAlphaSq);var e: f32=mix(-4.32054,-4.85967,oneMinusAlphaSq);return a/(1.0+b*pow(x,c))+d*x+e;}
+fn lambdaSheen(cosTheta: f32,alphaG: f32)->f32
+{return abs(cosTheta)<0.5 ? exp(l(cosTheta,alphaG)) : exp(2.0*l(0.5,alphaG)-l(1.0-cosTheta,alphaG));}
+fn visibility_CharlieSheen(NdotL: f32,NdotV: f32,alphaG: f32)->f32
+{var G: f32=1.0/(1.0+lambdaSheen(NdotV,alphaG)+lambdaSheen(NdotL,alphaG));return G/(4.0*NdotV*NdotL);}
+#endif
+*/
+#endif
+const constant1_FON: f32=0.5f-2.0f/(3.0f*PI);const constant2_FON: f32=2.0f/3.0f-28.0f/(15.0f*PI);fn E_FON_approx(mu: f32,roughness: f32)->f32
+{var sigma: f32=roughness; 
+var mucomp: f32=1.0f-mu;var mucomp2: f32=mucomp*mucomp;const Gcoeffs: mat2x2f=mat2x2f(0.0571085289f,-0.332181442f,
+0.491881867f,0.0714429953f);var GoverPi: f32=dot(Gcoeffs*vec2f(mucomp,mucomp2),vec2f(1.0f,mucomp2));return (1.0f+sigma*GoverPi)/(1.0f+constant1_FON*sigma);}
+fn diffuseBRDF_EON(albedo: vec3f,roughness: f32,NdotL: f32,NdotV: f32,LdotV: f32)->vec3f
+{var rho: vec3f=albedo;var sigma: f32=roughness; 
+var mu_i: f32=NdotL; 
+var mu_o: f32=NdotV; 
+var s: f32=LdotV-mu_i*mu_o; 
+var sovertF: f32=select(s,s/max(mu_i,mu_o),s>0.0f); 
+var AF: f32=1.0f/(1.0f+constant1_FON*sigma); 
+var f_ss: vec3f=(rho*RECIPROCAL_PI)*AF*(1.0f+sigma*sovertF); 
+var EFo: f32=E_FON_approx(mu_o,sigma); 
+var EFi: f32=E_FON_approx(mu_i,sigma); 
+var avgEF: f32=AF*(1.0f+constant2_FON*sigma); 
+var rho_ms: vec3f=(rho*rho)*avgEF/(vec3f(1.0f)-rho*(1.0f-avgEF));const eps: f32=1.0e-7f;var f_ms: vec3f=(rho_ms*RECIPROCAL_PI)*max(eps,1.0f-EFo) 
+* max(eps,1.0f-EFi)
+/ max(eps,1.0f-avgEF);return (f_ss+f_ms);}
+fn diffuseBRDF_Burley(NdotL: f32,NdotV: f32,VdotH: f32,roughness: f32)->f32 {var diffuseFresnelNV: f32=pow5(saturateEps(1.0-NdotL));var diffuseFresnelNL: f32=pow5(saturateEps(1.0-NdotV));var diffuseFresnel90: f32=0.5+2.0*VdotH*VdotH*roughness;var fresnel: f32 =
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNL) *
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNV);return fresnel/PI;}
+#ifdef SS_TRANSLUCENCY
+fn transmittanceBRDF_Burley(tintColor: vec3f,diffusionDistance: vec3f,thickness: f32)->vec3f {var S: vec3f=1./maxEpsVec3(diffusionDistance);var temp: vec3f=exp((-0.333333333*thickness)*S);return tintColor.rgb*0.25*(temp*temp*temp+3.0*temp);}
+fn computeWrappedDiffuseNdotL(NdotL: f32,w: f32)->f32 {var t: f32=1.0+w;var invt2: f32=1.0/(t*t);return saturate((NdotL+w)*invt2);}
+#endif
+#endif 
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["pbrBRDFFunctionsWGSL",0,{name:r,shader:i}])},45329,35011,e=>{"use strict";var t=e.i(12423);let r="bonesDeclaration",i=`#if NUM_BONE_INFLUENCERS>0
+#ifndef USE_VERTEX_PULLING
+attribute matricesIndices : vec4f;attribute matricesWeights : vec4f;
+#if NUM_BONE_INFLUENCERS>4
+attribute matricesIndicesExtra : vec4f;attribute matricesWeightsExtra : vec4f;
+#endif
+#endif
+#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#ifdef BONETEXTURE
+var boneSampler : texture_2d<f32>;uniform boneTextureInfo : vec2f;
+#else
+uniform mBones : array<mat4x4f,BonesPerMesh>;
+#endif
+#ifdef BONES_VELOCITY_ENABLED
+uniform mPreviousBones : array<mat4x4f,BonesPerMesh>;
+#endif
+#ifdef BONETEXTURE
+fn readMatrixFromRawSampler(smp : texture_2d<f32>,index : f32)->mat4x4f
+{let offset=i32(index)*4; 
+let textureWidth=i32(uniforms.boneTextureInfo.x);let y=offset/textureWidth;let x=offset % textureWidth;let m0=textureLoad(smp,vec2<i32>(x+0,y),0);let m1=textureLoad(smp,vec2<i32>(x+1,y),0);let m2=textureLoad(smp,vec2<i32>(x+2,y),0);let m3=textureLoad(smp,vec2<i32>(x+3,y),0);return mat4x4f(m0,m1,m2,m3);}
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["bonesDeclarationWGSL",0,{name:r,shader:i}],45329);let n="bakedVertexAnimationDeclaration",a=`#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+uniform bakedVertexAnimationTime: f32;uniform bakedVertexAnimationSettings: vec4<f32>;var bakedVertexAnimationTexture : texture_2d<f32>;
+#ifdef INSTANCES
+attribute bakedVertexAnimationSettingsInstanced : vec4<f32>;
+#endif
+fn readMatrixFromRawSamplerVAT(smp : texture_2d<f32>,index : f32,frame : f32)->mat4x4<f32>
+{let offset=i32(index)*4;let frameUV=i32(frame);let m0=textureLoad(smp,vec2<i32>(offset+0,frameUV),0);let m1=textureLoad(smp,vec2<i32>(offset+1,frameUV),0);let m2=textureLoad(smp,vec2<i32>(offset+2,frameUV),0);let m3=textureLoad(smp,vec2<i32>(offset+3,frameUV),0);return mat4x4<f32>(m0,m1,m2,m3);}
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["bakedVertexAnimationDeclarationWGSL",0,{name:n,shader:a}],35011)},18062,e=>{"use strict";var t=e.i(12423);let r="instancesDeclaration",i=`#ifdef INSTANCES
+attribute world0 : vec4<f32>;attribute world1 : vec4<f32>;attribute world2 : vec4<f32>;attribute world3 : vec4<f32>;
+#ifdef INSTANCESCOLOR
+attribute instanceColor : vec4<f32>;
+#endif
+#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)
+uniform world : mat4x4<f32>;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+attribute previousWorld0 : vec4<f32>;attribute previousWorld1 : vec4<f32>;attribute previousWorld2 : vec4<f32>;attribute previousWorld3 : vec4<f32>;
+#ifdef THIN_INSTANCES
+uniform previousWorld : mat4x4<f32>;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+uniform world : mat4x4<f32>;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+uniform previousWorld : mat4x4<f32>;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["instancesDeclarationWGSL",0,{name:r,shader:i}])},77785,e=>{"use strict";var t=e.i(12423);let r="clipPlaneVertexDeclaration",i=`#ifdef CLIPPLANE
+uniform vClipPlane: vec4<f32>;varying fClipDistance: f32;
+#endif
+#ifdef CLIPPLANE2
+uniform vClipPlane2: vec4<f32>;varying fClipDistance2: f32;
+#endif
+#ifdef CLIPPLANE3
+uniform vClipPlane3: vec4<f32>;varying fClipDistance3: f32;
+#endif
+#ifdef CLIPPLANE4
+uniform vClipPlane4: vec4<f32>;varying fClipDistance4: f32;
+#endif
+#ifdef CLIPPLANE5
+uniform vClipPlane5: vec4<f32>;varying fClipDistance5: f32;
+#endif
+#ifdef CLIPPLANE6
+uniform vClipPlane6: vec4<f32>;varying fClipDistance6: f32;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["clipPlaneVertexDeclarationWGSL",0,{name:r,shader:i}])},50331,3350,35845,3878,e=>{"use strict";var t=e.i(12423);let r="instancesVertex",i=`#ifdef INSTANCES
+var finalWorld=mat4x4<f32>(vertexInputs.world0,vertexInputs.world1,vertexInputs.world2,vertexInputs.world3);
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+var finalPreviousWorld=mat4x4<f32>(
+vertexInputs.previousWorld0,vertexInputs.previousWorld1,
+vertexInputs.previousWorld2,vertexInputs.previousWorld3);
+#endif
+#ifdef THIN_INSTANCES
+#if !defined(WORLD_UBO)
+finalWorld=uniforms.world*finalWorld;
+#else
+finalWorld=mesh.world*finalWorld;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+finalPreviousWorld=uniforms.previousWorld*finalPreviousWorld;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+var finalWorld=uniforms.world;
+#else
+var finalWorld=mesh.world;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY) || defined(PREPASS_VELOCITY_LINEAR) || defined(VELOCITY_LINEAR)
+var finalPreviousWorld=uniforms.previousWorld;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["instancesVertexWGSL",0,{name:r,shader:i}],50331);let n="bonesVertex",a=`#ifndef BAKED_VERTEX_ANIMATION_TEXTURE
+#if NUM_BONE_INFLUENCERS>0
+var influence : mat4x4<f32>;
+#ifdef BONETEXTURE
+influence=readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndices[0])*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndices[1])*vertexInputs.matricesWeights[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>2
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndices[2])*vertexInputs.matricesWeights[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>3
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndices[3])*vertexInputs.matricesWeights[3];
+#endif 
+#if NUM_BONE_INFLUENCERS>4
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndicesExtra[0])*vertexInputs.matricesWeightsExtra[0];
+#endif 
+#if NUM_BONE_INFLUENCERS>5
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndicesExtra[1])*vertexInputs.matricesWeightsExtra[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>6
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndicesExtra[2])*vertexInputs.matricesWeightsExtra[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>7
+influence=influence+readMatrixFromRawSampler(boneSampler,vertexInputs.matricesIndicesExtra[3])*vertexInputs.matricesWeightsExtra[3];
+#endif 
+#else 
+influence=uniforms.mBones[i32(vertexInputs.matricesIndices[0])]*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndices[1])]*vertexInputs.matricesWeights[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>2
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndices[2])]*vertexInputs.matricesWeights[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>3
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndices[3])]*vertexInputs.matricesWeights[3];
+#endif 
+#if NUM_BONE_INFLUENCERS>4
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndicesExtra[0])]*vertexInputs.matricesWeightsExtra[0];
+#endif 
+#if NUM_BONE_INFLUENCERS>5
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndicesExtra[1])]*vertexInputs.matricesWeightsExtra[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>6
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndicesExtra[2])]*vertexInputs.matricesWeightsExtra[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>7
+influence=influence+uniforms.mBones[i32(vertexInputs.matricesIndicesExtra[3])]*vertexInputs.matricesWeightsExtra[3];
+#endif 
+#endif
+finalWorld=finalWorld*influence;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["bonesVertexWGSL",0,{name:n,shader:a}],3350);let f="bakedVertexAnimation",o=`#ifdef BAKED_VERTEX_ANIMATION_TEXTURE
+{
+#ifdef INSTANCES
+let VATStartFrame: f32=vertexInputs.bakedVertexAnimationSettingsInstanced.x;let VATEndFrame: f32=vertexInputs.bakedVertexAnimationSettingsInstanced.y;let VATOffsetFrame: f32=vertexInputs.bakedVertexAnimationSettingsInstanced.z;let VATSpeed: f32=vertexInputs.bakedVertexAnimationSettingsInstanced.w;
+#else
+let VATStartFrame: f32=uniforms.bakedVertexAnimationSettings.x;let VATEndFrame: f32=uniforms.bakedVertexAnimationSettings.y;let VATOffsetFrame: f32=uniforms.bakedVertexAnimationSettings.z;let VATSpeed: f32=uniforms.bakedVertexAnimationSettings.w;
+#endif
+let totalFrames: f32=VATEndFrame-VATStartFrame+1.0;let time: f32=uniforms.bakedVertexAnimationTime*VATSpeed/totalFrames;let frameCorrection: f32=select(1.0,0.0,time<1.0);let numOfFrames: f32=totalFrames-frameCorrection;var VATFrameNum: f32=fract(time)*numOfFrames;VATFrameNum=(VATFrameNum+VATOffsetFrame) % numOfFrames;VATFrameNum=floor(VATFrameNum);VATFrameNum=VATFrameNum+VATStartFrame+frameCorrection;var VATInfluence : mat4x4<f32>;VATInfluence=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndices[0],VATFrameNum)*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndices[1],VATFrameNum)*vertexInputs.matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndices[2],VATFrameNum)*vertexInputs.matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndices[3],VATFrameNum)*vertexInputs.matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndicesExtra[0],VATFrameNum)*vertexInputs.matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndicesExtra[1],VATFrameNum)*vertexInputs.matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndicesExtra[2],VATFrameNum)*vertexInputs.matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+VATInfluence=VATInfluence+readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,vertexInputs.matricesIndicesExtra[3],VATFrameNum)*vertexInputs.matricesWeightsExtra[3];
+#endif
+finalWorld=finalWorld*VATInfluence;}
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[f]||(t.ShaderStore.IncludesShadersStoreWGSL[f]=o),e.s(["bakedVertexAnimationWGSL",0,{name:f,shader:o}],35845);let s="clipPlaneVertex",d=`#ifdef CLIPPLANE
+vertexOutputs.fClipDistance=dot(worldPos,uniforms.vClipPlane);
+#endif
+#ifdef CLIPPLANE2
+vertexOutputs.fClipDistance2=dot(worldPos,uniforms.vClipPlane2);
+#endif
+#ifdef CLIPPLANE3
+vertexOutputs.fClipDistance3=dot(worldPos,uniforms.vClipPlane3);
+#endif
+#ifdef CLIPPLANE4
+vertexOutputs.fClipDistance4=dot(worldPos,uniforms.vClipPlane4);
+#endif
+#ifdef CLIPPLANE5
+vertexOutputs.fClipDistance5=dot(worldPos,uniforms.vClipPlane5);
+#endif
+#ifdef CLIPPLANE6
+vertexOutputs.fClipDistance6=dot(worldPos,uniforms.vClipPlane6);
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[s]||(t.ShaderStore.IncludesShadersStoreWGSL[s]=d),e.s(["clipPlaneVertexWGSL",0,{name:s,shader:d}],3878)},75234,42893,8154,e=>{"use strict";var t=e.i(12423);let r="fogVertexDeclaration",i=`#ifdef FOG
+varying vFogDistance: vec3f;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["fogVertexDeclarationWGSL",0,{name:r,shader:i}],75234);let n="fogVertex",a=`#ifdef FOG
+#ifdef SCENE_UBO
+vertexOutputs.vFogDistance=(scene.view*worldPos).xyz;
+#else
+vertexOutputs.vFogDistance=(uniforms.view*worldPos).xyz;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["fogVertexWGSL",0,{name:n,shader:a}],42893);let f="vertexColorMixing",o=`#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+vertexOutputs.vColor=vec4f(1.0);
+#ifdef VERTEXCOLOR
+#ifdef VERTEXALPHA
+vertexOutputs.vColor*=colorUpdated;
+#else
+vertexOutputs.vColor=vec4f(vertexOutputs.vColor.rgb*colorUpdated.rgb,vertexOutputs.vColor.a);
+#endif
+#endif
+#ifdef INSTANCESCOLOR
+vertexOutputs.vColor*=vertexInputs.instanceColor;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[f]||(t.ShaderStore.IncludesShadersStoreWGSL[f]=o),e.s(["vertexColorMixingWGSL",0,{name:f,shader:o}],8154)},89340,5122,49853,62077,e=>{"use strict";var t=e.i(12423);let r="morphTargetsVertexGlobalDeclaration",i=`#ifdef MORPHTARGETS
+uniform morphTargetInfluences : array<f32,NUM_MORPH_INFLUENCERS>;
+#ifdef MORPHTARGETS_TEXTURE 
+uniform morphTargetTextureIndices : array<f32,NUM_MORPH_INFLUENCERS>;uniform morphTargetTextureInfo : vec3<f32>;var morphTargets : texture_2d_array<f32>;fn readVector3FromRawSampler(targetIndex : i32,vertexIndex : f32)->vec3<f32>
+{ 
+let textureWidth: i32=i32(uniforms.morphTargetTextureInfo.y);let y: i32=i32(vertexIndex)/textureWidth;let x: i32=i32(vertexIndex) % textureWidth;return textureLoad(morphTargets,vec2i(x,y),i32(uniforms.morphTargetTextureIndices[targetIndex]),0).xyz;}
+fn readVector4FromRawSampler(targetIndex : i32,vertexIndex : f32)->vec4<f32>
+{ 
+let textureWidth: i32=i32(uniforms.morphTargetTextureInfo.y); 
+let y: i32=i32(vertexIndex)/textureWidth;let x: i32=i32(vertexIndex) % textureWidth;return textureLoad(morphTargets,vec2i(x,y),i32(uniforms.morphTargetTextureIndices[targetIndex]),0);}
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["morphTargetsVertexGlobalDeclarationWGSL",0,{name:r,shader:i}],89340);let n="morphTargetsVertexDeclaration",a=`#ifdef MORPHTARGETS
+#ifndef MORPHTARGETS_TEXTURE
+#ifdef MORPHTARGETS_POSITION
+attribute position{X} : vec3<f32>;
+#endif
+#ifdef MORPHTARGETS_NORMAL
+attribute normal{X} : vec3<f32>;
+#endif
+#ifdef MORPHTARGETS_TANGENT
+attribute tangent{X} : vec3<f32>;
+#endif
+#ifdef MORPHTARGETS_UV
+attribute uv_{X} : vec2<f32>;
+#endif
+#ifdef MORPHTARGETS_UV2
+attribute uv2_{X} : vec2<f32>;
+#endif
+#ifdef MORPHTARGETS_COLOR
+attribute color{X} : vec4<f32>;
+#endif
+#elif {X}==0
+uniform morphTargetCount: f32;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["morphTargetsVertexDeclarationWGSL",0,{name:n,shader:a}],5122);let f="morphTargetsVertexGlobal",o=`#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE
+var vertexID : f32;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[f]||(t.ShaderStore.IncludesShadersStoreWGSL[f]=o),e.s(["morphTargetsVertexGlobalWGSL",0,{name:f,shader:o}],49853);let s="morphTargetsVertex",d=`#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE
+#if {X}==0
+for (var i=0; i<NUM_MORPH_INFLUENCERS; i=i+1) {if (f32(i)>=uniforms.morphTargetCount) {break;}
+#ifdef USE_VERTEX_PULLING
+vertexID=f32(vpVertexIndex)*uniforms.morphTargetTextureInfo.x;
+#else
+vertexID=f32(vertexInputs.vertexIndex)*uniforms.morphTargetTextureInfo.x;
+#endif
+#ifdef MORPHTARGETS_POSITION
+#ifdef USE_VERTEX_PULLING
+positionUpdated=positionUpdated+(readVector3FromRawSampler(i,vertexID)-vp_basePosition)*uniforms.morphTargetInfluences[i];
+#else
+positionUpdated=positionUpdated+(readVector3FromRawSampler(i,vertexID)-vertexInputs.position)*uniforms.morphTargetInfluences[i];
+#endif
+#endif
+#ifdef MORPHTARGETTEXTURE_HASPOSITIONS
+vertexID=vertexID+1.0;
+#endif
+#ifdef MORPHTARGETS_NORMAL
+#ifdef USE_VERTEX_PULLING
+normalUpdated=normalUpdated+(readVector3FromRawSampler(i,vertexID) -vp_baseNormal)*uniforms.morphTargetInfluences[i];
+#else
+normalUpdated=normalUpdated+(readVector3FromRawSampler(i,vertexID) -vertexInputs.normal)*uniforms.morphTargetInfluences[i];
+#endif
+#endif
+#ifdef MORPHTARGETTEXTURE_HASNORMALS
+vertexID=vertexID+1.0;
+#endif
+#ifdef MORPHTARGETS_UV
+#ifdef USE_VERTEX_PULLING
+uvUpdated=uvUpdated+(readVector3FromRawSampler(i,vertexID).xy-vp_baseUV)*uniforms.morphTargetInfluences[i];
+#else
+uvUpdated=uvUpdated+(readVector3FromRawSampler(i,vertexID).xy-vertexInputs.uv)*uniforms.morphTargetInfluences[i];
+#endif
+#endif
+#ifdef MORPHTARGETTEXTURE_HASUVS
+vertexID=vertexID+1.0;
+#endif
+#ifdef MORPHTARGETS_TANGENT
+#ifdef USE_VERTEX_PULLING
+tangentUpdated=vec4f(tangentUpdated.xyz+(readVector3FromRawSampler(i,vertexID) -vp_baseTangent.xyz)*uniforms.morphTargetInfluences[i],tangentUpdated.a);
+#else
+tangentUpdated=vec4f(tangentUpdated.xyz+(readVector3FromRawSampler(i,vertexID) -vertexInputs.tangent.xyz)*uniforms.morphTargetInfluences[i],tangentUpdated.a);
+#endif
+#endif
+#ifdef MORPHTARGETTEXTURE_HASTANGENTS
+vertexID=vertexID+1.0;
+#endif
+#ifdef MORPHTARGETS_UV2
+#ifdef USE_VERTEX_PULLING
+uv2Updated=uv2Updated+(readVector3FromRawSampler(i,vertexID).xy-vp_baseUV2)*uniforms.morphTargetInfluences[i];
+#else
+uv2Updated=uv2Updated+(readVector3FromRawSampler(i,vertexID).xy-vertexInputs.uv2)*uniforms.morphTargetInfluences[i];
+#endif
+#endif
+#ifdef MORPHTARGETS_COLOR
+#ifdef USE_VERTEX_PULLING
+colorUpdated=colorUpdated+(readVector4FromRawSampler(i,vertexID)-vp_baseColor)*uniforms.morphTargetInfluences[i];
+#else
+colorUpdated=colorUpdated+(readVector4FromRawSampler(i,vertexID)-vertexInputs.color)*uniforms.morphTargetInfluences[i];
+#endif
+#endif
+}
+#endif
+#else
+#ifdef MORPHTARGETS_POSITION
+#ifdef USE_VERTEX_PULLING
+positionUpdated=positionUpdated+(vertexInputs.position{X}-vp_basePosition)*uniforms.morphTargetInfluences[{X}];
+#else
+positionUpdated=positionUpdated+(vertexInputs.position{X}-vertexInputs.position)*uniforms.morphTargetInfluences[{X}];
+#endif
+#endif
+#ifdef MORPHTARGETS_NORMAL
+#ifdef USE_VERTEX_PULLING
+normalUpdated=normalUpdated+(vertexInputs.normal{X}-vp_baseNormal)*uniforms.morphTargetInfluences[{X}];
+#else
+normalUpdated=normalUpdated+(vertexInputs.normal{X}-vertexInputs.normal)*uniforms.morphTargetInfluences[{X}];
+#endif
+#endif
+#ifdef MORPHTARGETS_TANGENT
+#ifdef USE_VERTEX_PULLING
+tangentUpdated=vec4f(tangentUpdated.xyz+(vertexInputs.tangent{X}-vp_baseTangent.xyz)*uniforms.morphTargetInfluences[{X}],tangentUpdated.a);
+#else
+tangentUpdated=vec4f(tangentUpdated.xyz+(vertexInputs.tangent{X}-vertexInputs.tangent.xyz)*uniforms.morphTargetInfluences[{X}],tangentUpdated.a);
+#endif
+#endif
+#ifdef MORPHTARGETS_UV
+#ifdef USE_VERTEX_PULLING
+uvUpdated=uvUpdated+(vertexInputs.uv_{X}-vp_baseUV)*uniforms.morphTargetInfluences[{X}];
+#else
+uvUpdated=uvUpdated+(vertexInputs.uv_{X}-vertexInputs.uv)*uniforms.morphTargetInfluences[{X}];
+#endif
+#endif
+#ifdef MORPHTARGETS_UV2
+#ifdef USE_VERTEX_PULLING
+uv2Updated=uv2Updated+(vertexInputs.uv2_{X}-vp_baseUV2)*uniforms.morphTargetInfluences[{X}];
+#else
+uv2Updated=uv2Updated+(vertexInputs.uv2_{X}-vertexInputs.uv2)*uniforms.morphTargetInfluences[{X}];
+#endif
+#endif
+#ifdef MORPHTARGETS_COLOR
+#ifdef USE_VERTEX_PULLING
+colorUpdated=colorUpdated+(vertexInputs.color{X}-vp_baseColor)*uniforms.morphTargetInfluences[{X}];
+#else
+colorUpdated=colorUpdated+(vertexInputs.color{X}-vertexInputs.color)*uniforms.morphTargetInfluences[{X}];
+#endif
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[s]||(t.ShaderStore.IncludesShadersStoreWGSL[s]=d),e.s(["morphTargetsVertexWGSL",0,{name:s,shader:d}],62077)},71822,39359,19376,90742,45012,20958,80255,25716,86752,6275,47167,e=>{"use strict";var t=e.i(12423);let r="uvAttributeDeclaration",i=`#if defined(UV{X}) && !defined(USE_VERTEX_PULLING)
+attribute uv{X}: vec2f;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["uvAttributeDeclarationWGSL",0,{name:r,shader:i}],71822);let n="prePassVertexDeclaration",a=`#ifdef PREPASS
+#ifdef PREPASS_LOCAL_POSITION
+varying vPosition : vec3f;
+#endif
+#ifdef PREPASS_DEPTH
+varying vViewPos: vec3f;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+varying vNormViewDepth: f32;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)
+uniform previousViewProjection: mat4x4f;varying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[n]||(t.ShaderStore.IncludesShadersStoreWGSL[n]=a),e.s(["prePassVertexDeclarationWGSL",0,{name:n,shader:a}],39359);let f="samplerVertexDeclaration",o=`#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+varying v_VARYINGNAME_UV: vec2f;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[f]||(t.ShaderStore.IncludesShadersStoreWGSL[f]=o),e.s(["samplerVertexDeclarationWGSL",0,{name:f,shader:o}],19376);let s="lightVxUboDeclaration",d=`#ifdef LIGHT{X}
+struct Light{X}
+{vLightData: vec4f,
+vLightDiffuse: vec4f,
+vLightSpecular: vec4f,
+#ifdef SPOTLIGHT{X}
+vLightDirection: vec4f,
+vLightFalloff: vec4f,
+#elif defined(POINTLIGHT{X})
+vLightFalloff: vec4f,
+#elif defined(HEMILIGHT{X})
+vLightGround: vec3f,
+#elif defined(CLUSTLIGHT{X})
+vSliceData: vec2f,
+vSliceRanges: array<vec4f,CLUSTLIGHT_SLICES>,
+#endif
+#if defined(AREALIGHT{X}) && defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+vLightWidth: vec4f,
+vLightHeight: vec4f,
+#endif
+shadowsInfo: vec4f,
+depthValues: vec2f} ;var<uniform> light{X} : Light{X};
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform lightMatrix{X}: array<mat4x4f,SHADOWCSMNUM_CASCADES{X}>;varying vPositionFromLight{X}_0: vec4f;varying vDepthMetric{X}_0: f32;varying vPositionFromLight{X}_1: vec4f;varying vDepthMetric{X}_1: f32;varying vPositionFromLight{X}_2: vec4f;varying vDepthMetric{X}_2: f32;varying vPositionFromLight{X}_3: vec4f;varying vDepthMetric{X}_3: f32;varying vPositionFromCamera{X}: vec4f;
+#elif defined(SHADOWCUBE{X})
+#else
+varying vPositionFromLight{X}: vec4f;varying vDepthMetric{X}: f32;uniform lightMatrix{X}: mat4x4f;
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[s]||(t.ShaderStore.IncludesShadersStoreWGSL[s]=d),e.s(["lightVxUboDeclarationWGSL",0,{name:s,shader:d}],90742);let l="vertexPullingDeclaration",c=`#ifdef USE_VERTEX_PULLING
+#ifdef VERTEX_PULLING_USE_INDEX_BUFFER
+var<storage,read> indices : array<u32>;
+#endif
+var<storage,read> position : array<f32>;uniform vp_position_info : vec4f;
+#ifdef NORMAL
+var<storage,read> normal : array<f32>;uniform vp_normal_info : vec4f;
+#endif
+#ifdef TANGENT
+var<storage,read> tangent : array<f32>;uniform vp_tangent_info : vec4f;
+#endif
+#ifdef UV1
+var<storage,read> uv : array<f32>;uniform vp_uv_info : vec4f;
+#define VP_UV1_SUPPORTED
+#endif
+#ifdef UV2
+var<storage,read> uv2 : array<f32>;uniform vp_uv2_info : vec4f;
+#define VP_UV2_SUPPORTED
+#endif
+#ifdef UV3
+var<storage,read> uv3 : array<f32>;uniform vp_uv3_info : vec4f;
+#define VP_UV3_SUPPORTED
+#endif
+#ifdef UV4
+var<storage,read> uv4 : array<f32>;uniform vp_uv4_info : vec4f;
+#define VP_UV4_SUPPORTED
+#endif
+#ifdef UV5
+var<storage,read> uv5 : array<f32>;uniform vp_uv5_info : vec4f;
+#define VP_UV5_SUPPORTED
+#endif
+#ifdef UV6
+var<storage,read> uv6 : array<f32>;uniform vp_uv6_info : vec4f;
+#define VP_UV6_SUPPORTED
+#endif
+#ifdef VERTEXCOLOR
+var<storage,read> color : array<f32>;uniform vp_color_info : vec4f;
+#endif
+#if NUM_BONE_INFLUENCERS>0
+var<storage,read> matricesIndices : array<u32>;var<storage,read> matricesWeights : array<f32>;uniform vp_matricesIndices_info : vec4f;uniform vp_matricesWeights_info : vec4f;
+#if NUM_BONE_INFLUENCERS>4
+var<storage,read> matricesIndicesExtra : array<u32>;var<storage,read> matricesWeightsExtra : array<f32>;uniform vp_matricesIndicesExtra_info : vec4f;uniform vp_matricesWeightsExtra_info : vec4f;
+#endif
+#endif
+fn vp_convertToFloat(word : u32,byteInWord : u32,dataType : u32,normalized : bool)->f32 {switch (dataType) {case 5120u: { 
+let shift=byteInWord*8u;let value=(word>>shift) & 0xFFu;let signedValue=f32(i32(value<<24u)>>24u);if (normalized) { return signedValue/127.0; }
+return signedValue;}
+case 5121u: { 
+let shift=byteInWord*8u;let value=(word>>shift) & 0xFFu;if (normalized) { return f32(value)/255.0; }
+return f32(value);}
+case 5122u: { 
+let shift=(byteInWord & 0xFFFFFFFEu)*8u;let value=(word>>shift) & 0xFFFFu;let signedValue=f32(i32(value<<16u)>>16u);if (normalized) { return signedValue/32767.0; }
+return signedValue;}
+case 5123u: { 
+let shift=(byteInWord & 0xFFFFFFFEu)*8u;let value=(word>>shift) & 0xFFFFu;if (normalized) { return f32(value)/65535.0; }
+return f32(value);}
+case 5126u: { 
+return bitcast<f32>(word);}
+default: { return 0.0; }}}
+fn vp_componentSize(dataType : u32)->u32 {return select(select(2u,1u,dataType==5120u || dataType==5121u),4u,dataType==5126u);}
+fn vp_readVertexIndex(index : u32)->u32 {
+#ifndef VERTEX_PULLING_USE_INDEX_BUFFER
+return index;
+#else
+#ifdef VERTEX_PULLING_INDEX_BUFFER_32BITS
+return indices[index];
+#else
+let u32_index=index/2u;let bit_offset=(index & 1u)*16u;return (indices[u32_index]>>bit_offset) & 0xFFFFu;
+#endif
+#endif
+}
+fn vp_readPositionValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(position[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readPosition(info : vec4f,vertexIndex : u32)->vec3f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec3f(
+vp_readPositionValue(offset,dataType,normalized),
+vp_readPositionValue(offset+cs,dataType,normalized),
+vp_readPositionValue(offset+cs*2u,dataType,normalized)
+);}
+#ifdef NORMAL
+fn vp_readNormalValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(normal[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readNormal(info : vec4f,vertexIndex : u32)->vec3f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec3f(
+vp_readNormalValue(offset,dataType,normalized),
+vp_readNormalValue(offset+cs,dataType,normalized),
+vp_readNormalValue(offset+cs*2u,dataType,normalized)
+);}
+#endif
+#ifdef TANGENT
+fn vp_readTangentValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(tangent[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readTangent(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readTangentValue(offset,dataType,normalized),
+vp_readTangentValue(offset+cs,dataType,normalized),
+vp_readTangentValue(offset+cs*2u,dataType,normalized),
+vp_readTangentValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#ifdef UV1
+fn vp_readUVValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUVValue(offset,dataType,normalized),
+vp_readUVValue(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV2
+fn vp_readUV2Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv2[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV2(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV2Value(offset,dataType,normalized),
+vp_readUV2Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV3
+fn vp_readUV3Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv3[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV3(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV3Value(offset,dataType,normalized),
+vp_readUV3Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV4
+fn vp_readUV4Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv4[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV4(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV4Value(offset,dataType,normalized),
+vp_readUV4Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV5
+fn vp_readUV5Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv5[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV5(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV5Value(offset,dataType,normalized),
+vp_readUV5Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV6
+fn vp_readUV6Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv6[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV6(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV6Value(offset,dataType,normalized),
+vp_readUV6Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef VERTEXCOLOR
+fn vp_readColorValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(color[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readColor(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readColorValue(offset,dataType,normalized),
+vp_readColorValue(offset+cs,dataType,normalized),
+vp_readColorValue(offset+cs*2u,dataType,normalized),
+vp_readColorValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#if NUM_BONE_INFLUENCERS>0
+fn vp_readMatrixIndexValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(matricesIndices[byteOffset/4u],byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneIndices(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixIndexValue(offset,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs*3u,dataType,normalized)
+);}
+fn vp_readMatrixWeightValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(matricesWeights[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneWeights(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixWeightValue(offset,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs*3u,dataType,normalized)
+);}
+#if NUM_BONE_INFLUENCERS>4
+fn vp_readMatrixIndexExtraValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(matricesIndicesExtra[byteOffset/4u],byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneIndicesExtra(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixIndexExtraValue(offset,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs*3u,dataType,normalized)
+);}
+fn vp_readMatrixWeightExtraValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(matricesWeightsExtra[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneWeightsExtra(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixWeightExtraValue(offset,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[l]||(t.ShaderStore.IncludesShadersStoreWGSL[l]=c),e.s(["vertexPullingDeclarationWGSL",0,{name:l,shader:c}],45012);let u="vertexPullingVertex",v=`#ifdef USE_VERTEX_PULLING
+let vpVertexIndex: u32=vp_readVertexIndex(vertexInputs.vertexIndex);positionUpdated=vp_readPosition(uniforms.vp_position_info,vpVertexIndex);
+#ifdef NORMAL
+normalUpdated=vp_readNormal(uniforms.vp_normal_info,vpVertexIndex);
+#endif
+#ifdef TANGENT
+tangentUpdated=vp_readTangent(uniforms.vp_tangent_info,vpVertexIndex);
+#endif
+#ifdef UV1
+uvUpdated=vp_readUV(uniforms.vp_uv_info,vpVertexIndex);
+#endif
+#ifdef UV2
+uv2Updated=vp_readUV2(uniforms.vp_uv2_info,vpVertexIndex);
+#endif
+#ifdef UV3
+var uv3Updated: vec2f=vp_readUV3(uniforms.vp_uv3_info,vpVertexIndex);
+#endif
+#ifdef UV4
+var uv4Updated: vec2f=vp_readUV4(uniforms.vp_uv4_info,vpVertexIndex);
+#endif
+#ifdef UV5
+var uv5Updated: vec2f=vp_readUV5(uniforms.vp_uv5_info,vpVertexIndex);
+#endif
+#ifdef UV6
+var uv6Updated: vec2f=vp_readUV6(uniforms.vp_uv6_info,vpVertexIndex);
+#endif
+#ifdef VERTEXCOLOR
+colorUpdated=vp_readColor(uniforms.vp_color_info,vpVertexIndex);
+#endif
+#ifdef MORPHTARGETS
+let vp_basePosition: vec3f=positionUpdated;
+#ifdef NORMAL
+let vp_baseNormal: vec3f=normalUpdated;
+#endif
+#ifdef TANGENT
+let vp_baseTangent: vec4f=tangentUpdated;
+#endif
+#ifdef UV1
+let vp_baseUV: vec2f=uvUpdated;
+#endif
+#ifdef UV2
+let vp_baseUV2: vec2f=uv2Updated;
+#endif
+#ifdef VERTEXCOLOR
+let vp_baseColor: vec4f=colorUpdated;
+#endif
+#endif
+#if NUM_BONE_INFLUENCERS>0
+var vp_matricesIndices: vec4f=vp_readBoneIndices(uniforms.vp_matricesIndices_info,vpVertexIndex);var vp_matricesWeights: vec4f=vp_readBoneWeights(uniforms.vp_matricesWeights_info,vpVertexIndex);
+#if NUM_BONE_INFLUENCERS>4
+var vp_matricesIndicesExtra: vec4f=vp_readBoneIndicesExtra(uniforms.vp_matricesIndicesExtra_info,vpVertexIndex);var vp_matricesWeightsExtra: vec4f=vp_readBoneWeightsExtra(uniforms.vp_matricesWeightsExtra_info,vpVertexIndex);
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[u]||(t.ShaderStore.IncludesShadersStoreWGSL[u]=v),e.s(["vertexPullingVertexWGSL",0,{name:u,shader:v}],20958);let m="prePassVertex",p=`#ifdef PREPASS_DEPTH
+vertexOutputs.vViewPos=(scene.view*worldPos).rgb;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+vertexOutputs.vNormViewDepth=((scene.view*worldPos).z-uniforms.cameraInfo.x)/(uniforms.cameraInfo.y-uniforms.cameraInfo.x);
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+vertexOutputs.vPosition=positionUpdated.xyz;
+#endif
+#if (defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)) && defined(BONES_VELOCITY_ENABLED)
+vertexOutputs.vCurrentPosition=scene.viewProjection*worldPos;
+#if NUM_BONE_INFLUENCERS>0
+var previousInfluence: mat4x4f;previousInfluence=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[0])]*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[1])]*vertexInputs.matricesWeights[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[2])]*vertexInputs.matricesWeights[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[3])]*vertexInputs.matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[0])]*vertexInputs.matricesWeightsExtra[0];
+#endif 
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[1])]*vertexInputs.matricesWeightsExtra[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[2])]*vertexInputs.matricesWeightsExtra[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[3])]*vertexInputs.matricesWeightsExtra[3];
+#endif
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld*previousInfluence* vec4f(positionUpdated,1.0);
+#else
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld* vec4f(positionUpdated,1.0);
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[m]||(t.ShaderStore.IncludesShadersStoreWGSL[m]=p),e.s(["prePassVertexWGSL",0,{name:m,shader:p}],80255);let E="uvVariableDeclaration",_=`#ifdef MAINUV{X}
+#if !defined(UV{X})
+var uv{X}: vec2f=vec2f(0.,0.);
+#elif defined(USE_VERTEX_PULLING)
+var uv{X}: vec2f=uv{X}Updated;
+#else
+var uv{X}: vec2f=vertexInputs.uv{X};
+#endif
+vertexOutputs.vMainUV{X}=uv{X};
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[E]||(t.ShaderStore.IncludesShadersStoreWGSL[E]=_),e.s(["uvVariableDeclarationWGSL",0,{name:E,shader:_}],25716);let I="samplerVertexImplementation",S=`#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+if (uniforms.v_INFONAME_==0.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(uvUpdated,1.0,0.0)).xy;}
+#ifdef UV2
+else if (uniforms.v_INFONAME_==1.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(uv2Updated,1.0,0.0)).xy;}
+#endif
+#ifdef UV3
+else if (uniforms.v_INFONAME_==2.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv3,1.0,0.0)).xy;}
+#endif
+#ifdef UV4
+else if (uniforms.v_INFONAME_==3.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv4,1.0,0.0)).xy;}
+#endif
+#ifdef UV5
+else if (uniforms.v_INFONAME_==4.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv5,1.0,0.0)).xy;}
+#endif
+#ifdef UV6
+else if (uniforms.v_INFONAME_==5.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv6,1.0,0.0)).xy;}
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[I]||(t.ShaderStore.IncludesShadersStoreWGSL[I]=S),e.s(["samplerVertexImplementationWGSL",0,{name:I,shader:S}],86752);let x="shadowsVertex",N=`#ifdef SHADOWS
+#if defined(SHADOWCSM{X})
+#ifdef SCENE_UBO
+vertexOutputs.vPositionFromCamera{X}=scene.view*worldPos;
+#else
+vertexOutputs.vPositionFromCamera{X}=uniforms.view*worldPos;
+#endif
+#if SHADOWCSMNUM_CASCADES{X}>0
+vertexOutputs.vPositionFromLight{X}_0=uniforms.lightMatrix{X}[0]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_0=(-vertexOutputs.vPositionFromLight{X}_0.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_0= (vertexOutputs.vPositionFromLight{X}_0.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif
+#if SHADOWCSMNUM_CASCADES{X}>1
+vertexOutputs.vPositionFromLight{X}_1=uniforms.lightMatrix{X}[1]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_1=(-vertexOutputs.vPositionFromLight{X}_1.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_1= (vertexOutputs.vPositionFromLight{X}_1.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#if SHADOWCSMNUM_CASCADES{X}>2
+vertexOutputs.vPositionFromLight{X}_2=uniforms.lightMatrix{X}[2]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_2=(-vertexOutputs.vPositionFromLight{X}_2.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_2= (vertexOutputs.vPositionFromLight{X}_2.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#if SHADOWCSMNUM_CASCADES{X}>3
+vertexOutputs.vPositionFromLight{X}_3=uniforms.lightMatrix{X}[3]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_3=(-vertexOutputs.vPositionFromLight{X}_3.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_3= (vertexOutputs.vPositionFromLight{X}_3.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#elif defined(SHADOW{X}) && !defined(SHADOWCUBE{X})
+vertexOutputs.vPositionFromLight{X}=uniforms.lightMatrix{X}*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}=(-vertexOutputs.vPositionFromLight{X}.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}=(vertexOutputs.vPositionFromLight{X}.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[x]||(t.ShaderStore.IncludesShadersStoreWGSL[x]=N),e.s(["shadowsVertexWGSL",0,{name:x,shader:N}],6275);let T="logDepthVertex",A=`#ifdef LOGARITHMICDEPTH
+vertexOutputs.vFragmentDepth=1.0+vertexOutputs.position.w;vertexOutputs.position.z=log2(max(0.000001,vertexOutputs.vFragmentDepth))*uniforms.logarithmicDepthConstant;
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[T]||(t.ShaderStore.IncludesShadersStoreWGSL[T]=A),e.s(["logDepthVertexWGSL",0,{name:T,shader:A}],47167)},40664,e=>{"use strict";var t=e.i(12423);e.i(60106),e.i(50008);let r="openpbrUboDeclaration",i=`uniform vTangentSpaceParams: vec2f;uniform vLightingIntensity: vec4f;uniform pointSize: f32;uniform vDebugMode: vec2f;uniform renderTargetSize: vec2f;uniform cameraInfo: vec4f;uniform vTextureRepetitionHexTilingParams: vec4f;uniform backgroundRefractionMatrix: mat4x4f;uniform vBackgroundRefractionInfos: vec3f;uniform vReflectionInfos: vec2f;uniform reflectionMatrix: mat4x4f;uniform vReflectionMicrosurfaceInfos: vec3f;uniform vReflectionPosition: vec3f;uniform vReflectionSize: vec3f;uniform vReflectionFilteringInfo: vec2f;uniform vReflectionDominantDirection: vec3f;uniform vReflectionColor: vec3f;uniform vSphericalL00: vec3f;uniform vSphericalL1_1: vec3f;uniform vSphericalL10: vec3f;uniform vSphericalL11: vec3f;uniform vSphericalL2_2: vec3f;uniform vSphericalL2_1: vec3f;uniform vSphericalL20: vec3f;uniform vSphericalL21: vec3f;uniform vSphericalL22: vec3f;uniform vSphericalX: vec3f;uniform vSphericalY: vec3f;uniform vSphericalZ: vec3f;uniform vSphericalXX_ZZ: vec3f;uniform vSphericalYY_ZZ: vec3f;uniform vSphericalZZ: vec3f;uniform vSphericalXY: vec3f;uniform vSphericalYZ: vec3f;uniform vSphericalZX: vec3f;uniform vBaseWeight: f32;uniform vBaseColor: vec4f;uniform vBaseDiffuseRoughness: f32;uniform vReflectanceInfo: vec4f;uniform vSpecularColor: vec4f;uniform vSpecularAnisotropy: vec3f;uniform vTransmissionWeight : f32;uniform vTransmissionColor : vec3f;uniform vTransmissionDepth : f32;uniform vTransmissionScatter : vec3f;uniform vTransmissionScatterAnisotropy : f32;uniform vTransmissionDispersionScale : f32;uniform vTransmissionDispersionAbbeNumber : f32;uniform vSubsurfaceWeight: f32;uniform vSubsurfaceColor: vec3f;uniform vSubsurfaceRadius: f32;uniform vSubsurfaceRadiusScale: vec3f;uniform vSubsurfaceScatterAnisotropy: f32;uniform vCoatWeight: f32;uniform vCoatColor: vec3f;uniform vCoatRoughness: f32;uniform vCoatRoughnessAnisotropy: f32;uniform vCoatIor: f32;uniform vCoatDarkening : f32;uniform vFuzzWeight: f32;uniform vFuzzColor: vec3f;uniform vFuzzRoughness: f32;uniform vGeometryThinWalled: f32;uniform vGeometryCoatTangent: vec2f;uniform vGeometryThickness: f32;uniform vEmissionColor: vec3f;uniform vThinFilmWeight: f32;uniform vThinFilmThickness: vec2f;uniform vThinFilmIor: f32;uniform vBaseWeightInfos: vec2f;uniform baseWeightMatrix: mat4x4f;uniform vBaseColorInfos: vec2f;uniform baseColorMatrix: mat4x4f;uniform vBaseDiffuseRoughnessInfos: vec2f;uniform baseDiffuseRoughnessMatrix: mat4x4f;uniform vBaseMetalnessInfos: vec2f;uniform baseMetalnessMatrix: mat4x4f;uniform vSpecularWeightInfos: vec2f;uniform specularWeightMatrix: mat4x4f;uniform vSpecularColorInfos: vec2f;uniform specularColorMatrix: mat4x4f;uniform vSpecularRoughnessInfos: vec2f;uniform specularRoughnessMatrix: mat4x4f;uniform vSpecularRoughnessAnisotropyInfos: vec2f;uniform specularRoughnessAnisotropyMatrix: mat4x4f;uniform vTransmissionWeightInfos : vec2f;uniform transmissionWeightMatrix : mat4x4f;uniform vTransmissionColorInfos : vec2f;uniform transmissionColorMatrix : mat4x4f;uniform vTransmissionDepthInfos : vec2f;uniform transmissionDepthMatrix : mat4x4f;uniform vTransmissionScatterInfos : vec2f;uniform transmissionScatterMatrix : mat4x4f;uniform vTransmissionDispersionScaleInfos : vec2f;uniform transmissionDispersionScaleMatrix : mat4x4f;uniform vSubsurfaceWeightInfos: vec2f;uniform subsurfaceWeightMatrix: mat4x4f;uniform vSubsurfaceColorInfos: vec2f;uniform subsurfaceColorMatrix: mat4x4f;uniform vSubsurfaceRadiusScaleInfos: vec2f;uniform subsurfaceRadiusScaleMatrix: mat4x4f;uniform vCoatWeightInfos: vec2f;uniform coatWeightMatrix: mat4x4f;uniform vCoatColorInfos: vec2f;uniform coatColorMatrix: mat4x4f;uniform vCoatRoughnessInfos: vec2f;uniform coatRoughnessMatrix: mat4x4f;uniform vCoatRoughnessAnisotropyInfos: vec2f;uniform coatRoughnessAnisotropyMatrix: mat4x4f;uniform vCoatDarkeningInfos : vec2f;uniform coatDarkeningMatrix : mat4x4f;uniform vFuzzWeightInfos: vec2f;uniform fuzzWeightMatrix: mat4x4f;uniform vFuzzColorInfos: vec2f;uniform fuzzColorMatrix: mat4x4f;uniform vFuzzRoughnessInfos: vec2f;uniform fuzzRoughnessMatrix: mat4x4f;uniform vGeometryNormalInfos: vec2f;uniform geometryNormalMatrix: mat4x4f;uniform vGeometryTangentInfos: vec2f;uniform geometryTangentMatrix: mat4x4f;uniform vGeometryCoatNormalInfos: vec2f;uniform geometryCoatNormalMatrix: mat4x4f;uniform vGeometryCoatTangentInfos: vec2f;uniform geometryCoatTangentMatrix: mat4x4f;uniform vGeometryOpacityInfos: vec2f;uniform geometryOpacityMatrix: mat4x4f;uniform vGeometryThicknessInfos: vec2f;uniform geometryThicknessMatrix: mat4x4f;uniform vEmissionColorInfos: vec2f;uniform emissionColorMatrix: mat4x4f;uniform vThinFilmWeightInfos: vec2f;uniform thinFilmWeightMatrix: mat4x4f;uniform vThinFilmThicknessInfos: vec2f;uniform thinFilmThicknessMatrix: mat4x4f;uniform vAmbientOcclusionInfos: vec2f;uniform ambientOcclusionMatrix: mat4x4f;
+#define ADDITIONAL_UBO_DECLARATION
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;t.ShaderStore.IncludesShadersStoreWGSL[r]||(t.ShaderStore.IncludesShadersStoreWGSL[r]=i),e.s(["openpbrUboDeclarationWGSL",0,{name:r,shader:i}])},51455,e=>{"use strict";var t=e.i(12423),r=e.i(60106),i=e.i(50008),n=e.i(40664),a=e.i(71822),f=e.i(39780),o=e.i(4357),s=e.i(61202),d=e.i(45329),l=e.i(35011),c=e.i(18062),u=e.i(39359),v=e.i(19376),m=e.i(99452);let p="openpbrNormalMapVertexDeclaration",E=`#if defined(GEOMETRY_NORMAL) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(FUZZ)
+#if defined(TANGENT) && defined(NORMAL) 
+varying vTBN0: vec3f;varying vTBN1: vec3f;varying vTBN2: vec3f;
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[p]||(t.ShaderStore.IncludesShadersStoreWGSL[p]=E);var _=e.i(77785),I=e.i(75234),S=e.i(90742),x=e.i(89340),N=e.i(5122),T=e.i(54758),A=e.i(45012),R=e.i(20958),h=e.i(49853),V=e.i(62077),O=e.i(50331),M=e.i(3350),L=e.i(35845),g=e.i(80255),F=e.i(25716),U=e.i(86752);let C="openpbrNormalMapVertex",G=`#if defined(GEOMETRY_NORMAL) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(FUZZ)
+#if defined(TANGENT) && defined(NORMAL)
+var tbnNormal: vec3f=normalize(normalUpdated);var tbnTangent: vec3f=normalize(tangentUpdated.xyz);var tbnBitangent: vec3f=cross(tbnNormal,tbnTangent)*tangentUpdated.w;var matTemp= mat3x3f(finalWorld[0].xyz,finalWorld[1].xyz,finalWorld[2].xyz)* mat3x3f(tbnTangent,tbnBitangent,tbnNormal);vertexOutputs.vTBN0=matTemp[0];vertexOutputs.vTBN1=matTemp[1];vertexOutputs.vTBN2=matTemp[2];
+#endif
+#endif
+`;t.ShaderStore.IncludesShadersStoreWGSL[C]||(t.ShaderStore.IncludesShadersStoreWGSL[C]=G);var D=e.i(3878),P=e.i(42893),b=e.i(6275),y=e.i(8154),W=e.i(47167);let X="openpbrVertexShader",z=`#define OPENPBR_VERTEX_SHADER
+#include<openpbrUboDeclaration>
+#define CUSTOM_VERTEX_BEGIN
+#ifndef USE_VERTEX_PULLING
+attribute position: vec3f;
+#ifdef NORMAL
+attribute normal: vec3f;
+#endif
+#ifdef TANGENT
+attribute tangent: vec4f;
+#endif
+#ifdef UV1
+attribute uv: vec2f;
+#endif
+#include<uvAttributeDeclaration>[2..7]
+#ifdef VERTEXCOLOR
+attribute color: vec4f;
+#endif
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#include<helperFunctions>
+#include<pbrBRDFFunctions>
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<instancesDeclaration>
+#include<prePassVertexDeclaration>
+#include<samplerVertexDeclaration>(_DEFINENAME_,BASE_COLOR,_VARYINGNAME_,BaseColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,BASE_WEIGHT,_VARYINGNAME_,BaseWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,BASE_DIFFUSE_ROUGHNESS,_VARYINGNAME_,BaseDiffuseRoughness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,BASE_METALNESS,_VARYINGNAME_,BaseMetalness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR_WEIGHT,_VARYINGNAME_,SpecularWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR_COLOR,_VARYINGNAME_,SpecularColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR_ROUGHNESS,_VARYINGNAME_,SpecularRoughness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,SpecularRoughnessAnisotropy)
+#include<samplerVertexDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,TRANSMISSION_COLOR,_VARYINGNAME_,TransmissionColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,TRANSMISSION_DEPTH,_VARYINGNAME_,TransmissionDepth)
+#include<samplerVertexDeclaration>(_DEFINENAME_,TRANSMISSION_SCATTER,_VARYINGNAME_,TransmissionScatter)
+#include<samplerVertexDeclaration>(_DEFINENAME_,TRANSMISSION_DISPERSION_SCALE,_VARYINGNAME_,TransmissionDispersionScale)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SUBSURFACE_COLOR,_VARYINGNAME_,SubsurfaceColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SUBSURFACE_RADIUS_SCALE,_VARYINGNAME_,SubsurfaceRadiusScale)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_WEIGHT,_VARYINGNAME_,CoatWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_COLOR,_VARYINGNAME_,CoatColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_ROUGHNESS,_VARYINGNAME_,CoatRoughness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,CoatRoughnessAnisotropy)
+#include<samplerVertexDeclaration>(_DEFINENAME_,COAT_DARKENING,_VARYINGNAME_,CoatDarkening)
+#include<samplerVertexDeclaration>(_DEFINENAME_,FUZZ_WEIGHT,_VARYINGNAME_,FuzzWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,FUZZ_COLOR,_VARYINGNAME_,FuzzColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,FUZZ_ROUGHNESS,_VARYINGNAME_,FuzzRoughness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_NORMAL,_VARYINGNAME_,GeometryNormal)
+#include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_TANGENT,_VARYINGNAME_,GeometryTangent)
+#include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_COAT_NORMAL,_VARYINGNAME_,GeometryCoatNormal)
+#include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_OPACITY,_VARYINGNAME_,GeometryOpacity)
+#include<samplerVertexDeclaration>(_DEFINENAME_,GEOMETRY_THICKNESS,_VARYINGNAME_,GeometryThickness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,EMISSION_COLOR,_VARYINGNAME_,EmissionColor)
+#include<samplerVertexDeclaration>(_DEFINENAME_,THIN_FILM_WEIGHT,_VARYINGNAME_,ThinFilmWeight)
+#include<samplerVertexDeclaration>(_DEFINENAME_,THIN_FILM_THICKNESS,_VARYINGNAME_,ThinFilmThickness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,AMBIENT_OCCLUSION,_VARYINGNAME_,AmbientOcclusion)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail)
+varying vPositionW: vec3f;
+#if DEBUGMODE>0
+varying vClipSpacePosition: vec4f;
+#endif
+#ifdef NORMAL
+varying vNormalW: vec3f;
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+varying vEnvironmentIrradiance: vec3f;
+#include<harmonicsFunctions>
+#endif
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vColor: vec4f;
+#endif
+#include<openpbrNormalMapVertexDeclaration>
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<lightVxUboDeclaration>[0..maxSimultaneousLights]
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+varying vPositionUVW: vec3f;
+#endif
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vDirectionW: vec3f;
+#endif
+#include<logDepthDeclaration>
+#include<vertexPullingDeclaration>
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+#ifdef USE_VERTEX_PULLING
+var positionUpdated: vec3f=vec3f(0.0);
+#ifdef NORMAL
+var normalUpdated: vec3f=vec3f(0.0);
+#endif
+#ifdef TANGENT
+var tangentUpdated: vec4f=vec4f(0.0);
+#endif
+#ifdef UV1
+var uvUpdated: vec2f=vec2f(0.0);
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vec2f(0.0);
+#endif
+#ifdef VERTEXCOLOR
+var colorUpdated: vec4f=vec4f(0.0);
+#endif
+#else
+var positionUpdated: vec3f=vertexInputs.position;
+#ifdef NORMAL
+var normalUpdated: vec3f=vertexInputs.normal;
+#endif
+#ifdef TANGENT
+var tangentUpdated: vec4f=vertexInputs.tangent;
+#endif
+#ifdef UV1
+var uvUpdated: vec2f=vertexInputs.uv;
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vertexInputs.uv2;
+#endif
+#ifdef VERTEXCOLOR
+var colorUpdated: vec4f=vertexInputs.color;
+#endif
+#endif
+#include<vertexPullingVertex>
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+vertexOutputs.vPositionUVW=positionUpdated;
+#endif
+#define CUSTOM_VERTEX_UPDATE_POSITION
+#define CUSTOM_VERTEX_UPDATE_NORMAL
+#include<instancesVertex>
+#if defined(PREPASS) && ((defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)) && !defined(BONES_VELOCITY_ENABLED)
+vertexOutputs.vCurrentPosition=scene.viewProjection*finalWorld*vec4f(positionUpdated,1.0);vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld*vec4f(positionUpdated,1.0);
+#endif
+#ifdef USE_VERTEX_PULLING
+#include<bonesVertex>(vertexInputs.matricesIndices,vp_matricesIndices,vertexInputs.matricesWeights,vp_matricesWeights,vertexInputs.matricesIndicesExtra,vp_matricesIndicesExtra,vertexInputs.matricesWeightsExtra,vp_matricesWeightsExtra)
+#include<bakedVertexAnimation>(vertexInputs.matricesIndices,vp_matricesIndices,vertexInputs.matricesWeights,vp_matricesWeights,vertexInputs.matricesIndicesExtra,vp_matricesIndicesExtra,vertexInputs.matricesWeightsExtra,vp_matricesWeightsExtra)
+#else
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+#endif
+var worldPos: vec4f=finalWorld* vec4f(positionUpdated,1.0);vertexOutputs.vPositionW= worldPos.xyz;
+#ifdef PREPASS
+#include<prePassVertex>
+#endif
+#ifdef NORMAL
+var normalWorld: mat3x3f= mat3x3f(finalWorld[0].xyz,finalWorld[1].xyz,finalWorld[2].xyz);
+#if defined(INSTANCES) && defined(THIN_INSTANCES)
+vertexOutputs.vNormalW=normalUpdated/ vec3f(dot(normalWorld[0],normalWorld[0]),dot(normalWorld[1],normalWorld[1]),dot(normalWorld[2],normalWorld[2]));vertexOutputs.vNormalW=normalize(normalWorld*vertexOutputs.vNormalW);
+#else
+#ifdef NONUNIFORMSCALING
+normalWorld=transposeMat3(inverseMat3(normalWorld));
+#endif
+vertexOutputs.vNormalW=normalize(normalWorld*normalUpdated);
+#endif
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+#if BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LAMBERT && BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LEGACY
+var viewDirectionW: vec3f=normalize(scene.vEyePosition.xyz-vertexOutputs.vPositionW);var NdotV: f32=max(dot(vertexOutputs.vNormalW,viewDirectionW),0.0);var roughNormal: vec3f=mix(vertexOutputs.vNormalW,viewDirectionW,(0.5*(1.0-NdotV))*uniforms.vBaseDiffuseRoughness);var reflectionVector: vec3f= (uniforms.reflectionMatrix* vec4f(roughNormal,0)).xyz;
+#else
+var reflectionVector: vec3f= (uniforms.reflectionMatrix* vec4f(vertexOutputs.vNormalW,0)).xyz;
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+vertexOutputs.vEnvironmentIrradiance=computeEnvironmentIrradiance(reflectionVector);
+#endif
+#endif
+#define CUSTOM_VERTEX_UPDATE_WORLDPOS
+#ifdef MULTIVIEW
+if (gl_ViewID_OVR==0u) {vertexOutputs.position=scene.viewProjection*worldPos;} else {vertexOutputs.position=scene.viewProjectionR*worldPos;}
+#else
+vertexOutputs.position=scene.viewProjection*worldPos;
+#endif
+#if DEBUGMODE>0
+vertexOutputs.vClipSpacePosition=vertexOutputs.position;
+#endif
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+vertexOutputs.vDirectionW=normalize((finalWorld*vec4f(positionUpdated,0.0)).xyz);
+#endif
+#ifndef UV1
+var uvUpdated: vec2f= vec2f(0.,0.);
+#endif
+#ifdef MAINUV1
+vertexOutputs.vMainUV1=uvUpdated;
+#endif
+#ifndef UV2
+var uv2Updated: vec2f= vec2f(0.,0.);
+#endif
+#ifdef MAINUV2
+vertexOutputs.vMainUV2=uv2Updated;
+#endif
+#include<uvVariableDeclaration>[3..7]
+#include<samplerVertexImplementation>(_DEFINENAME_,BASE_COLOR,_VARYINGNAME_,BaseColor,_MATRIXNAME_,baseColor,_INFONAME_,BaseColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,BASE_WEIGHT,_VARYINGNAME_,BaseWeight,_MATRIXNAME_,baseWeight,_INFONAME_,BaseWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,BASE_DIFFUSE_ROUGHNESS,_VARYINGNAME_,BaseDiffuseRoughness,_MATRIXNAME_,baseDiffuseRoughness,_INFONAME_,BaseDiffuseRoughnessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,BASE_METALNESS,_VARYINGNAME_,BaseMetalness,_MATRIXNAME_,baseMetalness,_INFONAME_,BaseMetalnessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR_WEIGHT,_VARYINGNAME_,SpecularWeight,_MATRIXNAME_,specularWeight,_INFONAME_,SpecularWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR_COLOR,_VARYINGNAME_,SpecularColor,_MATRIXNAME_,specularColor,_INFONAME_,SpecularColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR_ROUGHNESS,_VARYINGNAME_,SpecularRoughness,_MATRIXNAME_,specularRoughness,_INFONAME_,SpecularRoughnessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,SpecularRoughnessAnisotropy,_MATRIXNAME_,specularRoughnessAnisotropy,_INFONAME_,SpecularRoughnessAnisotropyInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_MATRIXNAME_,transmissionWeight,_INFONAME_,TransmissionWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,TRANSMISSION_COLOR,_VARYINGNAME_,TransmissionColor,_MATRIXNAME_,transmissionColor,_INFONAME_,TransmissionColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,TRANSMISSION_DEPTH,_VARYINGNAME_,TransmissionDepth,_MATRIXNAME_,transmissionDepth,_INFONAME_,TransmissionDepthInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,TRANSMISSION_SCATTER,_VARYINGNAME_,TransmissionScatter,_MATRIXNAME_,transmissionScatter,_INFONAME_,TransmissionScatterInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,TRANSMISSION_DISPERSION_SCALE,_VARYINGNAME_,TransmissionDispersionScale,_MATRIXNAME_,transmissionDispersionScale,_INFONAME_,TransmissionDispersionScaleInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_MATRIXNAME_,subsurfaceWeight,_INFONAME_,SubsurfaceWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SUBSURFACE_COLOR,_VARYINGNAME_,SubsurfaceColor,_MATRIXNAME_,subsurfaceColor,_INFONAME_,SubsurfaceColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SUBSURFACE_RADIUS_SCALE,_VARYINGNAME_,SubsurfaceRadiusScale,_MATRIXNAME_,subsurfaceRadiusScale,_INFONAME_,SubsurfaceRadiusScaleInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,COAT_WEIGHT,_VARYINGNAME_,CoatWeight,_MATRIXNAME_,coatWeight,_INFONAME_,CoatWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,COAT_COLOR,_VARYINGNAME_,CoatColor,_MATRIXNAME_,coatColor,_INFONAME_,CoatColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,COAT_ROUGHNESS,_VARYINGNAME_,CoatRoughness,_MATRIXNAME_,coatRoughness,_INFONAME_,CoatRoughnessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,COAT_ROUGHNESS_ANISOTROPY,_VARYINGNAME_,CoatRoughnessAnisotropy,_MATRIXNAME_,coatRoughnessAnisotropy,_INFONAME_,CoatRoughnessAnisotropyInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,COAT_DARKENING,_VARYINGNAME_,CoatDarkening,_MATRIXNAME_,coatDarkening,_INFONAME_,CoatDarkeningInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,FUZZ_WEIGHT,_VARYINGNAME_,FuzzWeight,_MATRIXNAME_,fuzzWeight,_INFONAME_,FuzzWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,FUZZ_COLOR,_VARYINGNAME_,FuzzColor,_MATRIXNAME_,fuzzColor,_INFONAME_,FuzzColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,FUZZ_ROUGHNESS,_VARYINGNAME_,FuzzRoughness,_MATRIXNAME_,fuzzRoughness,_INFONAME_,FuzzRoughnessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_NORMAL,_VARYINGNAME_,GeometryNormal,_MATRIXNAME_,geometryNormal,_INFONAME_,GeometryNormalInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_TANGENT,_VARYINGNAME_,GeometryTangent,_MATRIXNAME_,geometryTangent,_INFONAME_,GeometryTangentInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_COAT_NORMAL,_VARYINGNAME_,GeometryCoatNormal,_MATRIXNAME_,geometryCoatNormal,_INFONAME_,GeometryCoatNormalInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_OPACITY,_VARYINGNAME_,GeometryOpacity,_MATRIXNAME_,geometryOpacity,_INFONAME_,GeometryOpacityInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,GEOMETRY_THICKNESS,_VARYINGNAME_,GeometryThickness,_MATRIXNAME_,geometryThickness,_INFONAME_,GeometryThicknessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,EMISSION_COLOR,_VARYINGNAME_,EmissionColor,_MATRIXNAME_,emissionColor,_INFONAME_,EmissionColorInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,THIN_FILM_WEIGHT,_VARYINGNAME_,ThinFilmWeight,_MATRIXNAME_,thinFilmWeight,_INFONAME_,ThinFilmWeightInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,THIN_FILM_THICKNESS,_VARYINGNAME_,ThinFilmThickness,_MATRIXNAME_,thinFilmThickness,_INFONAME_,ThinFilmThicknessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,AMBIENT_OCCLUSION,_VARYINGNAME_,AmbientOcclusion,_MATRIXNAME_,ambientOcclusion,_INFONAME_,AmbientOcclusionInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_MATRIXNAME_,decal,_INFONAME_,DecalInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_MATRIXNAME_,detail,_INFONAME_,DetailInfos.x)
+#include<openpbrNormalMapVertex>
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+#include<vertexColorMixing>
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}`;for(let e of(t.ShaderStore.ShadersStoreWGSL[X]||(t.ShaderStore.ShadersStoreWGSL[X]=z),[r.sceneUboDeclarationWGSL,i.meshUboDeclarationWGSL,n.openpbrUboDeclarationWGSL,a.uvAttributeDeclarationWGSL,f.mainUVVaryingDeclarationWGSL,o.helperFunctionsWGSL,s.pbrBRDFFunctionsWGSL,d.bonesDeclarationWGSL,l.bakedVertexAnimationDeclarationWGSL,c.instancesDeclarationWGSL,u.prePassVertexDeclarationWGSL,v.samplerVertexDeclarationWGSL,m.harmonicsFunctionsWGSL,{name:p,shader:E},_.clipPlaneVertexDeclarationWGSL,I.fogVertexDeclarationWGSL,S.lightVxUboDeclarationWGSL,x.morphTargetsVertexGlobalDeclarationWGSL,N.morphTargetsVertexDeclarationWGSL,T.logDepthDeclarationWGSL,A.vertexPullingDeclarationWGSL,R.vertexPullingVertexWGSL,h.morphTargetsVertexGlobalWGSL,V.morphTargetsVertexWGSL,O.instancesVertexWGSL,M.bonesVertexWGSL,L.bakedVertexAnimationWGSL,g.prePassVertexWGSL,F.uvVariableDeclarationWGSL,U.samplerVertexImplementationWGSL,{name:C,shader:G},D.clipPlaneVertexWGSL,P.fogVertexWGSL,b.shadowsVertexWGSL,y.vertexColorMixingWGSL,W.logDepthVertexWGSL]))t.ShaderStore.IncludesShadersStoreWGSL[e.name]||(t.ShaderStore.IncludesShadersStoreWGSL[e.name]=e.shader);e.s(["openpbrVertexShaderWGSL",0,{name:X,shader:z}],51455)}]);