@uptimizr/dashboard 0.1.2 → 0.2.0

package/out/_next/static/chunks/37epa8fz59vba.js

@@ -0,0 +1,1166 @@
+(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,28657,78875,23344,e=>{"use strict";var r=e.i(12423);let a="bumpFragmentMainFunctions",i=`#ifndef TEXRD_DEFINED
+fn TEXRD(t: texture_2d<f32>,ts: sampler,uv: vec2f)->vec4f {return textureSample(t,ts,uv);}
+#define TEXRD_DEFINED
+#endif
+#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)
+#if defined(TANGENT) && defined(NORMAL) 
+varying vTBN0: vec3f;varying vTBN1: vec3f;varying vTBN2: vec3f;
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+uniform normalMatrix: mat4x4f;fn toNormalMatrix(m: mat4x4f)->mat4x4f
+{var a00=m[0][0];var a01=m[0][1];var a02=m[0][2];var a03=m[0][3];var a10=m[1][0];var a11=m[1][1];var a12=m[1][2];var a13=m[1][3];var a20=m[2][0]; 
+var a21=m[2][1];var a22=m[2][2];var a23=m[2][3];var a30=m[3][0]; 
+var a31=m[3][1];var a32=m[3][2];var a33=m[3][3];var b00=a00*a11-a01*a10;var b01=a00*a12-a02*a10;var b02=a00*a13-a03*a10;var b03=a01*a12-a02*a11;var b04=a01*a13-a03*a11;var b05=a02*a13-a03*a12;var b06=a20*a31-a21*a30;var b07=a20*a32-a22*a30;var b08=a20*a33-a23*a30;var b09=a21*a32-a22*a31;var b10=a21*a33-a23*a31;var b11=a22*a33-a23*a32;var det=b00*b11-b01*b10+b02*b09+b03*b08-b04*b07+b05*b06;var mi=mat4x4<f32>(
+(a11*b11-a12*b10+a13*b09)/det,
+(a02*b10-a01*b11-a03*b09)/det,
+(a31*b05-a32*b04+a33*b03)/det,
+(a22*b04-a21*b05-a23*b03)/det,
+(a12*b08-a10*b11-a13*b07)/det,
+(a00*b11-a02*b08+a03*b07)/det,
+(a32*b02-a30*b05-a33*b01)/det,
+(a20*b05-a22*b02+a23*b01)/det,
+(a10*b10-a11*b08+a13*b06)/det,
+(a01*b08-a00*b10-a03*b06)/det,
+(a30*b04-a31*b02+a33*b00)/det,
+(a21*b02-a20*b04-a23*b00)/det,
+(a11*b07-a10*b09-a12*b06)/det,
+(a00*b09-a01*b07+a02*b06)/det,
+(a31*b01-a30*b03-a32*b00)/det,
+(a20*b03-a21*b01+a22*b00)/det);return mat4x4<f32>(mi[0][0],mi[1][0],mi[2][0],mi[3][0],
+mi[0][1],mi[1][1],mi[2][1],mi[3][1],
+mi[0][2],mi[1][2],mi[2][2],mi[3][2],
+mi[0][3],mi[1][3],mi[2][3],mi[3][3]);}
+#endif
+fn perturbNormalBase(cotangentFrame: mat3x3f,normal: vec3f,scale: f32)->vec3f
+{var output=normal;
+#ifdef NORMALXYSCALE
+output=normalize(output* vec3f(scale,scale,1.0));
+#endif
+return normalize(cotangentFrame*output);}
+fn perturbNormal(cotangentFrame: mat3x3f,textureSample: vec3f,scale: f32)->vec3f
+{return perturbNormalBase(cotangentFrame,textureSample*2.0-1.0,scale);}
+fn cotangent_frame(normal: vec3f,p: vec3f,uv: vec2f,tangentSpaceParams: vec2f)->mat3x3f
+{var dp1: vec3f=dpdx(p);var dp2: vec3f=dpdy(p);var duv1: vec2f=dpdx(uv);var duv2: vec2f=dpdy(uv);var dp2perp: vec3f=cross(dp2,normal);var dp1perp: vec3f=cross(normal,dp1);var tangent: vec3f=dp2perp*duv1.x+dp1perp*duv2.x;var bitangent: vec3f=dp2perp*duv1.y+dp1perp*duv2.y;tangent*=tangentSpaceParams.x;bitangent*=tangentSpaceParams.y;var det: f32=max(dot(tangent,tangent),dot(bitangent,bitangent));var invmax: f32=select(inverseSqrt(det),0.0,det==0.0);return mat3x3f(tangent*invmax,bitangent*invmax,normal);}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["bumpFragmentMainFunctionsWGSL",0,{name:a,shader:i}],28657),e.i(67367);let f="bumpFragmentFunctions",n=`#if defined(BUMP)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)
+#endif
+#if defined(DETAIL)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)
+#endif
+#if defined(BUMP) && defined(PARALLAX)
+const minSamples: f32=4.;const maxSamples: f32=15.;const iMaxSamples: i32=15;fn parallaxOcclusion(vViewDirCoT: vec3f,vNormalCoT: vec3f,texCoord: vec2f,parallaxScale: f32)->vec2f {var parallaxLimit: f32=length(vViewDirCoT.xy)/vViewDirCoT.z;parallaxLimit*=parallaxScale;var vOffsetDir: vec2f=normalize(vViewDirCoT.xy);var vMaxOffset: vec2f=vOffsetDir*parallaxLimit;var numSamples: f32=maxSamples+(dot(vViewDirCoT,vNormalCoT)*(minSamples-maxSamples));var stepSize: f32=1.0/numSamples;var currRayHeight: f32=1.0;var vCurrOffset: vec2f= vec2f(0,0);var vLastOffset: vec2f= vec2f(0,0);var lastSampledHeight: f32=1.0;var currSampledHeight: f32=1.0;var keepWorking: bool=true;for (var i: i32=0; i<iMaxSamples; i++)
+{currSampledHeight=textureSample(bumpSampler,bumpSamplerSampler,texCoord+vCurrOffset).w;if (!keepWorking)
+{}
+else if (currSampledHeight>currRayHeight)
+{var delta1: f32=currSampledHeight-currRayHeight;var delta2: f32=(currRayHeight+stepSize)-lastSampledHeight;var ratio: f32=delta1/(delta1+delta2);vCurrOffset=(ratio)* vLastOffset+(1.0-ratio)*vCurrOffset;keepWorking=false;}
+else
+{currRayHeight-=stepSize;vLastOffset=vCurrOffset;
+#ifdef PARALLAX_RHS
+vCurrOffset-=stepSize*vMaxOffset;
+#else
+vCurrOffset+=stepSize*vMaxOffset;
+#endif
+lastSampledHeight=currSampledHeight;}}
+return vCurrOffset;}
+fn parallaxOffset(viewDir: vec3f,heightScale: f32)->vec2f
+{var height: f32=textureSample(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV).w;var texCoordOffset: vec2f=heightScale*viewDir.xy*height;
+#ifdef PARALLAX_RHS
+return texCoordOffset;
+#else
+return -texCoordOffset;
+#endif
+}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[f]||(r.ShaderStore.IncludesShadersStoreWGSL[f]=n),e.s(["bumpFragmentFunctionsWGSL",0,{name:f,shader:n}],78875);let t="bumpFragment",o=`var uvOffset: vec2f= vec2f(0.0,0.0);
+#if defined(BUMP) || defined(PARALLAX) || defined(DETAIL)
+#ifdef NORMALXYSCALE
+var normalScale: f32=1.0;
+#elif defined(BUMP)
+var normalScale: f32=uniforms.vBumpInfos.y;
+#else
+var normalScale: f32=1.0;
+#endif
+#if defined(TANGENT) && defined(NORMAL)
+var TBN: mat3x3f=mat3x3<f32>(input.vTBN0,input.vTBN1,input.vTBN2); 
+#elif defined(BUMP)
+var TBNUV: vec2f=select(-fragmentInputs.vBumpUV,fragmentInputs.vBumpUV,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW*normalScale,input.vPositionW,TBNUV,uniforms.vTangentSpaceParams);
+#else
+var TBNUV: vec2f=select(-fragmentInputs.vDetailUV,fragmentInputs.vDetailUV,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW*normalScale,input.vPositionW,TBNUV, vec2f(1.,1.));
+#endif
+#elif defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+var TBN: mat3x3f=mat3x3<f32>(input.vTBN0,input.vTBN1,input.vTBN2); 
+#else
+var TBNUV: vec2f=select( -fragmentInputs.vMainUV1,fragmentInputs.vMainUV1,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW,input.vPositionW,TBNUV, vec2f(1.,1.));
+#endif
+#endif
+#ifdef PARALLAX
+var invTBN: mat3x3f=transposeMat3(TBN);
+#ifdef PARALLAXOCCLUSION
+uvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,fragmentInputs.vBumpUV,uniforms.vBumpInfos.z);
+#else
+uvOffset=parallaxOffset(invTBN*viewDirectionW,uniforms.vBumpInfos.z);
+#endif
+#endif
+#ifdef DETAIL
+var detailColor: vec4f=textureSample(detailSampler,detailSamplerSampler,fragmentInputs.vDetailUV+uvOffset);var detailNormalRG: vec2f=detailColor.wy*2.0-1.0;var detailNormalB: f32=sqrt(1.-saturate(dot(detailNormalRG,detailNormalRG)));var detailNormal: vec3f= vec3f(detailNormalRG,detailNormalB);
+#endif
+#ifdef BUMP
+#ifdef OBJECTSPACE_NORMALMAP
+#define CUSTOM_FRAGMENT_BUMP_FRAGMENT
+normalW=normalize(TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV).xyz *2.0-1.0);normalW=normalize(mat3x3f(uniforms.normalMatrix[0].xyz,uniforms.normalMatrix[1].xyz,uniforms.normalMatrix[2].xyz)*normalW);
+#elif !defined(DETAIL)
+normalW=perturbNormal(TBN,TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV+uvOffset).xyz,uniforms.vBumpInfos.y);
+#else
+var bumpNormal: vec3f=TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV+uvOffset).xyz*2.0-1.0;
+#if DETAIL_NORMALBLENDMETHOD==0 
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);var blendedNormal: vec3f=normalize( vec3f(bumpNormal.xy+detailNormal.xy,bumpNormal.z*detailNormal.z));
+#elif DETAIL_NORMALBLENDMETHOD==1 
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);bumpNormal+= vec3f(0.0,0.0,1.0);detailNormal*= vec3f(-1.0,-1.0,1.0);var blendedNormal: vec3f=bumpNormal*dot(bumpNormal,detailNormal)/bumpNormal.z-detailNormal;
+#endif
+normalW=perturbNormalBase(TBN,blendedNormal,uniforms.vBumpInfos.y);
+#endif
+#elif defined(DETAIL)
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);normalW=perturbNormalBase(TBN,detailNormal,uniforms.vDetailInfos.z);
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[t]||(r.ShaderStore.IncludesShadersStoreWGSL[t]=o),e.s(["bumpFragmentWGSL",0,{name:t,shader:o}],23344)},4357,e=>{"use strict";var r=e.i(12423);let a="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));}
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["helperFunctionsWGSL",0,{name:a,shader:i}])},60106,e=>{"use strict";var r=e.i(12423);let a="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;
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["sceneUboDeclarationWGSL",0,{name:a,shader:i}])},61202,e=>{"use strict";var r=e.i(12423);let a="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 
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["pbrBRDFFunctionsWGSL",0,{name:a,shader:i}])},35182,63406,e=>{"use strict";var r=e.i(12423);let a="clipPlaneFragmentDeclaration",i=`#ifdef CLIPPLANE
+varying fClipDistance: f32;
+#endif
+#ifdef CLIPPLANE2
+varying fClipDistance2: f32;
+#endif
+#ifdef CLIPPLANE3
+varying fClipDistance3: f32;
+#endif
+#ifdef CLIPPLANE4
+varying fClipDistance4: f32;
+#endif
+#ifdef CLIPPLANE5
+varying fClipDistance5: f32;
+#endif
+#ifdef CLIPPLANE6
+varying fClipDistance6: f32;
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["clipPlaneFragmentDeclarationWGSL",0,{name:a,shader:i}],35182);let f="clipPlaneFragment",n=`#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)
+if (false) {}
+#endif
+#ifdef CLIPPLANE
+else if (fragmentInputs.fClipDistance>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE2
+else if (fragmentInputs.fClipDistance2>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE3
+else if (fragmentInputs.fClipDistance3>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE4
+else if (fragmentInputs.fClipDistance4>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE5
+else if (fragmentInputs.fClipDistance5>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE6
+else if (fragmentInputs.fClipDistance6>0.0)
+{discard;}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[f]||(r.ShaderStore.IncludesShadersStoreWGSL[f]=n),e.s(["clipPlaneFragmentWGSL",0,{name:f,shader:n}],63406)},67367,23356,e=>{"use strict";var r=e.i(12423);let a="samplerFragmentDeclaration",i=`#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying v_VARYINGNAME_UV: vec2f;
+#endif
+var _SAMPLERNAME_SamplerSampler: sampler;var _SAMPLERNAME_Sampler: texture_2d<f32>;
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["samplerFragmentDeclarationWGSL",0,{name:a,shader:i}],67367);let f="reflectionFunction",n=`fn computeFixedEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,direction: vec3f)->vec3f
+{var lon: f32=atan2(direction.z,direction.x);var lat: f32=acos(direction.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(s,t,0); }
+fn computeMirroredFixedEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,direction: vec3f)->vec3f
+{var lon: f32=atan2(direction.z,direction.x);var lat: f32=acos(direction.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(1.0-s,t,0); }
+fn computeEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var cameraToVertex: vec3f=normalize(worldPos.xyz-eyePosition);var r: vec3f=normalize(reflect(cameraToVertex,worldNormal));r= (reflectionMatrix* vec4f(r,0)).xyz;var lon: f32=atan2(r.z,r.x);var lat: f32=acos(r.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(s,t,0);}
+fn computeSphericalCoords(worldPos: vec4f,worldNormal: vec3f,view: mat4x4f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=normalize((view*worldPos).xyz);var viewNormal: vec3f=normalize((view* vec4f(worldNormal,0.0)).xyz);var r: vec3f=reflect(viewDir,viewNormal);r= (reflectionMatrix* vec4f(r,0)).xyz;r.z=r.z-1.0;var m: f32=2.0*length(r);return vec3f(r.x/m+0.5,1.0-r.y/m-0.5,0);}
+fn computePlanarCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=worldPos.xyz-eyePosition;var coords: vec3f=normalize(reflect(viewDir,worldNormal));return (reflectionMatrix* vec4f(coords,1)).xyz;}
+fn computeCubicCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=normalize(worldPos.xyz-eyePosition);var coords: vec3f=reflect(viewDir,worldNormal);coords= (reflectionMatrix* vec4f(coords,0)).xyz;
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+fn computeCubicLocalCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f,reflectionSize: vec3f,reflectionPosition: vec3f)->vec3f
+{var viewDir: vec3f=normalize(worldPos.xyz-eyePosition);var coords: vec3f=reflect(viewDir,worldNormal);coords=parallaxCorrectNormal(worldPos.xyz,coords,reflectionSize,reflectionPosition);coords=(reflectionMatrix* vec4f(coords,0)).xyz;
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+fn computeProjectionCoords(worldPos: vec4f,view: mat4x4f,reflectionMatrix: mat4x4f)->vec3f
+{return (reflectionMatrix*(view*worldPos)).xyz;}
+fn computeSkyBoxCoords(positionW: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{return (reflectionMatrix* vec4f(positionW,1.)).xyz;}
+#ifdef REFLECTION
+fn computeReflectionCoords(worldPos: vec4f,worldNormal: vec3f)->vec3f
+{
+#ifdef REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED
+var direction: vec3f=normalize(fragmentInputs.vDirectionW);return computeMirroredFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR_FIXED
+var direction: vec3f=normalize(fragmentInputs.vDirectionW);return computeFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR
+return computeEquirectangularCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SPHERICAL
+return computeSphericalCoords(worldPos,worldNormal,scene.view,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_PLANAR
+return computePlanarCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_CUBIC
+#ifdef USE_LOCAL_REFLECTIONMAP_CUBIC
+return computeCubicLocalCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix,uniforms.vReflectionSize,uniforms.vReflectionPosition);
+#else
+return computeCubicCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_PROJECTION
+return computeProjectionCoords(worldPos,scene.view,uniforms.reflectionMatrix);
+#endif
+#ifndef REFLECTIONMAP_CUBIC
+#ifdef REFLECTIONMAP_SKYBOX
+return computeSkyBoxCoords(fragmentInputs.vPositionUVW,uniforms.reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_EXPLICIT
+return vec3f(0,0,0);
+#endif
+}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[f]||(r.ShaderStore.IncludesShadersStoreWGSL[f]=n),e.s(["reflectionFunctionWGSL",0,{name:f,shader:n}],23356)},90780,82518,e=>{"use strict";var r=e.i(12423);let a="pbrFragmentReflectionDeclaration",i=`#ifdef REFLECTION
+#ifdef REFLECTIONMAP_3D
+var reflectionSamplerSampler: sampler;var reflectionSampler: texture_cube<f32>;
+#ifdef LODBASEDMICROSFURACE
+#else
+var reflectionLowSamplerSampler: sampler;var reflectionLowSampler: texture_cube<f32>;var reflectionHighSamplerSampler: sampler;var reflectionHighSampler: texture_cube<f32>;
+#endif
+#ifdef USEIRRADIANCEMAP
+var irradianceSamplerSampler: sampler;var irradianceSampler: texture_cube<f32>;
+#endif
+#else
+var reflectionSamplerSampler: sampler;var reflectionSampler: texture_2d<f32>;
+#ifdef LODBASEDMICROSFURACE
+#else
+var reflectionLowSamplerSampler: sampler;var reflectionLowSampler: texture_2d<f32>;var reflectionHighSamplerSampler: sampler;var reflectionHighSampler: texture_2d<f32>;
+#endif
+#ifdef USEIRRADIANCEMAP
+var irradianceSamplerSampler: sampler;var irradianceSampler: texture_2d<f32>;
+#endif
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+varying vPositionUVW: vec3f;
+#else
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vDirectionW: vec3f;
+#endif
+#endif
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["pbrFragmentReflectionDeclarationWGSL",0,{name:a,shader:i}],90780);let f="pbrIBLFunctions",n=`#if defined(REFLECTION) || defined(SS_REFRACTION)
+fn getLodFromAlphaG(cubeMapDimensionPixels: f32,microsurfaceAverageSlope: f32)->f32 {var microsurfaceAverageSlopeTexels: f32=cubeMapDimensionPixels*microsurfaceAverageSlope;var lod: f32=log2(microsurfaceAverageSlopeTexels);return lod;}
+fn getLinearLodFromRoughness(cubeMapDimensionPixels: f32,roughness: f32)->f32 {var lod: f32=log2(cubeMapDimensionPixels)*roughness;return lod;}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(RADIANCEOCCLUSION)
+fn environmentRadianceOcclusion(ambientOcclusion: f32,NdotVUnclamped: f32)->f32 {var temp: f32=NdotVUnclamped+ambientOcclusion;return saturate(temp*temp-1.0+ambientOcclusion);}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(HORIZONOCCLUSION)
+fn environmentHorizonOcclusion(view: vec3f,normal: vec3f,geometricNormal: vec3f)->f32 {var reflection: vec3f=reflect(view,normal);var temp: f32=saturate(1.0+1.1*dot(reflection,geometricNormal));return temp*temp;}
+#endif
+#if defined(LODINREFLECTIONALPHA) || defined(SS_LODINREFRACTIONALPHA)
+fn UNPACK_LOD(x: f32)->f32 {return (1.0-x)*255.0;}
+fn getLodFromAlphaGNdotV(cubeMapDimensionPixels: f32,alphaG: f32,NdotV: f32)->f32 {var microsurfaceAverageSlope: f32=alphaG;microsurfaceAverageSlope*=sqrt(abs(NdotV));return getLodFromAlphaG(cubeMapDimensionPixels,microsurfaceAverageSlope);}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[f]||(r.ShaderStore.IncludesShadersStoreWGSL[f]=n),e.s(["pbrIBLFunctionsWGSL",0,{name:f,shader:n}],82518)},30420,22389,63189,e=>{"use strict";var r=e.i(12423);let a="openpbrDielectricReflectance",i=`struct ReflectanceParams
+{F0: f32,
+F90: f32,
+coloredF0: vec3f,
+coloredF90: vec3f,};
+#define pbr_inline
+fn dielectricReflectance(
+insideIOR: f32,outsideIOR: f32,specularColor: vec3f,specularWeight: f32
+)->ReflectanceParams
+{var outParams: ReflectanceParams;let dielectricF0=pow((insideIOR-outsideIOR)/(insideIOR+outsideIOR),2.0);
+#if DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_GLTF
+let maxF0=max(specularColor.r,max(specularColor.g,specularColor.b));outParams.F0=dielectricF0*maxF0*specularWeight;
+#else
+outParams.F0=dielectricF0*specularWeight;
+#endif
+let f90Scale=clamp(2.0f*abs(insideIOR-outsideIOR),0.0f,1.0f);outParams.F90=f90Scale*specularWeight;outParams.coloredF0=vec3f(dielectricF0*specularWeight)*specularColor.rgb;
+#if (DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_OPENPBR)
+let dielectricColorF90: vec3f=specularColor.rgb*vec3f(f90Scale)*specularWeight;
+#else
+let dielectricColorF90: vec3f=vec3f(f90Scale)*specularWeight;
+#endif
+outParams.coloredF90=dielectricColorF90;return outParams;}
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["openpbrDielectricReflectanceWGSL",0,{name:a,shader:i}],30420);let f="openpbrGeometryInfo",n=`struct geometryInfoOutParams
+{NdotV: f32,
+NdotVUnclamped: f32,
+environmentBrdf: vec3f,
+horizonOcclusion: f32};struct geometryInfoAnisoOutParams
+{NdotV: f32,
+NdotVUnclamped: f32,
+environmentBrdf: vec3f,
+horizonOcclusion: f32,
+anisotropy: f32,
+anisotropicTangent: vec3f,
+anisotropicBitangent: vec3f,
+TBN: mat3x3<f32>};fn geometryInfo(
+normalW: vec3f,viewDirectionW: vec3f,roughness: f32,geometricNormalW: vec3f
+)->geometryInfoOutParams
+{var outParams: geometryInfoOutParams;outParams.NdotVUnclamped=dot(normalW,viewDirectionW);outParams.NdotV=absEps(outParams.NdotVUnclamped);
+#if defined(ENVIRONMENTBRDF)
+outParams.environmentBrdf=getBRDFLookup(outParams.NdotV,roughness);
+#else
+outParams.environmentBrdf=vec3f(0.0);
+#endif
+outParams.horizonOcclusion=1.0f;
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef HORIZONOCCLUSION
+#if defined(GEOMETRY_NORMAL) || defined(GEOMETRY_COAT_NORMAL)
+#ifdef REFLECTIONMAP_3D
+outParams.horizonOcclusion=environmentHorizonOcclusion(-viewDirectionW,normalW,geometricNormalW);
+#endif
+#endif
+#endif
+#endif
+return outParams;}
+fn geometryInfoAniso(
+normalW: vec3f,viewDirectionW: vec3f,roughness: f32,geometricNormalW: vec3f
+,vAnisotropy: vec3f,TBN: mat3x3<f32>
+)->geometryInfoAnisoOutParams
+{let geoInfo: geometryInfoOutParams=geometryInfo(normalW,viewDirectionW,roughness,geometricNormalW);var outParams: geometryInfoAnisoOutParams;outParams.NdotV=geoInfo.NdotV;outParams.NdotVUnclamped=geoInfo.NdotVUnclamped;outParams.environmentBrdf=geoInfo.environmentBrdf;outParams.horizonOcclusion=geoInfo.horizonOcclusion;outParams.anisotropy=vAnisotropy.b;let anisotropyDirection: vec3f=vec3f(vAnisotropy.xy,0.);let anisoTBN: mat3x3<f32>=mat3x3<f32>(normalize(TBN[0]),normalize(TBN[1]),normalize(TBN[2]));outParams.anisotropicTangent=normalize(anisoTBN*anisotropyDirection);outParams.anisotropicBitangent=normalize(cross(anisoTBN[2],outParams.anisotropicTangent));outParams.TBN=TBN;return outParams;}
+`;r.ShaderStore.IncludesShadersStoreWGSL[f]||(r.ShaderStore.IncludesShadersStoreWGSL[f]=n),e.s(["openpbrGeometryInfoWGSL",0,{name:f,shader:n}],22389);let t="openpbrIblFunctions",o=`#ifdef REFLECTION
+fn sampleIrradiance(
+surfaceNormal: vec3f
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,vEnvironmentIrradianceSH: vec3f
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,iblMatrix: mat4x4f
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+,irradianceSampler: texture_cube<f32>
+,irradianceSamplerSampler: sampler
+#else
+,irradianceSampler: texture_2d<f32>
+,irradianceSamplerSampler: sampler
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,reflectionDominantDirection: vec3f
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#ifdef IBL_CDF_FILTERING
+,icdfSampler: texture_2d<f32>
+,icdfSamplerSampler: sampler
+#endif
+#endif
+,reflectionInfos: vec2f
+,viewDirectionW: vec3f
+,diffuseRoughness: f32
+,surfaceAlbedo: vec3f
+)->vec3f {var environmentIrradiance=vec3f(0.,0.,0.);
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+var irradianceVector=(iblMatrix*vec4f(surfaceNormal,0.0f)).xyz;var irradianceView=(iblMatrix*vec4f(viewDirectionW,0.0f)).xyz;
+#if !defined(USE_IRRADIANCE_DOMINANT_DIRECTION) && !defined(REALTIME_FILTERING)
+#if BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LAMBERT && BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LEGACY
+{let NdotV=max(dot(surfaceNormal,viewDirectionW),0.0f);irradianceVector=mix(irradianceVector,irradianceView,(0.5f*(1.0f-NdotV))*diffuseRoughness);}
+#endif
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;irradianceView.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;irradianceView.y*=-1.0;
+#endif
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+environmentIrradiance=vEnvironmentIrradianceSH;
+#else
+#if defined(REALTIME_FILTERING)
+environmentIrradiance=irradiance(reflectionSampler,reflectionSamplerSampler,irradianceVector,reflectionFilteringInfo,diffuseRoughness,surfaceAlbedo,irradianceView
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+,icdfSamplerSampler
+#endif
+);
+#else
+environmentIrradiance=computeEnvironmentIrradiance(irradianceVector);
+#endif
+#endif
+#elif defined(USEIRRADIANCEMAP)
+#ifdef REFLECTIONMAP_3D
+let environmentIrradianceFromTexture: vec4f=textureSample(irradianceSampler,irradianceSamplerSampler,irradianceVector);
+#else
+let environmentIrradianceFromTexture: vec4f=textureSample(irradianceSampler,irradianceSamplerSampler,reflectionCoords);
+#endif
+environmentIrradiance=environmentIrradianceFromTexture.rgb;
+#ifdef RGBDREFLECTION
+environmentIrradiance.rgb=fromRGBD(environmentIrradianceFromTexture);
+#endif
+#ifdef GAMMAREFLECTION
+environmentIrradiance.rgb=toLinearSpaceVec3(environmentIrradiance.rgb);
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+let Ls: vec3f=normalize(reflectionDominantDirection);let NoL: f32=dot(irradianceVector,Ls);let NoV: f32=dot(irradianceVector,irradianceView);var diffuseRoughnessTerm=vec3f(1.0f);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+let LoV: f32=dot (Ls,irradianceView);let mag: f32=length(reflectionDominantDirection)*2.0f;let clampedAlbedo: vec3f=clamp(surfaceAlbedo,vec3f(0.1f),vec3f(1.0f));diffuseRoughnessTerm=diffuseBRDF_EON(clampedAlbedo,diffuseRoughness,NoL,NoV,LoV)*PI;diffuseRoughnessTerm=diffuseRoughnessTerm/clampedAlbedo;diffuseRoughnessTerm=mix(vec3f(1.0f),diffuseRoughnessTerm,sqrt(clamp(mag*NoV,0.0f,1.0f)));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+let H: vec3f=(irradianceView+Ls)*0.5f;let VoH: f32=dot(irradianceView,H);diffuseRoughnessTerm=vec3f(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+environmentIrradiance=environmentIrradiance.rgb*diffuseRoughnessTerm;
+#endif
+#endif
+environmentIrradiance*=reflectionInfos.x;return environmentIrradiance;}
+#ifdef REFLECTIONMAP_3D
+fn createReflectionCoords(vPositionW: vec3f,normalW: vec3f)->vec3f
+#else
+fn createReflectionCoords(vPositionW: vec3f,normalW: vec3f)->vec2f
+#endif
+{var reflectionVector: vec3f=computeReflectionCoords(vec4f(vPositionW,1.0f),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+var reflectionCoords: vec3f=reflectionVector;
+#else
+var reflectionCoords: vec2f=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0f-reflectionCoords.y;
+#endif
+return reflectionCoords;}
+fn sampleRadiance(
+alphaG: f32
+,reflectionMicrosurfaceInfos: vec3f
+,reflectionInfos: vec2f
+,geoInfo: geometryInfoOutParams
+#ifdef REFLECTIONMAP_3D
+,reflectionSampler: texture_cube<f32>
+,reflectionSamplerSampler: sampler
+,reflectionCoords: vec3f
+#else
+,reflectionSampler: texture_2d<f32>
+,reflectionSamplerSampler: sampler
+,reflectionCoords: vec2f
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#endif
+)->vec3f {var environmentRadiance: vec4f=vec4f(0.f,0.f,0.f,0.f);
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,alphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+var reflectionLOD: f32=getLinearLodFromRoughness(reflectionMicrosurfaceInfos.x,roughness);
+#else
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,alphaG);
+#endif
+reflectionLOD=reflectionLOD*reflectionMicrosurfaceInfos.y+reflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+environmentRadiance=vec4f(radiance(alphaG,reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionFilteringInfo),1.0f);
+#else
+environmentRadiance=textureSampleLevel(reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionLOD);
+#endif
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb=fromRGBD(environmentRadiance);
+#endif
+#ifdef GAMMAREFLECTION
+environmentRadiance.rgb=toLinearSpaceVec3(environmentRadiance.rgb);
+#endif
+environmentRadiance=vec4f(environmentRadiance.rgb*reflectionInfos.x,environmentRadiance.a);return environmentRadiance.rgb;}
+#if defined(ANISOTROPIC)
+fn sampleRadianceAnisotropic(
+alphaG: f32
+,reflectionMicrosurfaceInfos: vec3f
+,reflectionInfos: vec2f
+,geoInfo: geometryInfoAnisoOutParams
+,normalW: vec3f
+,viewDirectionW: vec3f
+,positionW: vec3f
+,noise: vec3f
+,isRefraction: bool
+,ior: f32
+#ifdef REFLECTIONMAP_3D
+,reflectionSampler: texture_cube<f32>
+,reflectionSamplerSampler: sampler
+#else
+,reflectionSampler: texture_2d<f32>
+,reflectionSamplerSampler: sampler
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#endif
+)->vec3f {var environmentRadiance: vec4f=vec4f(0.f,0.f,0.f,0.f);let alphaT=alphaG*sqrt(2.0f/(1.0f+(1.0f-geoInfo.anisotropy)*(1.0f-geoInfo.anisotropy)));let alphaB=(1.0f-geoInfo.anisotropy)*alphaT;let modifiedAlphaG=alphaB;
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,modifiedAlphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+var reflectionLOD: f32=getLinearLodFromRoughness(reflectionMicrosurfaceInfos.x,roughness);
+#else
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,modifiedAlphaG);
+#endif
+reflectionLOD=reflectionLOD*reflectionMicrosurfaceInfos.y+reflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+var view=(uniforms.reflectionMatrix*vec4f(viewDirectionW,0.0f)).xyz;var tangent=(uniforms.reflectionMatrix*vec4f(geoInfo.anisotropicTangent,0.0f)).xyz;var bitangent=(uniforms.reflectionMatrix*vec4f(geoInfo.anisotropicBitangent,0.0f)).xyz;var normal=(uniforms.reflectionMatrix*vec4f(normalW,0.0f)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+view.z*=-1.0f;tangent.z*=-1.0f;bitangent.z*=-1.0f;normal.z*=-1.0f;
+#endif
+environmentRadiance =
+vec4f(radianceAnisotropic(alphaT,alphaB,reflectionSampler,reflectionSamplerSampler,
+view,tangent,
+bitangent,normal,
+reflectionFilteringInfo,noise.xy,isRefraction,ior),
+1.0f);
+#else
+const samples: i32=16;var radianceSample=vec4f(0.0);var accumulatedRadiance=vec3f(0.0);var reflectionCoords=vec3f(0.0);var sample_weight=0.0f;var total_weight=0.0f;let step=1.0f/f32(max(samples-1,1));for (var i: i32=0; i<samples; i++) {var t: f32=mix(-1.0,1.0,f32(i)*step);t+=step*2.0*noise.x;sample_weight=max(1.0-abs(t),0.001);sample_weight*=sample_weight;t*=min(4.0*alphaT*geoInfo.anisotropy,1.0);var bentNormal: vec3f;if (t<0.0) {let blend: f32=t+1.0;bentNormal=normalize(mix(-geoInfo.anisotropicTangent,normalW,blend));} else if (t>0.0) {let blend: f32=t;bentNormal=normalize(mix(normalW,geoInfo.anisotropicTangent,blend));} else {bentNormal=normalW;}
+if (isRefraction) {reflectionCoords=double_refract(-viewDirectionW,bentNormal,ior);} else {reflectionCoords=reflect(-viewDirectionW,bentNormal);}
+reflectionCoords=(uniforms.reflectionMatrix*vec4f(reflectionCoords,0.f)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionCoords.z*=-1.0f;
+#endif
+radianceSample=textureSampleLevel(reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionLOD);
+#ifdef RGBDREFLECTION
+accumulatedRadiance+=vec3f(sample_weight)*fromRGBD(radianceSample);
+#elif defined(GAMMAREFLECTION)
+accumulatedRadiance+=vec3f(sample_weight)*toLinearSpaceVec3(radianceSample.rgb);
+#else
+accumulatedRadiance+=vec3f(sample_weight)*radianceSample.rgb;
+#endif
+total_weight+=sample_weight;}
+environmentRadiance=vec4f(accumulatedRadiance/vec3f(total_weight),1.0f);
+#endif
+environmentRadiance=vec4f(environmentRadiance.rgb*reflectionInfos.xxx,environmentRadiance.a);return environmentRadiance.rgb;}
+#endif
+#endif
+#ifdef ENVIRONMENTBRDF
+fn computeDielectricIblFresnel(reflectance: ReflectanceParams,environmentBrdf: vec3f)->f32
+{let dielectricIblFresnel: f32=getReflectanceFromBRDFWithEnvLookup(vec3f(reflectance.F0),vec3f(reflectance.F90),environmentBrdf).r;let dielectricECF: f32=1.0+reflectance.F0*(1.0/environmentBrdf.y-1.0);return clamp(dielectricIblFresnel*dielectricECF,0.0,1.0);}
+fn computeConductorIblFresnel(reflectance: ReflectanceParams,environmentBrdf: vec3f)->vec3f
+{
+#if (CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR)
+let openPBRBrdf: vec3f=vec3f(environmentBrdf.xy,environmentBrdf.z/BRDF_Z_SCALE);let b: vec3f =getF82B(reflectance.coloredF0,reflectance.coloredF90);let E_F82: vec3f=getF82DirectionalAlbedo(reflectance.coloredF0,vec3f(1.0),b,openPBRBrdf);let F_avg: vec3f=getF82AverageFresnel(reflectance.coloredF0,b);let ECF: vec3f =vec3f(1.0)+F_avg*(vec3f(1.0)/openPBRBrdf.y-vec3f(1.0));return clamp(E_F82*ECF,vec3f(0.0),vec3f(1.0));
+#else
+return getReflectanceFromBRDFLookup(reflectance.coloredF0,reflectance.coloredF90,environmentBrdf);
+#endif
+}
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[t]||(r.ShaderStore.IncludesShadersStoreWGSL[t]=o),e.s(["openpbrIblFunctionsWGSL",0,{name:t,shader:o}],63189)},80899,e=>{"use strict";var r=e.i(12423);let a="openpbrSubsurfaceLayerData",i=`var subsurface_weight: f32=uniforms.vSubsurfaceWeight;var subsurface_color: vec3f=uniforms.vSubsurfaceColor.rgb;var subsurface_radius: f32=uniforms.vSubsurfaceRadius;var subsurface_radius_scale: vec3f=uniforms.vSubsurfaceRadiusScale;var subsurface_scatter_anisotropy: f32=clamp(uniforms.vSubsurfaceScatterAnisotropy,-0.9999f,0.9999f);
+#ifdef SUBSURFACE_WEIGHT
+let subsurfaceWeightFromTexture: vec4f=TEXRD(subsurfaceWeightSampler,subsurfaceWeightSamplerSampler,fragmentInputs.vSubsurfaceWeightUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_COLOR
+let subsurfaceColorFromTexture: vec4f=TEXRD(subsurfaceColorSampler,subsurfaceColorSamplerSampler,fragmentInputs.vSubsurfaceColorUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+let subsurfaceRadiusScaleFromTexture: vec4f=TEXRD(subsurfaceRadiusScaleSampler,subsurfaceRadiusScaleSamplerSampler,fragmentInputs.vSubsurfaceRadiusScaleUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_WEIGHT
+#ifdef SUBSURFACE_WEIGHT_FROM_TEXTURE_ALPHA
+subsurface_weight*=subsurfaceWeightFromTexture.a;
+#else
+subsurface_weight*=subsurfaceWeightFromTexture.r;
+#endif
+#endif
+#ifdef SUBSURFACE_COLOR
+#ifdef SUBSURFACE_COLOR_GAMMA
+subsurface_color*=toLinearSpaceVec3(subsurfaceColorFromTexture.rgb);
+#else
+subsurface_color*=subsurfaceColorFromTexture.rgb;
+#endif
+subsurface_color*=uniforms.vSubsurfaceColorInfos.y;
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+subsurface_radius_scale*=subsurfaceRadiusScaleFromTexture.rgb;
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["openpbrSubsurfaceLayerDataWGSL",0,{name:a,shader:i}])},4558,e=>{"use strict";var r=e.i(12423);let a="openpbrTransmissionLayerData",i=`var transmission_weight: f32=uniforms.vTransmissionWeight;var transmission_color: vec3f=uniforms.vTransmissionColor.rgb;var transmission_depth: f32=uniforms.vTransmissionDepth;var transmission_scatter: vec3f=uniforms.vTransmissionScatter.rgb;var transmission_scatter_anisotropy: f32=clamp(uniforms.vTransmissionScatterAnisotropy,-0.9999f,0.9999f);var transmission_dispersion_scale: f32=uniforms.vTransmissionDispersionScale;var transmission_dispersion_abbe_number: f32=uniforms.vTransmissionDispersionAbbeNumber;
+#ifdef TRANSMISSION_WEIGHT
+let transmissionWeightFromTexture: vec4f=TEXRD(transmissionWeightSampler,transmissionWeightSamplerSampler,fragmentInputs.vTransmissionWeightUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_COLOR
+let transmissionColorFromTexture: vec4f=TEXRD(transmissionColorSampler,transmissionColorSamplerSampler,fragmentInputs.vTransmissionColorUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DEPTH
+let transmissionDepthFromTexture: vec4f=TEXRD(transmissionDepthSampler,transmissionDepthSamplerSampler,fragmentInputs.vTransmissionDepthUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_SCATTER
+let transmissionScatterFromTexture: vec4f=TEXRD(transmissionScatterSampler,transmissionScatterSamplerSampler,fragmentInputs.vTransmissionScatterUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+let transmissionDispersionScaleFromTexture: vec4f=TEXRD(transmissionDispersionScaleSampler,transmissionDispersionScaleSamplerSampler,fragmentInputs.vTransmissionDispersionScaleUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_WEIGHT
+transmission_weight*=transmissionWeightFromTexture.r;
+#endif
+#ifdef TRANSMISSION_COLOR
+#ifdef TRANSMISSION_COLOR_GAMMA
+transmission_color*=toLinearSpaceVec3(transmissionColorFromTexture.rgb);
+#else
+transmission_color*=transmissionColorFromTexture.rgb;
+#endif
+transmission_color*=uniforms.vTransmissionColorInfos.y;
+#endif
+#ifdef TRANSMISSION_DEPTH
+transmission_depth*=transmissionDepthFromTexture.r;
+#endif
+#ifdef TRANSMISSION_SCATTER
+transmission_scatter*=transmissionScatterFromTexture.rgb;
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+transmission_dispersion_scale*=transmissionDispersionScaleFromTexture.r;
+#endif
+`;r.ShaderStore.IncludesShadersStoreWGSL[a]||(r.ShaderStore.IncludesShadersStoreWGSL[a]=i),e.s(["openpbrTransmissionLayerDataWGSL",0,{name:a,shader:i}])},89511,e=>{"use strict";var r=e.i(12423),a=e.i(35182),i=e.i(28657),f=e.i(67367),n=e.i(78875),t=e.i(4357),o=e.i(90780),c=e.i(60106),s=e.i(61202),l=e.i(30420),d=e.i(82518),v=e.i(23356),m=e.i(22389),u=e.i(63189),p=e.i(63406),S=e.i(23344),E=e.i(80899),R=e.i(4558);let I="geometryPixelShader",N=`#ifdef BUMP
+varying vWorldView0: vec4f;varying vWorldView1: vec4f;varying vWorldView2: vec4f;varying vWorldView3: vec4f;varying vNormalW: vec3f;
+#else
+varying vNormalV: vec3f;
+#endif
+varying vViewPos: vec4f;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vPositionW: vec3f;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+varying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;
+#endif
+#ifdef NEED_UV
+varying vUV: vec2f;
+#endif
+#ifdef BUMP
+uniform vBumpInfos: vec3f;uniform vTangentSpaceParams: vec2f;
+#endif
+#if defined(REFLECTIVITY)
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+var reflectivitySamplerSampler: sampler;var reflectivitySampler: texture_2d<f32>;varying vReflectivityUV: vec2f;
+#else
+#ifdef METALLIC_TEXTURE
+var metallicSamplerSampler: sampler;var metallicSampler: texture_2d<f32>;varying vMetallicUV: vec2f;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+var roughnessSamplerSampler: sampler;var roughnessSampler: texture_2d<f32>;varying vRoughnessUV: vec2f;
+#endif
+#endif
+#ifdef ALBEDOTEXTURE
+varying vAlbedoUV: vec2f;var albedoSamplerSampler: sampler;var albedoSampler: texture_2d<f32>;
+#endif
+#ifdef REFLECTIVITYCOLOR
+uniform reflectivityColor: vec3f;
+#endif
+#ifdef ALBEDOCOLOR
+uniform albedoColor: vec3f;
+#endif
+#ifdef METALLIC
+uniform metallic: f32;
+#endif
+#if defined(ROUGHNESS) || defined(GLOSSINESS)
+uniform glossiness: f32;
+#endif
+#endif
+#if defined(ALPHATEST) && defined(NEED_UV)
+var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+#endif
+#include<clipPlaneFragmentDeclaration>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<helperFunctions>
+#ifdef IRRADIANCE
+#include<pbrFragmentReflectionDeclaration>
+#ifdef REFLECTION
+#ifdef USEIRRADIANCEMAP
+#include<sceneUboDeclaration>
+uniform reflectionMatrix: mat4x4f;uniform vReflectionInfos: vec2f;uniform vReflectionDominantDirection: vec3f;
+#include<pbrBRDFFunctions>
+#include<openpbrDielectricReflectance>
+#include<pbrIBLFunctions>
+#include<reflectionFunction>
+#include<openpbrGeometryInfo>
+#include<openpbrIblFunctions>
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+varying vEnvironmentIrradiance: vec3f;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+var iblShadowSampler: texture_2d<f32>;var iblShadowSamplerSampler: sampler;uniform shadowTextureSize: vec2f;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+uniform vSubsurfaceWeight: f32;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)
+uniform vSubsurfaceScatterAnisotropy: f32;uniform vTransmissionWeight: f32;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)
+uniform vTransmissionScatterAnisotropy: f32;
+#endif
+#endif
+#endif
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<0.4) {discard;}
+#endif
+var normalOutput: vec3f;
+#ifdef BUMP
+var normalW: vec3f=normalize(input.vNormalW);
+#include<bumpFragment>
+#ifdef NORMAL_WORLDSPACE
+normalOutput=normalW;
+#else
+normalOutput=normalize( (mat4x4f(input.vWorldView0,input.vWorldView1,input.vWorldView2,input.vWorldView3)* vec4f(normalW,0.0)).xyz);
+#endif
+#elif defined(HAS_NORMAL_ATTRIBUTE)
+normalOutput=normalize(input.vNormalV);
+#elif defined(POSITION)
+normalOutput=normalize(-cross(dpdx(input.vPositionW),dpdy(input.vPositionW)));
+#endif
+#ifdef ENCODE_NORMAL
+normalOutput=normalOutput*0.5+0.5;
+#endif
+var fragData: array<vec4<f32>,SCENE_MRT_COUNT>;
+#ifdef DEPTH
+fragData[DEPTH_INDEX]=vec4f(input.vViewPos.z/input.vViewPos.w,0.0,0.0,1.0);
+#endif
+#ifdef NORMAL
+fragData[NORMAL_INDEX]=vec4f(normalOutput,1.0);
+#endif
+#ifdef SCREENSPACE_DEPTH
+fragData[SCREENSPACE_DEPTH_INDEX]=vec4f(fragmentInputs.position.z,0.0,0.0,1.0);
+#endif
+#ifdef POSITION
+fragData[POSITION_INDEX]= vec4f(input.vPositionW,1.0);
+#endif
+#ifdef VELOCITY
+var a: vec2f=(input.vCurrentPosition.xy/input.vCurrentPosition.w)*0.5+0.5;var b: vec2f=(input.vPreviousPosition.xy/input.vPreviousPosition.w)*0.5+0.5;var velocity: vec2f=abs(a-b);velocity= vec2f(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;fragData[VELOCITY_INDEX]= vec4f(velocity,0.0,1.0);
+#endif
+#ifdef VELOCITY_LINEAR
+var velocity : vec2f=vec2f(0.5)*((input.vPreviousPosition.xy /
+input.vPreviousPosition.w) -
+(input.vCurrentPosition.xy /
+input.vCurrentPosition.w));fragData[VELOCITY_LINEAR_INDEX]=vec4f(velocity,0.0,1.0);
+#endif
+#ifdef REFLECTIVITY
+var reflectivity: vec4f= vec4f(0.0,0.0,0.0,1.0);
+#ifdef METALLICWORKFLOW
+var metal: f32=1.0;var roughness: f32=1.0;
+#ifdef ORMTEXTURE
+metal*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).b;roughness*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).g;
+#else
+#ifdef METALLIC_TEXTURE
+metal*=textureSample(metallicSampler,metallicSamplerSampler,input.vMetallicUV).r;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+roughness*=textureSample(roughnessSampler,roughnessSamplerSampler,input.vRoughnessUV).r;
+#endif
+#endif
+#ifdef METALLIC
+metal*=uniforms.metallic;
+#endif
+#ifdef ROUGHNESS
+roughness*=(1.0-uniforms.glossiness); 
+#endif
+reflectivity=vec4f(reflectivity.rgb,reflectivity.a-roughness);var color: vec3f= vec3f(1.0);
+#ifdef ALBEDOTEXTURE
+color=textureSample(albedoSampler,albedoSamplerSampler,input.vAlbedoUV).rgb;
+#ifdef GAMMAALBEDO
+color=toLinearSpaceVec4(color);
+#endif
+#endif
+#ifdef ALBEDOCOLOR
+color*=uniforms.albedoColor.xyz;
+#endif
+reflectivity=vec4f(mix( vec3f(0.04),color,metal),reflectivity.a);
+#else
+#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+reflectivity=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV);
+#ifdef GAMMAREFLECTIVITYTEXTURE
+reflectivity=vec4f(toLinearSpaceVec3(reflectivity.rgb),reflectivity.a);
+#endif
+#else 
+#ifdef REFLECTIVITYCOLOR
+reflectivity=vec4f(toLinearSpaceVec3(uniforms.reflectivityColor.xyz),1.0);
+#endif
+#endif
+#ifdef GLOSSINESSS
+reflectivity=vec4f(reflectivity.rgb,reflectivity.a*glossiness); 
+#endif
+#endif
+fragData[REFLECTIVITY_INDEX]=reflectivity;
+#endif
+#ifdef IRRADIANCE
+var irradiance: vec3f=vec3f(0.0);var irradiance_alpha: f32=1.0;
+#ifdef REFLECTION
+#ifdef IRRADIANCE_SCATTER_MASK
+#ifndef BUMP
+let uvOffset: vec2f=vec2f(0.0);
+#endif
+var vSubsurfaceColor: vec3f=vec3f(1.0);var vSubsurfaceRadius: f32=0.0;var vSubsurfaceRadiusScale: vec3f=vec3f(1.0);
+#include<openpbrSubsurfaceLayerData>(uniforms.vSubsurfaceColor,vSubsurfaceColor,uniforms.vSubsurfaceRadius,vSubsurfaceRadius,uniforms.vSubsurfaceRadiusScale,vSubsurfaceRadiusScale)
+var vTransmissionDepth: f32=1.0;var vTransmissionColor: vec3f=vec3f(1.0);var vTransmissionScatter: vec3f=vec3f(0.0);var vTransmissionDispersionScale: f32=0.0;var vTransmissionDispersionAbbeNumber: f32=0.0;
+#include<openpbrTransmissionLayerData>(uniforms.vTransmissionDispersionScale,vTransmissionDispersionScale,uniforms.vTransmissionDispersionAbbeNumber,vTransmissionDispersionAbbeNumber,uniforms.vTransmissionColor,vTransmissionColor,uniforms.vTransmissionDepth,vTransmissionDepth,uniforms.vTransmissionScatter\\.,vTransmissionScatter.)
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+#ifdef COLORED_IBL_SHADOWS
+let iblShadowValue: vec3f=textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).rgb;
+#else
+let iblShadowValue: vec3f=vec3f(textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).r);
+#endif
+#endif
+#if defined(USEIRRADIANCEMAP)
+#ifdef IRRADIANCE_SCATTER_MASK
+let bendAmount: f32=subsurface_weight*-min(subsurface_scatter_anisotropy,0.0);let mixedBendAmount: f32=mix(bendAmount,-min(transmission_scatter_anisotropy,0.0),transmission_weight);let viewVector: vec3f=normalize(scene.vEyePosition.xyz-input.vPositionW);let bentNormal: vec3f=mix(normalOutput,viewVector,mixedBendAmount*dot(normalOutput,viewVector));
+#else
+let bentNormal: vec3f=normalOutput;
+#endif
+irradiance=sampleIrradiance(
+bentNormal
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,input.vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,uniforms.reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+,irradianceSamplerSampler
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,uniforms.vReflectionDominantDirection
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,uniforms.vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+,icdfSamplerSampler
+#endif
+#endif
+,uniforms.vReflectionInfos
+,input.vViewPos.xyz
+,1.0
+,vec3f(1.0)
+);
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+irradiance=input.vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+irradiance*=iblShadowValue;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+irradiance_alpha=min(subsurface_weight+transmission_weight,1.0);
+#endif
+#endif
+fragData[IRRADIANCE_INDEX]=vec4f(irradiance,irradiance_alpha);
+#endif
+#if SCENE_MRT_COUNT>0
+fragmentOutputs.fragData0=fragData[0];
+#endif
+#if SCENE_MRT_COUNT>1
+fragmentOutputs.fragData1=fragData[1];
+#endif
+#if SCENE_MRT_COUNT>2
+fragmentOutputs.fragData2=fragData[2];
+#endif
+#if SCENE_MRT_COUNT>3
+fragmentOutputs.fragData3=fragData[3];
+#endif
+#if SCENE_MRT_COUNT>4
+fragmentOutputs.fragData4=fragData[4];
+#endif
+#if SCENE_MRT_COUNT>5
+fragmentOutputs.fragData5=fragData[5];
+#endif
+#if SCENE_MRT_COUNT>6
+fragmentOutputs.fragData6=fragData[6];
+#endif
+#if SCENE_MRT_COUNT>7
+fragmentOutputs.fragData7=fragData[7];
+#endif
+}
+`;for(let e of(r.ShaderStore.ShadersStoreWGSL[I]||(r.ShaderStore.ShadersStoreWGSL[I]=N),[a.clipPlaneFragmentDeclarationWGSL,i.bumpFragmentMainFunctionsWGSL,f.samplerFragmentDeclarationWGSL,n.bumpFragmentFunctionsWGSL,t.helperFunctionsWGSL,o.pbrFragmentReflectionDeclarationWGSL,c.sceneUboDeclarationWGSL,s.pbrBRDFFunctionsWGSL,l.openpbrDielectricReflectanceWGSL,d.pbrIBLFunctionsWGSL,v.reflectionFunctionWGSL,m.openpbrGeometryInfoWGSL,u.openpbrIblFunctionsWGSL,p.clipPlaneFragmentWGSL,S.bumpFragmentWGSL,E.openpbrSubsurfaceLayerDataWGSL,R.openpbrTransmissionLayerDataWGSL]))r.ShaderStore.IncludesShadersStoreWGSL[e.name]||(r.ShaderStore.IncludesShadersStoreWGSL[e.name]=e.shader);e.s(["geometryPixelShaderWGSL",0,{name:I,shader:N}])}]);