@vived/component-abb-6700 1.0.0

package/dist/pbrDebug-Bk3sPoEG.js

@@ -0,0 +1,719 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+import "./logDepthDeclaration-Bwm-3KyB.js";
+import "./oitFragment-DH3h3T6x.js";
+const t = "pbrFragmentExtraDeclaration", v = `varying vPositionW: vec3f;
+#if DEBUGMODE>0
+varying vClipSpacePosition: vec4f;
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#ifdef NORMAL
+varying vNormalW: vec3f;
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+varying vEnvironmentIrradiance: vec3f;
+#endif
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vColor: vec4f;
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+varying vViewDepth: f32;
+#endif
+`;
+e.IncludesShadersStoreWGSL[t] || (e.IncludesShadersStoreWGSL[t] = v);
+const i = "subSurfaceScatteringFunctions", g = `fn testLightingForSSS(diffusionProfile: f32)->bool
+{return diffusionProfile<1.;}`;
+e.IncludesShadersStoreWGSL[i] || (e.IncludesShadersStoreWGSL[i] = g);
+const f = "importanceSampling", h = `fn hemisphereCosSample(u: vec2f)->vec3f {var phi: f32=2.*PI*u.x;var cosTheta2: f32=1.-u.y;var cosTheta: f32=sqrt(cosTheta2);var sinTheta: f32=sqrt(1.-cosTheta2);return vec3f(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}
+fn hemisphereImportanceSampleDggx(u: vec2f,a: f32)->vec3f {var phi: f32=2.*PI*u.x;var cosTheta2: f32=(1.-u.y)/(1.+(a+1.)*((a-1.)*u.y));var cosTheta: f32=sqrt(cosTheta2);var sinTheta: f32=sqrt(1.-cosTheta2);return vec3f(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}
+fn hemisphereImportanceSampleDggxAnisotropic(Xi: vec2f,alphaTangent: f32,alphaBitangent: f32)->vec3f
+{let alphaT: f32=max(alphaTangent,0.0001);let alphaB: f32=max(alphaBitangent,0.0001);var phi: f32=atan(alphaB/alphaT*tan(2.0f*PI*Xi.x));if (Xi.x>0.5) {phi+=PI; }
+let cosPhi: f32=cos(phi);let sinPhi: f32=sin(phi);let alpha2: f32=(cosPhi*cosPhi)/(alphaT*alphaT) +
+(sinPhi*sinPhi)/(alphaB*alphaB);let tanTheta2: f32=Xi.y/(1.0f-Xi.y)/alpha2;let cosTheta: f32=1.0f/sqrt(1.0f+tanTheta2);let sinTheta: f32=sqrt(max(0.0f,1.0f-cosTheta*cosTheta));return vec3f(sinTheta*cosPhi,sinTheta*sinPhi,cosTheta);}
+fn hemisphereImportanceSampleDCharlie(u: vec2f,a: f32)->vec3f { 
+var phi: f32=2.*PI*u.x;var sinTheta: f32=pow(u.y,a/(2.*a+1.));var cosTheta: f32=sqrt(1.-sinTheta*sinTheta);return vec3f(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}`;
+e.IncludesShadersStoreWGSL[f] || (e.IncludesShadersStoreWGSL[f] = h);
+const r = "pbrHelperFunctions", p = `#define MINIMUMVARIANCE 0.0005
+#ifndef TEXRD_DEFINED
+fn TEXRD(t: texture_2d<f32>,ts: sampler,uv: vec2f)->vec4f {return textureSample(t,ts,uv);}
+#define TEXRD_DEFINED
+#endif
+fn convertRoughnessToAverageSlope(roughness: f32)->f32
+{return roughness*roughness+MINIMUMVARIANCE;}
+fn fresnelGrazingReflectance(reflectance0: f32)->f32 {var reflectance90: f32=saturate(reflectance0*25.0);return reflectance90;}
+fn getAARoughnessFactors(normalVector: vec3f)->vec2f {
+#ifdef SPECULARAA
+var nDfdx: vec3f=dpdx(normalVector.xyz);var nDfdy: vec3f=dpdy(normalVector.xyz);var slopeSquare: f32=max(dot(nDfdx,nDfdx),dot(nDfdy,nDfdy));var geometricRoughnessFactor: f32=pow(saturate(slopeSquare),0.333);var geometricAlphaGFactor: f32=sqrt(slopeSquare);geometricAlphaGFactor*=0.75;return vec2f(geometricRoughnessFactor,geometricAlphaGFactor);
+#else
+return vec2f(0.);
+#endif
+}
+#ifdef ANISOTROPIC
+#ifdef ANISOTROPIC_LEGACY
+fn getAnisotropicRoughness(alphaG: f32,anisotropy: f32)->vec2f {var alphaT: f32=max(alphaG*(1.0+anisotropy),MINIMUMVARIANCE);var alphaB: f32=max(alphaG*(1.0-anisotropy),MINIMUMVARIANCE);return vec2f(alphaT,alphaB);}
+fn getAnisotropicBentNormals(T: vec3f,B: vec3f,N: vec3f,V: vec3f,anisotropy: f32,roughness: f32)->vec3f {var anisotropicFrameDirection: vec3f=select(T,B,anisotropy>=0.0);var anisotropicFrameTangent: vec3f=cross(normalize(anisotropicFrameDirection),V);var anisotropicFrameNormal: vec3f=cross(anisotropicFrameTangent,anisotropicFrameDirection);var anisotropicNormal: vec3f=normalize(mix(N,anisotropicFrameNormal,abs(anisotropy)));return anisotropicNormal;}
+#elif ANISOTROPIC_OPENPBR
+fn getAnisotropicRoughness(alphaG: f32,anisotropy: f32)->vec2f {var alphaT: f32=max(alphaG*alphaG*sqrt(2.0/(1.0+(1.0-anisotropy)*(1.0-anisotropy))),MINIMUMVARIANCE);var alphaB: f32=max(alphaT*(1.0-anisotropy),MINIMUMVARIANCE);return vec2f(alphaT,alphaB);}
+#else
+fn getAnisotropicRoughness(alphaG: f32,anisotropy: f32)->vec2f {var alphaT: f32=max(mix(alphaG,1.0,anisotropy*anisotropy),MINIMUMVARIANCE);var alphaB: f32=max(alphaG,MINIMUMVARIANCE);return vec2f(alphaT,alphaB);}
+fn getAnisotropicBentNormals(T: vec3f,B: vec3f,N: vec3f,V: vec3f,anisotropy: f32,roughness: f32)->vec3f {var bentNormal: vec3f=cross(B,V);bentNormal=normalize(cross(bentNormal,B));var sq=1.0-anisotropy*(1.0-roughness);var a: f32=sq*sq*sq*sq;bentNormal=normalize(mix(bentNormal,N,a));return bentNormal;}
+#endif
+#endif
+#if defined(CLEARCOAT) || defined(SS_REFRACTION)
+fn cocaLambertVec3(alpha: vec3f,distance: f32)->vec3f {return exp(-alpha*distance);}
+fn cocaLambert(NdotVRefract: f32,NdotLRefract: f32,alpha: vec3f,thickness: f32)->vec3f {return cocaLambertVec3(alpha,(thickness*((NdotLRefract+NdotVRefract)/(NdotLRefract*NdotVRefract))));}
+fn computeColorAtDistanceInMedia(color: vec3f,distance: f32)->vec3f {return -log(color)/distance;}
+fn computeClearCoatAbsorption(NdotVRefract: f32,NdotLRefract: f32,clearCoatColor: vec3f,clearCoatThickness: f32,clearCoatIntensity: f32)->vec3f {var clearCoatAbsorption: vec3f=mix( vec3f(1.0),
+cocaLambert(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness),
+clearCoatIntensity);return clearCoatAbsorption;}
+#endif
+#ifdef MICROSURFACEAUTOMATIC
+fn computeDefaultMicroSurface(microSurface: f32,reflectivityColor: vec3f)->f32
+{const kReflectivityNoAlphaWorkflow_SmoothnessMax: f32=0.95;var reflectivityLuminance: f32=getLuminance(reflectivityColor);var reflectivityLuma: f32=sqrt(reflectivityLuminance);var resultMicroSurface=reflectivityLuma*kReflectivityNoAlphaWorkflow_SmoothnessMax;return resultMicroSurface;}
+#endif
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = p);
+const n = "pbrDirectLightingSetupFunctions", E = `struct preLightingInfo
+{lightOffset: vec3f,
+lightDistanceSquared: f32,
+lightDistance: f32,
+attenuation: f32,
+L: vec3f,
+H: vec3f,
+NdotV: f32,
+NdotLUnclamped: f32,
+NdotL: f32,
+VdotH: f32,
+LdotV: f32,
+roughness: f32,
+diffuseRoughness: f32,
+surfaceAlbedo: vec3f,
+#ifdef IRIDESCENCE
+iridescenceIntensity: f32
+#endif
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+areaLightDiffuse: vec3f,
+#ifdef SPECULARTERM
+areaLightSpecular: vec3f,
+areaLightFresnel: vec4f
+#endif
+#endif
+};fn computePointAndSpotPreLightingInfo(lightData: vec4f,V: vec3f,N: vec3f,posW: vec3f)->preLightingInfo {var result: preLightingInfo;result.lightOffset=lightData.xyz-posW;result.lightDistanceSquared=dot(result.lightOffset,result.lightOffset);result.lightDistance=sqrt(result.lightDistanceSquared);result.L=normalize(result.lightOffset);result.H=normalize(V+result.L);result.VdotH=saturate(dot(V,result.H));result.NdotLUnclamped=dot(N,result.L);result.NdotL=saturateEps(result.NdotLUnclamped);return result;}
+fn computeDirectionalPreLightingInfo(lightData: vec4f,V: vec3f,N: vec3f)->preLightingInfo {var result: preLightingInfo;result.lightDistance=length(-lightData.xyz);result.L=normalize(-lightData.xyz);result.H=normalize(V+result.L);result.VdotH=saturate(dot(V,result.H));result.NdotLUnclamped=dot(N,result.L);result.NdotL=saturateEps(result.NdotLUnclamped);result.LdotV=dot(result.L,V);return result;}
+fn computeHemisphericPreLightingInfo(lightData: vec4f,V: vec3f,N: vec3f)->preLightingInfo {var result: preLightingInfo;result.NdotL=dot(N,lightData.xyz)*0.5+0.5;result.NdotL=saturateEps(result.NdotL);result.NdotLUnclamped=result.NdotL;
+#ifdef SPECULARTERM
+result.L=normalize(lightData.xyz);result.H=normalize(V+result.L);result.VdotH=saturate(dot(V,result.H));
+#endif
+return result;}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+#include<ltcHelperFunctions>
+var areaLightsLTC1SamplerSampler: sampler;var areaLightsLTC1Sampler: texture_2d<f32>;var areaLightsLTC2SamplerSampler: sampler;var areaLightsLTC2Sampler: texture_2d<f32>;fn computeAreaPreLightingInfo(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightCenter:vec3f,halfWidth:vec3f, halfHeight:vec3f,roughness:f32)->preLightingInfo {var result: preLightingInfo;var data: areaLightData=computeAreaLightSpecularDiffuseFresnel(ltc1,ltc1Sampler,ltc2,ltc2Sampler,viewDirectionW,vNormal,vPosition,lightCenter,halfWidth,halfHeight,roughness);
+#ifdef SPECULARTERM
+result.areaLightFresnel=data.Fresnel;result.areaLightSpecular=data.Specular;
+#endif
+result.areaLightDiffuse+=data.Diffuse;return result;}
+fn computeAreaPreLightingInfoWithTexture(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,emissionTexture:texture_2d<f32>,emissionTextureSampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightCenter:vec3f,halfWidth:vec3f, halfHeight:vec3f,roughness:f32)->preLightingInfo {var result: preLightingInfo;result.lightOffset=lightCenter-vPosition;result.lightDistanceSquared=dot(result.lightOffset,result.lightOffset);result.lightDistance=sqrt(result.lightDistanceSquared);var data: areaLightData=computeAreaLightSpecularDiffuseFresnelWithEmission(ltc1,ltc1Sampler,ltc2,ltc2Sampler,emissionTexture,emissionTextureSampler,viewDirectionW,vNormal,vPosition,lightCenter,halfWidth,halfHeight,roughness);
+#ifdef SPECULARTERM
+result.areaLightFresnel=data.Fresnel;result.areaLightSpecular=data.Specular;
+#endif
+result.areaLightDiffuse=data.Diffuse;result.LdotV=0.;result.roughness=0.;result.diffuseRoughness=0.;result.surfaceAlbedo=vec3f(0.);return result;}
+#endif
+`;
+e.IncludesShadersStoreWGSL[n] || (e.IncludesShadersStoreWGSL[n] = E);
+const o = "pbrDirectLightingFalloffFunctions", L = `fn computeDistanceLightFalloff_Standard(lightOffset: vec3f,range: f32)->f32
+{return max(0.,1.0-length(lightOffset)/range);}
+fn computeDistanceLightFalloff_Physical(lightDistanceSquared: f32)->f32
+{return 1.0/maxEps(lightDistanceSquared);}
+fn computeDistanceLightFalloff_GLTF(lightDistanceSquared: f32,inverseSquaredRange: f32)->f32
+{var lightDistanceFalloff: f32=1.0/maxEps(lightDistanceSquared);var factor: f32=lightDistanceSquared*inverseSquaredRange;var attenuation: f32=saturate(1.0-factor*factor);attenuation*=attenuation;lightDistanceFalloff*=attenuation;return lightDistanceFalloff;}
+fn computeDirectionalLightFalloff_IES(lightDirection: vec3f,directionToLightCenterW: vec3f,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->f32
+{var cosAngle: f32=dot(-lightDirection,directionToLightCenterW);var angle=acos(cosAngle)/PI;return textureSampleLevel(iesLightTexture,iesLightTextureSampler,vec2f(angle,0),0.).r;}
+fn computeDistanceLightFalloff(lightOffset: vec3f,lightDistanceSquared: f32,range: f32,inverseSquaredRange: f32)->f32
+{
+#ifdef USEPHYSICALLIGHTFALLOFF
+return computeDistanceLightFalloff_Physical(lightDistanceSquared);
+#elif defined(USEGLTFLIGHTFALLOFF)
+return computeDistanceLightFalloff_GLTF(lightDistanceSquared,inverseSquaredRange);
+#else
+return computeDistanceLightFalloff_Standard(lightOffset,range);
+#endif
+}
+fn computeDirectionalLightFalloff_Standard(lightDirection: vec3f,directionToLightCenterW: vec3f,cosHalfAngle: f32,exponent: f32)->f32
+{var falloff: f32=0.0;var cosAngle: f32=maxEps(dot(-lightDirection,directionToLightCenterW));if (cosAngle>=cosHalfAngle)
+{falloff=max(0.,pow(cosAngle,exponent));}
+return falloff;}
+fn computeDirectionalLightFalloff_Physical(lightDirection: vec3f,directionToLightCenterW: vec3f,cosHalfAngle: f32)->f32
+{const kMinusLog2ConeAngleIntensityRatio: f32=6.64385618977; 
+var concentrationKappa: f32=kMinusLog2ConeAngleIntensityRatio/(1.0-cosHalfAngle);var lightDirectionSpreadSG: vec4f= vec4f(-lightDirection*concentrationKappa,-concentrationKappa);var falloff: f32=exp2(dot( vec4f(directionToLightCenterW,1.0),lightDirectionSpreadSG));return falloff;}
+fn computeDirectionalLightFalloff_GLTF(lightDirection: vec3f,directionToLightCenterW: vec3f,lightAngleScale: f32,lightAngleOffset: f32)->f32
+{var cd: f32=dot(-lightDirection,directionToLightCenterW);var falloff: f32=saturate(cd*lightAngleScale+lightAngleOffset);falloff*=falloff;return falloff;}
+fn computeDirectionalLightFalloff(lightDirection: vec3f,directionToLightCenterW: vec3f,cosHalfAngle: f32,exponent: f32,lightAngleScale: f32,lightAngleOffset: f32)->f32
+{
+#ifdef USEPHYSICALLIGHTFALLOFF
+return computeDirectionalLightFalloff_Physical(lightDirection,directionToLightCenterW,cosHalfAngle);
+#elif defined(USEGLTFLIGHTFALLOFF)
+return computeDirectionalLightFalloff_GLTF(lightDirection,directionToLightCenterW,lightAngleScale,lightAngleOffset);
+#else
+return computeDirectionalLightFalloff_Standard(lightDirection,directionToLightCenterW,cosHalfAngle,exponent);
+#endif
+}`;
+e.IncludesShadersStoreWGSL[o] || (e.IncludesShadersStoreWGSL[o] = L);
+const a = "hdrFilteringFunctions", m = `#ifdef NUM_SAMPLES
+#if NUM_SAMPLES>0
+fn radicalInverse_VdC(value: u32)->f32 
+{var bits=(value<<16u) | (value>>16u);bits=((bits & 0x55555555u)<<1u) | ((bits & 0xAAAAAAAAu)>>1u);bits=((bits & 0x33333333u)<<2u) | ((bits & 0xCCCCCCCCu)>>2u);bits=((bits & 0x0F0F0F0Fu)<<4u) | ((bits & 0xF0F0F0F0u)>>4u);bits=((bits & 0x00FF00FFu)<<8u) | ((bits & 0xFF00FF00u)>>8u);return f32(bits)*2.3283064365386963e-10; }
+fn hammersley(i: u32,N: u32)->vec2f
+{return vec2f( f32(i)/ f32(N),radicalInverse_VdC(i));}
+fn log4(x: f32)->f32 {return log2(x)/2.;}
+fn uv_to_normal(uv: vec2f)->vec3f {var N: vec3f;var uvRange: vec2f=uv;var theta: f32=uvRange.x*2.0*PI;var phi: f32=uvRange.y*PI;N.x=cos(theta)*sin(phi);N.z=sin(theta)*sin(phi);N.y=cos(phi);return N;}
+const NUM_SAMPLES_FLOAT: f32= f32(NUM_SAMPLES);const NUM_SAMPLES_FLOAT_INVERSED: f32=1./NUM_SAMPLES_FLOAT;const K: f32=4.;fn irradiance(
+#ifdef CUSTOM_IRRADIANCE_FILTERING_INPUT
+CUSTOM_IRRADIANCE_FILTERING_INPUT
+#else
+inputTexture: texture_cube<f32>,inputSampler: sampler,
+#endif
+inputN: vec3f,
+filteringInfo: vec2f,
+diffuseRoughness: f32,
+surfaceAlbedo: vec3f,
+inputV: vec3f
+#ifdef IBL_CDF_FILTERING
+,icdfSampler: texture_2d<f32>,icdfSamplerSampler: sampler
+#endif
+)->vec3f
+{var n: vec3f=normalize(inputN);var result: vec3f= vec3f(0.0);
+#ifndef IBL_CDF_FILTERING
+var tangent: vec3f=select(vec3f(1.,0.,0.),vec3f(0.,0.,1.),abs(n.z)<0.999);tangent=normalize(cross(tangent,n));var bitangent: vec3f=cross(n,tangent);var tbn: mat3x3f= mat3x3f(tangent,bitangent,n);var tbnInverse: mat3x3f=transpose(tbn);
+#endif
+var maxLevel: f32=filteringInfo.y;var dim0: f32=filteringInfo.x;var omegaP: f32=(4.*PI)/(6.*dim0*dim0);var clampedAlbedo: vec3f=clamp(surfaceAlbedo,vec3f(0.1),vec3f(1.0));for(var i: u32=0u; i<NUM_SAMPLES; i++)
+{var Xi: vec2f=hammersley(i,NUM_SAMPLES);
+#ifdef IBL_CDF_FILTERING
+var T: vec2f;T.x=textureSampleLevel(icdfSampler,icdfSamplerSampler,vec2(Xi.x,0.0),0.0).x;T.y=textureSampleLevel(icdfSampler,icdfSamplerSampler,vec2(T.x,Xi.y),0.0).y;var Ls: vec3f=uv_to_normal(vec2f(1.0-fract(T.x+0.25),T.y));var NoL: f32=dot(n,Ls);var NoV: f32=dot(n,inputV);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+var LoV: f32=dot(Ls,inputV);
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+var H: vec3f=(inputV+Ls)*0.5;var VoH: f32=dot(inputV,H);
+#endif 
+#else
+var Ls: vec3f=hemisphereCosSample(Xi);Ls=normalize(Ls);var Ns: vec3f= vec3f(0.,0.,1.);var NoL: f32=dot(Ns,Ls);var V: vec3f=tbnInverse*inputV;var NoV: f32=dot(Ns,V);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+var LoV: f32=dot(Ls,V);
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+var H: vec3f=(V+Ls)*0.5;var VoH: f32=dot(V,H);
+#endif
+#endif
+if (NoL>0.) {
+#ifdef IBL_CDF_FILTERING
+var pdf: f32=textureSampleLevel(icdfSampler,icdfSamplerSampler,T,0.0).z;var c: vec3f=textureSampleLevel(inputTexture,inputSampler,Ls,0.0).rgb;
+#else
+var pdf_inversed: f32=PI/NoL;var omegaS: f32=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;var l: f32=log4(omegaS)-log4(omegaP)+log4(K);var mipLevel: f32=clamp(l,0.0,maxLevel);
+#ifdef CUSTOM_IRRADIANCE_FILTERING_FUNCTION
+CUSTOM_IRRADIANCE_FILTERING_FUNCTION
+#else
+var c: vec3f=textureSampleLevel(inputTexture,inputSampler,tbn*Ls,mipLevel).rgb;
+#endif
+#endif
+#ifdef GAMMA_INPUT
+c=toLinearSpaceVec3(c);
+#endif
+var diffuseRoughnessTerm: vec3f=vec3f(1.0);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+diffuseRoughnessTerm=diffuseBRDF_EON(clampedAlbedo,diffuseRoughness,NoL,NoV,LoV)*PI;
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+diffuseRoughnessTerm=vec3f(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+#ifdef IBL_CDF_FILTERING
+var light: vec3f=vec3f(0.0);if (pdf>1e-6) {light=vec3f(1.0)/vec3f(pdf)*c;}
+result+=NoL*diffuseRoughnessTerm*light;
+#else
+result+=c*diffuseRoughnessTerm;
+#endif
+}}
+result=result*NUM_SAMPLES_FLOAT_INVERSED;
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+result=result/clampedAlbedo;
+#endif
+return result;}
+fn radiance(alphaG: f32,inputTexture: texture_cube<f32>,inputSampler: sampler,inputN: vec3f,filteringInfo: vec2f)->vec3f
+{var n: vec3f=normalize(inputN);var c: vec3f=textureSampleLevel(inputTexture,inputSampler,n,0.0).rgb; 
+if (alphaG==0.) {
+#ifdef GAMMA_INPUT
+c=toLinearSpaceVec3(c);
+#endif
+return c;} else {var result: vec3f= vec3f(0.);var tangent: vec3f=select(vec3f(1.,0.,0.),vec3f(0.,0.,1.),abs(n.z)<0.999);tangent=normalize(cross(tangent,n));var bitangent: vec3f=cross(n,tangent);var tbn: mat3x3f= mat3x3f(tangent,bitangent,n);var maxLevel: f32=filteringInfo.y;var dim0: f32=filteringInfo.x;var omegaP: f32=(4.*PI)/(6.*dim0*dim0);var weight: f32=0.;for(var i: u32=0u; i<NUM_SAMPLES; i++)
+{var Xi: vec2f=hammersley(i,NUM_SAMPLES);var H: vec3f=hemisphereImportanceSampleDggx(Xi,alphaG);var NoV: f32=1.;var NoH: f32=H.z;var NoH2: f32=H.z*H.z;var NoL: f32=2.*NoH2-1.;var L: vec3f= vec3f(2.*NoH*H.x,2.*NoH*H.y,NoL);L=normalize(L);if (NoL>0.) {var pdf_inversed: f32=4./normalDistributionFunction_TrowbridgeReitzGGX(NoH,alphaG);var omegaS: f32=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;var l: f32=log4(omegaS)-log4(omegaP)+log4(K);var mipLevel: f32=clamp( f32(l),0.0,maxLevel);weight+=NoL;var c: vec3f=textureSampleLevel(inputTexture,inputSampler,tbn*L,mipLevel).rgb;
+#ifdef GAMMA_INPUT
+c=toLinearSpaceVec3(c);
+#endif
+result+=c*NoL;}}
+result=result/weight;return result;}}
+#ifdef ANISOTROPIC
+fn radianceAnisotropic(
+alphaTangent: f32, 
+alphaBitangent: f32, 
+inputTexture: texture_cube<f32>,
+inputSampler: sampler,
+inputView: vec3f, 
+inputTangent: vec3f, 
+inputBitangent: vec3f, 
+inputNormal: vec3f, 
+filteringInfo: vec2f,
+noiseInput: vec2f, 
+isRefraction: bool,
+ior: f32 
+)->vec3f {var V: vec3f=inputView;var N: vec3f=inputNormal;var T: vec3f=inputTangent;var B: vec3f=inputBitangent;var result: vec3f=vec3f(0.f);var maxLevel: f32=filteringInfo.y;var dim0: f32=filteringInfo.x;let clampedAlphaT: f32=max(alphaTangent,MINIMUMVARIANCE);let clampedAlphaB: f32=max(alphaBitangent,MINIMUMVARIANCE);var effectiveDim: f32=dim0*sqrt(clampedAlphaT*clampedAlphaB);var omegaP: f32=(4.f*PI)/(6.f*effectiveDim*effectiveDim);let noiseScale: f32=clamp(log2(f32(NUM_SAMPLES))/12.0f,0.0f,1.0f);var weight: f32=0.f;for(var i: u32=0u; i<NUM_SAMPLES; i++)
+{var Xi: vec2f=hammersley(i,NUM_SAMPLES);Xi=fract(Xi+noiseInput*mix(0.5f,0.015f,noiseScale)); 
+var H_tangent: vec3f=hemisphereImportanceSampleDggxAnisotropic(Xi,clampedAlphaT,clampedAlphaB);var H: vec3f=normalize(H_tangent.x*T+H_tangent.y*B+H_tangent.z*N);var L: vec3f;if (isRefraction) {L=refract(-V,H,1.0/ior);} else {L=reflect(-V,H);}
+var NoH: f32=max(dot(N,H),0.001f);var VoH: f32=max(dot(V,H),0.001f);var NoL: f32=max(dot(N,L),0.001f);if (NoL>0.f) {var pdf_inversed: f32=4./normalDistributionFunction_BurleyGGX_Anisotropic(
+H_tangent.z,H_tangent.x,H_tangent.y,vec2f(clampedAlphaT,clampedAlphaB)
+);var omegaS: f32=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;var l: f32=log4(omegaS)-log4(omegaP)+log4(K);var mipLevel: f32=clamp(l,0.0f,maxLevel);weight+=NoL;var c: vec3f=textureSampleLevel(inputTexture,inputSampler,L,mipLevel).rgb;
+#if GAMMA_INPUT
+c=toLinearSpaceVec3(c);
+#endif
+result+=c*NoL;}}
+result=result/weight;return result;}
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[a] || (e.IncludesShadersStoreWGSL[a] = m);
+const l = "pbrBlockReflectance0", S = `var reflectanceF0: f32=reflectivityOut.reflectanceF0;var specularEnvironmentR0: vec3f=reflectivityOut.colorReflectanceF0;var specularEnvironmentR90: vec3f= reflectivityOut.reflectanceF90;
+#ifdef ALPHAFRESNEL
+var reflectance90: f32=fresnelGrazingReflectance(reflectanceF0);specularEnvironmentR90=specularEnvironmentR90*reflectance90;
+#endif
+`;
+e.IncludesShadersStoreWGSL[l] || (e.IncludesShadersStoreWGSL[l] = S);
+const c = "pbrDirectLightingFunctions", D = `#define CLEARCOATREFLECTANCE90 1.0
+struct lightingInfo
+{diffuse: vec3f,
+#ifdef SS_TRANSLUCENCY
+diffuseTransmission: vec3f,
+#endif
+#ifdef SPECULARTERM
+specular: vec3f,
+#endif
+#ifdef CLEARCOAT
+clearCoat: vec4f,
+#endif
+#ifdef SHEEN
+sheen: vec3f
+#endif
+};fn adjustRoughnessFromLightProperties(roughness: f32,lightRadius: f32,lightDistance: f32)->f32 {
+#if defined(USEPHYSICALLIGHTFALLOFF) || defined(USEGLTFLIGHTFALLOFF)
+var lightRoughness: f32=lightRadius/lightDistance;var totalRoughness: f32=saturate(lightRoughness+roughness);return totalRoughness;
+#else
+return roughness;
+#endif
+}
+fn computeHemisphericDiffuseLighting(info: preLightingInfo,lightColor: vec3f,groundColor: vec3f)->vec3f {return mix(groundColor,lightColor,info.NdotL);}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+fn computeAreaDiffuseLighting(info: preLightingInfo,lightColor: vec3f)->vec3f {return info.areaLightDiffuse*lightColor;}
+#endif
+fn computeDiffuseLighting(info: preLightingInfo,lightColor: vec3f)->vec3f {var diffuseTerm: vec3f=vec3f(1.0/PI);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_LEGACY
+diffuseTerm=vec3f(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.roughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+diffuseTerm=vec3f(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.diffuseRoughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+var clampedAlbedo: vec3f=clamp(info.surfaceAlbedo,vec3f(0.1),vec3f(1.0));diffuseTerm=diffuseBRDF_EON(clampedAlbedo,info.diffuseRoughness,info.NdotL,info.NdotV,info.LdotV);diffuseTerm/=clampedAlbedo;
+#endif
+return diffuseTerm*info.attenuation*info.NdotL*lightColor;}
+fn computeProjectionTextureDiffuseLighting(projectionLightTexture: texture_2d<f32>,projectionLightSampler: sampler,textureProjectionMatrix: mat4x4f,posW: vec3f)->vec3f{var strq: vec4f=textureProjectionMatrix* vec4f(posW,1.0);strq/=strq.w;var textureColor: vec3f=textureSample(projectionLightTexture,projectionLightSampler,strq.xy).rgb;return toLinearSpaceVec3(textureColor);}
+#ifdef SS_TRANSLUCENCY
+fn computeDiffuseTransmittedLighting(info: preLightingInfo,lightColor: vec3f,transmittance: vec3f)->vec3f {var transmittanceNdotL=vec3f(0.0);var NdotL: f32=absEps(info.NdotLUnclamped);
+#ifndef SS_TRANSLUCENCY_LEGACY
+if (info.NdotLUnclamped<0.0) {
+#endif
+var wrapNdotL: f32=computeWrappedDiffuseNdotL(NdotL,0.02);var trAdapt: f32=step(0.,info.NdotLUnclamped);transmittanceNdotL=mix(transmittance*wrapNdotL, vec3f(wrapNdotL),trAdapt);
+#ifndef SS_TRANSLUCENCY_LEGACY
+}
+var diffuseTerm : vec3f=vec3f(1.0/PI);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_LEGACY
+diffuseTerm=vec3f(diffuseBRDF_Burley(
+info.NdotL,info.NdotV,info.VdotH,info.roughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+diffuseTerm=vec3f(diffuseBRDF_Burley(
+info.NdotL,info.NdotV,info.VdotH,info.diffuseRoughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+var clampedAlbedo: vec3f=clamp(info.surfaceAlbedo,vec3f(0.1),vec3f(1.0));diffuseTerm=diffuseBRDF_EON(clampedAlbedo,info.diffuseRoughness,
+info.NdotL,info.NdotV,info.LdotV);diffuseTerm/=clampedAlbedo;
+#endif
+return (transmittanceNdotL*diffuseTerm)*info.attenuation*lightColor;
+#else
+let diffuseTerm=diffuseBRDF_Burley(NdotL,info.NdotV,info.VdotH,info.roughness);return diffuseTerm*transmittanceNdotL*info.attenuation*lightColor;
+#endif
+}
+#endif
+#ifdef SPECULARTERM
+fn computeSpecularLighting(info: preLightingInfo,N: vec3f,reflectance0: vec3f,fresnel: vec3f,geometricRoughnessFactor: f32,lightColor: vec3f)->vec3f {var NdotH: f32=saturateEps(dot(N,info.H));var roughness: f32=max(info.roughness,geometricRoughnessFactor);var alphaG: f32=convertRoughnessToAverageSlope(roughness);var modifiedFresnel: vec3f=fresnel;
+#ifdef IRIDESCENCE
+modifiedFresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+var distribution: f32=normalDistributionFunction_TrowbridgeReitzGGX(NdotH,alphaG);
+#ifdef BRDF_V_HEIGHT_CORRELATED
+var smithVisibility: f32=smithVisibility_GGXCorrelated(info.NdotL,info.NdotV,alphaG);
+#else
+var smithVisibility: f32=smithVisibility_TrowbridgeReitzGGXFast(info.NdotL,info.NdotV,alphaG);
+#endif
+var specTerm: vec3f=modifiedFresnel*distribution*smithVisibility;return specTerm*info.attenuation*info.NdotL*lightColor;}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+fn computeAreaSpecularLighting(info: preLightingInfo,specularColor: vec3f,reflectance0: vec3f,reflectance90: vec3f)->vec3f {var fresnel:vec3f =reflectance0*specularColor*info.areaLightFresnel.x+( vec3f( 1.0 )-specularColor )*info.areaLightFresnel.y*reflectance90;return specularColor*fresnel*info.areaLightSpecular;}
+#endif
+#endif
+#ifdef FUZZ
+fn evalFuzz(L: vec3f,NdotL: f32,NdotV: f32,T: vec3f,B: vec3f,ltcLut: vec3f)->f32
+{if (NdotL<=0.0f || NdotV<=0.0f) {return 0.0f;}
+let M=mat3x3f(
+vec3f(ltcLut.r,0.0f,0.0f),
+vec3f(ltcLut.g,1.0f,0.0f),
+vec3f(0.0f,0.0f,1.0f)
+);let Llocal: vec3f=vec3f(dot(L,T),dot(L,B),NdotL);let Lwarp: vec3f=normalize(M*Llocal);let cosThetaWarp: f32=max(Lwarp.z,0.0f);return cosThetaWarp*NdotL;}
+#endif
+#if defined(ANISOTROPIC) && defined(ANISOTROPIC_OPENPBR)
+fn computeAnisotropicSpecularLighting(info: preLightingInfo,V: vec3f,N: vec3f,T: vec3f,B: vec3f,anisotropy: f32,geometricRoughnessFactor: f32,lightColor: vec3f)->vec3f {var NdotH: f32=saturateEps(dot(N,info.H));var TdotH: f32=dot(T,info.H);var BdotH: f32=dot(B,info.H);var TdotV: f32=dot(T,V);var BdotV: f32=dot(B,V);var TdotL: f32=dot(T,info.L);var BdotL: f32=dot(B,info.L);var alphaG: f32=convertRoughnessToAverageSlope(info.roughness);var alphaTB: vec2f=getAnisotropicRoughness(alphaG,anisotropy);var distribution: f32=normalDistributionFunction_BurleyGGX_Anisotropic(NdotH,TdotH,BdotH,alphaTB);var smithVisibility: f32=smithVisibility_GGXCorrelated_Anisotropic(info.NdotL,info.NdotV,TdotV,BdotV,TdotL,BdotL,alphaTB);var specTerm: vec3f=vec3f(distribution*smithVisibility);return specTerm*info.attenuation*info.NdotL*lightColor;}
+#elif defined(ANISOTROPIC)
+fn computeAnisotropicSpecularLighting(info: preLightingInfo,V: vec3f,N: vec3f,T: vec3f,B: vec3f,anisotropy: f32,reflectance0: vec3f,reflectance90: vec3f,geometricRoughnessFactor: f32,lightColor: vec3f)->vec3f {var NdotH: f32=saturateEps(dot(N,info.H));var TdotH: f32=dot(T,info.H);var BdotH: f32=dot(B,info.H);var TdotV: f32=dot(T,V);var BdotV: f32=dot(B,V);var TdotL: f32=dot(T,info.L);var BdotL: f32=dot(B,info.L);var alphaG: f32=convertRoughnessToAverageSlope(info.roughness);var alphaTB: vec2f=getAnisotropicRoughness(alphaG,anisotropy);alphaTB=max(alphaTB,vec2f(geometricRoughnessFactor*geometricRoughnessFactor));var fresnel: vec3f=fresnelSchlickGGXVec3(info.VdotH,reflectance0,reflectance90);
+#ifdef IRIDESCENCE
+fresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+var distribution: f32=normalDistributionFunction_BurleyGGX_Anisotropic(NdotH,TdotH,BdotH,alphaTB);var smithVisibility: f32=smithVisibility_GGXCorrelated_Anisotropic(info.NdotL,info.NdotV,TdotV,BdotV,TdotL,BdotL,alphaTB);var specTerm: vec3f=fresnel*distribution*smithVisibility;return specTerm*info.attenuation*info.NdotL*lightColor;}
+#endif
+#ifdef CLEARCOAT
+fn computeClearCoatLighting(info: preLightingInfo,Ncc: vec3f,geometricRoughnessFactor: f32,clearCoatIntensity: f32,lightColor: vec3f)->vec4f {var NccdotL: f32=saturateEps(dot(Ncc,info.L));var NccdotH: f32=saturateEps(dot(Ncc,info.H));var clearCoatRoughness: f32=max(info.roughness,geometricRoughnessFactor);var alphaG: f32=convertRoughnessToAverageSlope(clearCoatRoughness);var fresnel: f32=fresnelSchlickGGX(info.VdotH,uniforms.vClearCoatRefractionParams.x,CLEARCOATREFLECTANCE90);fresnel*=clearCoatIntensity;var distribution: f32=normalDistributionFunction_TrowbridgeReitzGGX(NccdotH,alphaG);var kelemenVisibility: f32=visibility_Kelemen(info.VdotH);var clearCoatTerm: f32=fresnel*distribution*kelemenVisibility;return vec4f(
+clearCoatTerm*info.attenuation*NccdotL*lightColor,
+1.0-fresnel
+);}
+fn computeClearCoatLightingAbsorption(NdotVRefract: f32,L: vec3f,Ncc: vec3f,clearCoatColor: vec3f,clearCoatThickness: f32,clearCoatIntensity: f32)->vec3f {var LRefract: vec3f=-refract(L,Ncc,uniforms.vClearCoatRefractionParams.y);var NdotLRefract: f32=saturateEps(dot(Ncc,LRefract));var absorption: vec3f=computeClearCoatAbsorption(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness,clearCoatIntensity);return absorption;}
+#endif
+#ifdef SHEEN
+fn computeSheenLighting(info: preLightingInfo,N: vec3f,reflectance0: vec3f,reflectance90: vec3f,geometricRoughnessFactor: f32,lightColor: vec3f)->vec3f {var NdotH: f32=saturateEps(dot(N,info.H));var roughness: f32=max(info.roughness,geometricRoughnessFactor);var alphaG: f32=convertRoughnessToAverageSlope(roughness);var fresnel: f32=1.;var distribution: f32=normalDistributionFunction_CharlieSheen(NdotH,alphaG);/*#ifdef SHEEN_SOFTER
+var visibility: f32=visibility_CharlieSheen(info.NdotL,info.NdotV,alphaG);
+#else */
+var visibility: f32=visibility_Ashikhmin(info.NdotL,info.NdotV);/* #endif */
+var sheenTerm: f32=fresnel*distribution*visibility;return sheenTerm*info.attenuation*info.NdotL*lightColor;}
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+#include<clusteredLightingFunctions>
+fn computeClusteredLighting(
+lightDataTexture: texture_2d<f32>,
+tileMaskBuffer: ptr<storage,array<u32>>,
+lightData: vec4f,
+sliceRange: vec2u,
+V: vec3f,
+N: vec3f,
+posW: vec3f,
+surfaceAlbedo: vec3f,
+reflectivityOut: reflectivityOutParams,
+#ifdef IRIDESCENCE
+iridescenceIntensity: f32,
+#endif
+#ifdef SS_TRANSLUCENCY
+subSurfaceOut: subSurfaceOutParams,
+#endif
+#ifdef SPECULARTERM
+AARoughnessFactor: f32,
+#endif
+#ifdef ANISOTROPIC
+anisotropicOut: anisotropicOutParams,
+#endif
+#ifdef SHEEN
+sheenOut: sheenOutParams,
+#endif
+#ifdef CLEARCOAT
+clearcoatOut: clearcoatOutParams,
+#endif
+)->lightingInfo {let NdotV=absEps(dot(N,V));
+#include<pbrBlockReflectance0>
+#ifdef CLEARCOAT
+specularEnvironmentR0=clearcoatOut.specularEnvironmentR0;
+#endif
+var result: lightingInfo;let tilePosition=vec2u(fragmentInputs.position.xy*lightData.xy);let maskResolution=vec2u(lightData.zw);var tileIndex=(tilePosition.x*maskResolution.x+tilePosition.y)*maskResolution.y;let batchRange=sliceRange/CLUSTLIGHT_BATCH;var batchOffset=batchRange.x*CLUSTLIGHT_BATCH;tileIndex+=batchRange.x;for (var i=batchRange.x; i<=batchRange.y; i+=1) {var mask=tileMaskBuffer[tileIndex];tileIndex+=1;let maskOffset=max(sliceRange.x,batchOffset)-batchOffset; 
+let maskWidth=min(sliceRange.y-batchOffset+1,CLUSTLIGHT_BATCH);mask=extractBits(mask,maskOffset,maskWidth);while mask != 0 {let trailing=firstTrailingBit(mask);mask ^= 1u<<trailing;let light=getClusteredLight(lightDataTexture,batchOffset+maskOffset+trailing);var preInfo=computePointAndSpotPreLightingInfo(light.vLightData,V,N,posW);preInfo.NdotV=NdotV;preInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light.vLightFalloff.x,light.vLightFalloff.y);if light.vLightDirection.w>=0.0 {preInfo.attenuation*=computeDirectionalLightFalloff(light.vLightDirection.xyz,preInfo.L,light.vLightDirection.w,light.vLightData.w,light.vLightFalloff.z,light.vLightFalloff.w);}
+preInfo.roughness=adjustRoughnessFromLightProperties(reflectivityOut.roughness,light.vLightSpecular.a,preInfo.lightDistance);preInfo.diffuseRoughness=reflectivityOut.diffuseRoughness;preInfo.surfaceAlbedo=surfaceAlbedo;
+#ifdef IRIDESCENCE
+preInfo.iridescenceIntensity=iridescenceIntensity;
+#endif
+var info: lightingInfo;
+#ifdef SS_TRANSLUCENCY
+#ifdef SS_TRANSLUCENCY_LEGACY
+info.diffuse=computeDiffuseTransmittedLighting(preInfo,light.vLightDiffuse.rgb,subSurfaceOut.transmittance);info.diffuseTransmission=vec3(0);
+#else
+info.diffuse=computeDiffuseLighting(preInfo,light.vLightDiffuse.rgb)*(1.0-subSurfaceOut.translucencyIntensity);info.diffuseTransmission=computeDiffuseTransmittedLighting(preInfo,light.vLightDiffuse.rgb,subSurfaceOut.transmittance);
+#endif
+#else
+info.diffuse=computeDiffuseLighting(preInfo,light.vLightDiffuse.rgb);
+#endif
+#ifdef SPECULARTERM
+#if CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR
+let metalFresnel=reflectivityOut.specularWeight*getF82Specular(preInfo.VdotH,specularEnvironmentR0,reflectivityOut.colorReflectanceF90,reflectivityOut.roughness);let dielectricFresnel=fresnelSchlickGGXVec3(preInfo.VdotH,reflectivityOut.dielectricColorF0,reflectivityOut.colorReflectanceF90);let coloredFresnel=mix(dielectricFresnel,metalFresnel,reflectivityOut.metallic);
+#else
+let coloredFresnel=fresnelSchlickGGXVec3(preInfo.VdotH,specularEnvironmentR0,reflectivityOut.colorReflectanceF90);
+#endif
+#ifndef LEGACY_SPECULAR_ENERGY_CONSERVATION
+let NdotH=dot(N,preInfo.H);let fresnel=fresnelSchlickGGXVec3(NdotH,vec3(reflectanceF0),specularEnvironmentR90);info.diffuse*=(vec3(1.0)-fresnel);
+#endif
+#ifdef ANISOTROPIC
+info.specular=computeAnisotropicSpecularLighting(preInfo,V,N,anisotropicOut.anisotropicTangent,anisotropicOut.anisotropicBitangent,anisotropicOut.anisotropy,specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactor,light.vLightDiffuse.rgb);
+#else
+info.specular=computeSpecularLighting(preInfo,N,specularEnvironmentR0,coloredFresnel,AARoughnessFactor,light.vLightDiffuse.rgb);
+#endif
+#endif
+#ifdef SHEEN
+#ifdef SHEEN_LINKWITHALBEDO
+preInfo.roughness=sheenOut.sheenIntensity;
+#else
+preInfo.roughness=adjustRoughnessFromLightProperties(sheenOut.sheenRoughness,light.vLightSpecular.a,preInfo.lightDistance);
+#endif
+info.sheen=computeSheenLighting(preInfo,normalW,sheenOut.sheenColor,specularEnvironmentR90,AARoughnessFactor,light.vLightDiffuse.rgb);
+#endif
+#ifdef CLEARCOAT
+preInfo.roughness=adjustRoughnessFromLightProperties(clearcoatOut.clearCoatRoughness,light.vLightSpecular.a,preInfo.lightDistance);info.clearCoat=computeClearCoatLighting(preInfo,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatAARoughnessFactors.x,clearcoatOut.clearCoatIntensity,light.vLightDiffuse.rgb);
+#ifdef CLEARCOAT_TINT
+let absorption=computeClearCoatLightingAbsorption(clearcoatOut.clearCoatNdotVRefract,preInfo.L,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatColor,clearcoatOut.clearCoatThickness,clearcoatOut.clearCoatIntensity);info.diffuse*=absorption;
+#ifdef SS_TRANSLUCENCY
+info.diffuseTransmission*=absorption;
+#endif
+#ifdef SPECULARTERM
+info.specular*=absorption;
+#endif
+#endif
+info.diffuse*=info.clearCoat.w;
+#ifdef SS_TRANSLUCENCY
+info.diffuseTransmission*=info.clearCoat.w;
+#endif
+#ifdef SPECULARTERM
+info.specular*=info.clearCoat.w;
+#endif
+#ifdef SHEEN
+info.sheen*=info.clearCoat.w;
+#endif
+#endif
+result.diffuse+=info.diffuse;
+#ifdef SS_TRANSLUCENCY
+result.diffuseTransmission+=info.diffuseTransmission;
+#endif
+#ifdef SPECULARTERM
+result.specular+=info.specular;
+#endif
+#ifdef CLEARCOAT
+result.clearCoat+=info.clearCoat;
+#endif
+#ifdef SHEEN
+result.sheen+=info.sheen;
+#endif
+}
+batchOffset+=CLUSTLIGHT_BATCH;}
+return result;}
+#endif
+`;
+e.IncludesShadersStoreWGSL[c] || (e.IncludesShadersStoreWGSL[c] = D);
+const s = "pbrBlockNormalGeometric", A = `var viewDirectionW: vec3f=normalize(scene.vEyePosition.xyz-input.vPositionW);
+#ifdef NORMAL
+var normalW: vec3f=normalize(input.vNormalW);
+#else
+var normalW: vec3f=normalize(cross(dpdx(input.vPositionW),dpdy(input.vPositionW)))*scene.vEyePosition.w;
+#endif
+var geometricNormalW: vec3f=normalW;
+#if defined(TWOSIDEDLIGHTING) && defined(NORMAL)
+geometricNormalW=select(-geometricNormalW,geometricNormalW,fragmentInputs.frontFacing);
+#endif
+`;
+e.IncludesShadersStoreWGSL[s] || (e.IncludesShadersStoreWGSL[s] = A);
+const d = "pbrBlockImageProcessing", T = `#if defined(IMAGEPROCESSINGPOSTPROCESS) || defined(SS_SCATTERING)
+#if !defined(SKIPFINALCOLORCLAMP)
+finalColor=vec4f(clamp(finalColor.rgb,vec3f(0.),vec3f(30.0)),finalColor.a);
+#endif
+#else
+finalColor=applyImageProcessing(finalColor);
+#endif
+finalColor=vec4f(finalColor.rgb,finalColor.a*mesh.visibility);
+#ifdef PREMULTIPLYALPHA
+finalColor=vec4f(finalColor.rgb*finalColor.a,finalColor.a);;
+#endif
+`;
+e.IncludesShadersStoreWGSL[d] || (e.IncludesShadersStoreWGSL[d] = T);
+const u = "pbrDebug", N = `#if DEBUGMODE>0
+if (input.vClipSpacePosition.x/input.vClipSpacePosition.w>=uniforms.vDebugMode.x) {var color: vec3f;
+#if DEBUGMODE==1
+color=fragmentInputs.vPositionW.rgb;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==2 && defined(NORMAL)
+color=fragmentInputs.vNormalW.rgb;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==3 && defined(BUMP) || DEBUGMODE==3 && defined(PARALLAX) || DEBUGMODE==3 && defined(ANISOTROPIC)
+color=TBN[0];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==4 && defined(BUMP) || DEBUGMODE==4 && defined(PARALLAX) || DEBUGMODE==4 && defined(ANISOTROPIC)
+color=TBN[1];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==5
+color=normalW;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==6 && defined(MAINUV1)
+color= vec3f(input.vMainUV1,0.0);
+#elif DEBUGMODE==7 && defined(MAINUV2)
+color= vec3f(input.vMainUV2,0.0);
+#elif DEBUGMODE==8 && defined(CLEARCOAT) && defined(CLEARCOAT_BUMP)
+color=clearcoatOut.TBNClearCoat[0];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==9 && defined(CLEARCOAT) && defined(CLEARCOAT_BUMP)
+color=clearcoatOut.TBNClearCoat[1];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==10 && defined(CLEARCOAT)
+color=clearcoatOut.clearCoatNormalW;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==11 && defined(ANISOTROPIC)
+color=anisotropicOut.anisotropicNormal;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==12 && defined(ANISOTROPIC)
+color=anisotropicOut.anisotropicTangent;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==13 && defined(ANISOTROPIC)
+color=anisotropicOut.anisotropicBitangent;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==20 && defined(ALBEDO)
+color=albedoTexture.rgb;
+#ifndef GAMMAALBEDO
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==21 && defined(AMBIENT)
+color=aoOut.ambientOcclusionColorMap.rgb;
+#elif DEBUGMODE==22 && defined(OPACITY)
+color=opacityMap.rgb;
+#elif DEBUGMODE==23 && defined(EMISSIVE)
+color=emissiveColorTex.rgb;
+#ifndef GAMMAEMISSIVE
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==24 && defined(LIGHTMAP)
+color=lightmapColor;
+#ifndef GAMMALIGHTMAP
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==25 && defined(REFLECTIVITY) && defined(METALLICWORKFLOW)
+color=reflectivityOut.surfaceMetallicColorMap.rgb;
+#elif DEBUGMODE==26 && defined(REFLECTIVITY) && !defined(METALLICWORKFLOW)
+color=reflectivityOut.surfaceReflectivityColorMap.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==27 && defined(CLEARCOAT) && defined(CLEARCOAT_TEXTURE)
+color= vec3f(clearcoatOut.clearCoatMapData.rg,0.0);
+#elif DEBUGMODE==28 && defined(CLEARCOAT) && defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
+color=clearcoatOut.clearCoatTintMapData.rgb;
+#elif DEBUGMODE==29 && defined(SHEEN) && defined(SHEEN_TEXTURE)
+color=sheenOut.sheenMapData.rgb;
+#elif DEBUGMODE==30 && defined(ANISOTROPIC) && defined(ANISOTROPIC_TEXTURE)
+color=anisotropicOut.anisotropyMapData.rgb;
+#elif DEBUGMODE==31 && defined(SUBSURFACE) && defined(SS_THICKNESSANDMASK_TEXTURE)
+color=subSurfaceOut.thicknessMap.rgb;
+#elif DEBUGMODE==32 && defined(BUMP)
+color=textureSample(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV).rgb;
+#elif DEBUGMODE==40 && defined(SS_REFRACTION)
+color=subSurfaceOut.environmentRefraction.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==41 && defined(REFLECTION)
+color=reflectionOut.environmentRadiance.rgb;
+#ifndef GAMMAREFLECTION
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==42 && defined(CLEARCOAT) && defined(REFLECTION)
+color=clearcoatOut.environmentClearCoatRadiance.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==50
+color=diffuseBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==51 && defined(SPECULARTERM)
+color=specularBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==52 && defined(CLEARCOAT)
+color=clearCoatBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==53 && defined(SHEEN)
+color=sheenBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==54 && defined(REFLECTION)
+color=reflectionOut.environmentIrradiance.rgb;
+#ifndef GAMMAREFLECTION
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==60
+color=surfaceAlbedo.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==61
+color=clearcoatOut.specularEnvironmentR0;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==62 && defined(METALLICWORKFLOW)
+color= vec3f(reflectivityOut.metallic);
+#elif DEBUGMODE==71 && defined(METALLICWORKFLOW)
+color=reflectivityOut.metallicF0;
+#elif DEBUGMODE==63
+color= vec3f(roughness);
+#elif DEBUGMODE==64
+color= vec3f(alphaG);
+#elif DEBUGMODE==65
+color= vec3f(NdotV);
+#elif DEBUGMODE==66 && defined(CLEARCOAT) && defined(CLEARCOAT_TINT)
+color=clearcoatOut.clearCoatColor;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==67 && defined(CLEARCOAT)
+color= vec3f(clearcoatOut.clearCoatRoughness);
+#elif DEBUGMODE==68 && defined(CLEARCOAT)
+color= vec3f(clearcoatOut.clearCoatNdotV);
+#elif DEBUGMODE==69 && defined(SUBSURFACE) && defined(SS_TRANSLUCENCY)
+color=subSurfaceOut.transmittance;
+#elif DEBUGMODE==70 && defined(SUBSURFACE) && defined(SS_REFRACTION)
+color=subSurfaceOut.refractionTransmittance;
+#elif DEBUGMODE==72
+color= vec3f(microSurface);
+#elif DEBUGMODE==73
+color=uniforms.vAlbedoColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==74 && !defined(METALLICWORKFLOW)
+color=uniforms.vReflectivityColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==75
+color=uniforms.vEmissiveColor;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==80 && defined(RADIANCEOCCLUSION)
+color= vec3f(seo);
+#elif DEBUGMODE==81 && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+color= vec3f(eho);
+#elif DEBUGMODE==82 && defined(MS_BRDF_ENERGY_CONSERVATION)
+color= vec3f(energyConservationFactor);
+#elif DEBUGMODE==83 && defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+color=baseSpecularEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==84 && defined(CLEARCOAT) && defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+color=clearcoatOut.clearCoatEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==85 && defined(SHEEN) && defined(REFLECTION)
+color=sheenOut.sheenEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==86 && defined(ALPHABLEND)
+color= vec3f(luminanceOverAlpha);
+#elif DEBUGMODE==87
+color= vec3f(alpha);
+#elif DEBUGMODE==88 && defined(ALBEDO)
+color= vec3f(albedoTexture.a);
+#elif DEBUGMODE==89
+color=aoOut.ambientOcclusionColor;
+#else
+var stripeWidth: f32=30.;var stripePos: f32=abs(floor(input.position.x/stripeWidth));var whichColor: f32=((stripePos)%(2.));var color1: vec3f= vec3f(.6,.2,.2);var color2: vec3f= vec3f(.3,.1,.1);color=mix(color1,color2,whichColor);
+#endif
+color*=uniforms.vDebugMode.y;
+#ifdef DEBUGMODE_NORMALIZE
+color=normalize(color)*0.5+0.5;
+#endif
+#ifdef DEBUGMODE_GAMMA
+color=toGammaSpaceVec3(color);
+#endif
+fragmentOutputs.color=vec4f(color,1.0);
+#ifdef PREPASS
+fragmentOutputs.fragData0=toLinearSpaceVec3(color); 
+fragmentOutputs.fragData1=vec4f(0.,0.,0.,0.); 
+#endif
+#ifdef DEBUGMODE_FORCERETURN
+return fragmentOutputs;
+#endif
+}
+#endif
+`;
+e.IncludesShadersStoreWGSL[u] || (e.IncludesShadersStoreWGSL[u] = N);