@graphty/graphty-element 1.0.1

package/dist/pbr.fragment-siOdCYqI.js

@@ -0,0 +1,3219 @@
+import { S as e } from "./index-ChGTkj2q.js";
+import "./oitFragment-D6JBEGk0.js";
+import "./harmonicsFunctions-D9ZL5yLA.js";
+import "./logDepthDeclaration-Bou5AJOP.js";
+import "./helperFunctions-Dh1WD8YN.js";
+const n = "pbrFragmentDeclaration", V = `uniform vec4 vEyePosition;uniform vec3 vReflectionColor;uniform vec4 vAlbedoColor;uniform float baseWeight;uniform float baseDiffuseRoughness;uniform vec4 vLightingIntensity;uniform vec4 vReflectivityColor;uniform vec4 vMetallicReflectanceFactors;uniform vec3 vEmissiveColor;uniform float visibility;uniform vec3 vAmbientColor;
+#ifdef ALBEDO
+uniform vec2 vAlbedoInfos;
+#endif
+#ifdef BASE_WEIGHT
+uniform vec2 vBaseWeightInfos;
+#endif
+#ifdef BASE_DIFFUSE_ROUGHNESS
+uniform vec2 vBaseDiffuseRoughnessInfos;
+#endif
+#ifdef AMBIENT
+uniform vec4 vAmbientInfos;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;uniform vec2 vTangentSpaceParams;
+#endif
+#ifdef OPACITY
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+#endif
+#ifdef REFLECTIVITY
+uniform vec3 vReflectivityInfos;
+#endif
+#ifdef MICROSURFACEMAP
+uniform vec2 vMicroSurfaceSamplerInfos;
+#endif
+#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(SS_REFRACTION) || defined(PREPASS)
+uniform mat4 view;
+#endif
+#ifdef REFLECTION
+uniform vec2 vReflectionInfos;
+#ifdef REALTIME_FILTERING
+uniform vec2 vReflectionFilteringInfo;
+#endif
+uniform mat4 reflectionMatrix;uniform vec3 vReflectionMicrosurfaceInfos;
+#if defined(USEIRRADIANCEMAP) && defined(USE_IRRADIANCE_DOMINANT_DIRECTION)
+uniform vec3 vReflectionDominantDirection;
+#endif
+#if defined(USE_LOCAL_REFLECTIONMAP_CUBIC) && defined(REFLECTIONMAP_CUBIC)
+uniform vec3 vReflectionPosition;uniform vec3 vReflectionSize;
+#endif
+#endif
+#if defined(SS_REFRACTION) && defined(SS_USE_LOCAL_REFRACTIONMAP_CUBIC)
+uniform vec3 vRefractionPosition;uniform vec3 vRefractionSize;
+#endif
+#ifdef CLEARCOAT
+uniform vec2 vClearCoatParams;uniform vec4 vClearCoatRefractionParams;
+#if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+uniform vec4 vClearCoatInfos;
+#endif
+#ifdef CLEARCOAT_TEXTURE
+uniform mat4 clearCoatMatrix;
+#endif
+#ifdef CLEARCOAT_TEXTURE_ROUGHNESS
+uniform mat4 clearCoatRoughnessMatrix;
+#endif
+#ifdef CLEARCOAT_BUMP
+uniform vec2 vClearCoatBumpInfos;uniform vec2 vClearCoatTangentSpaceParams;uniform mat4 clearCoatBumpMatrix;
+#endif
+#ifdef CLEARCOAT_TINT
+uniform vec4 vClearCoatTintParams;uniform float clearCoatColorAtDistance;
+#ifdef CLEARCOAT_TINT_TEXTURE
+uniform vec2 vClearCoatTintInfos;uniform mat4 clearCoatTintMatrix;
+#endif
+#endif
+#endif
+#ifdef IRIDESCENCE
+uniform vec4 vIridescenceParams;
+#if defined(IRIDESCENCE_TEXTURE) || defined(IRIDESCENCE_THICKNESS_TEXTURE)
+uniform vec4 vIridescenceInfos;
+#endif
+#ifdef IRIDESCENCE_TEXTURE
+uniform mat4 iridescenceMatrix;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+uniform mat4 iridescenceThicknessMatrix;
+#endif
+#endif
+#ifdef ANISOTROPIC
+uniform vec3 vAnisotropy;
+#ifdef ANISOTROPIC_TEXTURE
+uniform vec2 vAnisotropyInfos;uniform mat4 anisotropyMatrix;
+#endif
+#endif
+#ifdef SHEEN
+uniform vec4 vSheenColor;
+#ifdef SHEEN_ROUGHNESS
+uniform float vSheenRoughness;
+#endif
+#if defined(SHEEN_TEXTURE) || defined(SHEEN_TEXTURE_ROUGHNESS)
+uniform vec4 vSheenInfos;
+#endif
+#ifdef SHEEN_TEXTURE
+uniform mat4 sheenMatrix;
+#endif
+#ifdef SHEEN_TEXTURE_ROUGHNESS
+uniform mat4 sheenRoughnessMatrix;
+#endif
+#endif
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+uniform vec4 vRefractionMicrosurfaceInfos;uniform vec4 vRefractionInfos;uniform mat4 refractionMatrix;
+#ifdef REALTIME_FILTERING
+uniform vec2 vRefractionFilteringInfo;
+#endif
+#ifdef SS_DISPERSION
+uniform float dispersion;
+#endif
+#endif
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+uniform vec2 vThicknessInfos;uniform mat4 thicknessMatrix;
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+uniform vec2 vRefractionIntensityInfos;uniform mat4 refractionIntensityMatrix;
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+uniform vec2 vTranslucencyIntensityInfos;uniform mat4 translucencyIntensityMatrix;
+#endif
+uniform vec2 vThicknessParam;uniform vec3 vDiffusionDistance;uniform vec4 vTintColor;uniform vec3 vSubSurfaceIntensity;uniform vec4 vTranslucencyColor;
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE
+uniform vec2 vTranslucencyColorInfos;uniform mat4 translucencyColorMatrix;
+#endif
+#endif
+#ifdef PREPASS
+#ifdef SS_SCATTERING
+uniform float scatteringDiffusionProfile;
+#endif
+#endif
+#if DEBUGMODE>0
+uniform vec2 vDebugMode;
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+#endif
+#include<decalFragmentDeclaration>
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+uniform vec3 vSphericalL00;uniform vec3 vSphericalL1_1;uniform vec3 vSphericalL10;uniform vec3 vSphericalL11;uniform vec3 vSphericalL2_2;uniform vec3 vSphericalL2_1;uniform vec3 vSphericalL20;uniform vec3 vSphericalL21;uniform vec3 vSphericalL22;
+#else
+uniform vec3 vSphericalX;uniform vec3 vSphericalY;uniform vec3 vSphericalZ;uniform vec3 vSphericalXX_ZZ;uniform vec3 vSphericalYY_ZZ;uniform vec3 vSphericalZZ;uniform vec3 vSphericalXY;uniform vec3 vSphericalYZ;uniform vec3 vSphericalZX;
+#endif
+#endif
+#define ADDITIONAL_FRAGMENT_DECLARATION
+`;
+e.IncludesShadersStore[n] || (e.IncludesShadersStore[n] = V);
+const a = "pbrFragmentExtraDeclaration", H = `varying vec3 vPositionW;
+#if DEBUGMODE>0
+varying vec4 vClipSpacePosition;
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#ifdef NORMAL
+varying vec3 vNormalW;
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+varying vec3 vEnvironmentIrradiance;
+#endif
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+`;
+e.IncludesShadersStore[a] || (e.IncludesShadersStore[a] = H);
+const o = "samplerFragmentAlternateDeclaration", x = `#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 vec2 v_VARYINGNAME_UV;
+#endif
+#endif
+`;
+e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = x);
+const r = "pbrFragmentSamplersDeclaration", W = `#include<samplerFragmentDeclaration>(_DEFINENAME_,ALBEDO,_VARYINGNAME_,Albedo,_SAMPLERNAME_,albedo)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BASE_WEIGHT,_VARYINGNAME_,BaseWeight,_SAMPLERNAME_,baseWeight)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BASE_DIFFUSE_ROUGHNESS,_VARYINGNAME_,BaseDiffuseRoughness,_SAMPLERNAME_,baseDiffuseRoughness)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient,_SAMPLERNAME_,ambient)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity,_SAMPLERNAME_,opacity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive,_SAMPLERNAME_,emissive)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap,_SAMPLERNAME_,lightmap)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,REFLECTIVITY,_VARYINGNAME_,Reflectivity,_SAMPLERNAME_,reflectivity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,MICROSURFACEMAP,_VARYINGNAME_,MicroSurfaceSampler,_SAMPLERNAME_,microSurface)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,METALLIC_REFLECTANCE,_VARYINGNAME_,MetallicReflectance,_SAMPLERNAME_,metallicReflectance)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,REFLECTANCE,_VARYINGNAME_,Reflectance,_SAMPLERNAME_,reflectance)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_SAMPLERNAME_,decal)
+#ifdef CLEARCOAT
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE,_VARYINGNAME_,ClearCoat,_SAMPLERNAME_,clearCoat)
+#include<samplerFragmentAlternateDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE_ROUGHNESS,_VARYINGNAME_,ClearCoatRoughness)
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+uniform sampler2D clearCoatRoughnessSampler;
+#endif
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_BUMP,_VARYINGNAME_,ClearCoatBump,_SAMPLERNAME_,clearCoatBump)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_TINT_TEXTURE,_VARYINGNAME_,ClearCoatTint,_SAMPLERNAME_,clearCoatTint)
+#endif
+#ifdef IRIDESCENCE
+#include<samplerFragmentDeclaration>(_DEFINENAME_,IRIDESCENCE_TEXTURE,_VARYINGNAME_,Iridescence,_SAMPLERNAME_,iridescence)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,IRIDESCENCE_THICKNESS_TEXTURE,_VARYINGNAME_,IridescenceThickness,_SAMPLERNAME_,iridescenceThickness)
+#endif
+#ifdef SHEEN
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SHEEN_TEXTURE,_VARYINGNAME_,Sheen,_SAMPLERNAME_,sheen)
+#include<samplerFragmentAlternateDeclaration>(_DEFINENAME_,SHEEN_TEXTURE_ROUGHNESS,_VARYINGNAME_,SheenRoughness)
+#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS)
+uniform sampler2D sheenRoughnessSampler;
+#endif
+#endif
+#ifdef ANISOTROPIC
+#include<samplerFragmentDeclaration>(_DEFINENAME_,ANISOTROPIC_TEXTURE,_VARYINGNAME_,Anisotropy,_SAMPLERNAME_,anisotropy)
+#endif
+#ifdef REFLECTION
+#ifdef REFLECTIONMAP_3D
+#define sampleReflection(s,c) textureCube(s,c)
+uniform samplerCube reflectionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleReflectionLod(s,c,l) textureCubeLodEXT(s,c,l)
+#else
+uniform samplerCube reflectionSamplerLow;uniform samplerCube reflectionSamplerHigh;
+#endif
+#ifdef USEIRRADIANCEMAP
+uniform samplerCube irradianceSampler;
+#endif
+#else
+#define sampleReflection(s,c) texture2D(s,c)
+uniform sampler2D reflectionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleReflectionLod(s,c,l) texture2DLodEXT(s,c,l)
+#else
+uniform sampler2D reflectionSamplerLow;uniform sampler2D reflectionSamplerHigh;
+#endif
+#ifdef USEIRRADIANCEMAP
+uniform sampler2D irradianceSampler;
+#endif
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+varying vec3 vPositionUVW;
+#else
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vec3 vDirectionW;
+#endif
+#endif
+#endif
+#ifdef ENVIRONMENTBRDF
+uniform sampler2D environmentBrdfSampler;
+#endif
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+#ifdef SS_REFRACTIONMAP_3D
+#define sampleRefraction(s,c) textureCube(s,c)
+uniform samplerCube refractionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleRefractionLod(s,c,l) textureCubeLodEXT(s,c,l)
+#else
+uniform samplerCube refractionSamplerLow;uniform samplerCube refractionSamplerHigh;
+#endif
+#else
+#define sampleRefraction(s,c) texture2D(s,c)
+uniform sampler2D refractionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleRefractionLod(s,c,l) texture2DLodEXT(s,c,l)
+#else
+uniform sampler2D refractionSamplerLow;uniform sampler2D refractionSamplerHigh;
+#endif
+#endif
+#endif
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_THICKNESSANDMASK_TEXTURE,_VARYINGNAME_,Thickness,_SAMPLERNAME_,thickness)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_REFRACTIONINTENSITY_TEXTURE,_VARYINGNAME_,RefractionIntensity,_SAMPLERNAME_,refractionIntensity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_TRANSLUCENCYINTENSITY_TEXTURE,_VARYINGNAME_,TranslucencyIntensity,_SAMPLERNAME_,translucencyIntensity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_TRANSLUCENCYCOLOR_TEXTURE,_VARYINGNAME_,TranslucencyColor,_SAMPLERNAME_,translucencyColor)
+#endif
+#ifdef IBL_CDF_FILTERING
+uniform sampler2D icdfSampler;
+#endif
+`;
+e.IncludesShadersStore[r] || (e.IncludesShadersStore[r] = W);
+const t = "subSurfaceScatteringFunctions", X = `bool testLightingForSSS(float diffusionProfile)
+{return diffusionProfile<1.;}`;
+e.IncludesShadersStore[t] || (e.IncludesShadersStore[t] = X);
+const f = "importanceSampling", Y = `vec3 hemisphereCosSample(vec2 u) {float phi=2.*PI*u.x;float cosTheta2=1.-u.y;float cosTheta=sqrt(cosTheta2);float sinTheta=sqrt(1.-cosTheta2);return vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}
+vec3 hemisphereImportanceSampleDggx(vec2 u,float a) {float phi=2.*PI*u.x;float cosTheta2=(1.-u.y)/(1.+(a+1.)*((a-1.)*u.y));float cosTheta=sqrt(cosTheta2);float sinTheta=sqrt(1.-cosTheta2);return vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}
+vec3 hemisphereImportanceSampleDCharlie(vec2 u,float a) { 
+float phi=2.*PI*u.x;float sinTheta=pow(u.y,a/(2.*a+1.));float cosTheta=sqrt(1.-sinTheta*sinTheta);return vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);}`;
+e.IncludesShadersStore[f] || (e.IncludesShadersStore[f] = Y);
+const c = "pbrHelperFunctions", k = `#define MINIMUMVARIANCE 0.0005
+float convertRoughnessToAverageSlope(float roughness)
+{return square(roughness)+MINIMUMVARIANCE;}
+float fresnelGrazingReflectance(float reflectance0) {float reflectance90=saturate(reflectance0*25.0);return reflectance90;}
+vec2 getAARoughnessFactors(vec3 normalVector) {
+#ifdef SPECULARAA
+vec3 nDfdx=dFdx(normalVector.xyz);vec3 nDfdy=dFdy(normalVector.xyz);float slopeSquare=max(dot(nDfdx,nDfdx),dot(nDfdy,nDfdy));float geometricRoughnessFactor=pow(saturate(slopeSquare),0.333);float geometricAlphaGFactor=sqrt(slopeSquare);geometricAlphaGFactor*=0.75;return vec2(geometricRoughnessFactor,geometricAlphaGFactor);
+#else
+return vec2(0.);
+#endif
+}
+#ifdef ANISOTROPIC
+#ifdef ANISOTROPIC_LEGACY
+vec2 getAnisotropicRoughness(float alphaG,float anisotropy) {float alphaT=max(alphaG*(1.0+anisotropy),MINIMUMVARIANCE);float alphaB=max(alphaG*(1.0-anisotropy),MINIMUMVARIANCE);return vec2(alphaT,alphaB);}
+vec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {vec3 anisotropicFrameDirection;if (anisotropy>=0.0) {anisotropicFrameDirection=B;} else {anisotropicFrameDirection=T;}
+vec3 anisotropicFrameTangent=cross(normalize(anisotropicFrameDirection),V);vec3 anisotropicFrameNormal=cross(anisotropicFrameTangent,anisotropicFrameDirection);vec3 anisotropicNormal=normalize(mix(N,anisotropicFrameNormal,abs(anisotropy)));return anisotropicNormal;}
+#else
+vec2 getAnisotropicRoughness(float alphaG,float anisotropy) {float alphaT=max(mix(alphaG,1.0,anisotropy*anisotropy),MINIMUMVARIANCE);float alphaB=max(alphaG,MINIMUMVARIANCE);return vec2(alphaT,alphaB);}
+vec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {vec3 bentNormal=cross(B,V);bentNormal=normalize(cross(bentNormal,B));float a=square(square(1.0-anisotropy*(1.0-roughness)));bentNormal=normalize(mix(bentNormal,N,a));return bentNormal;}
+#endif
+#endif
+#if defined(CLEARCOAT) || defined(SS_REFRACTION)
+vec3 cocaLambert(vec3 alpha,float distance) {return exp(-alpha*distance);}
+vec3 cocaLambert(float NdotVRefract,float NdotLRefract,vec3 alpha,float thickness) {return cocaLambert(alpha,(thickness*((NdotLRefract+NdotVRefract)/(NdotLRefract*NdotVRefract))));}
+vec3 computeColorAtDistanceInMedia(vec3 color,float distance) {return -log(color)/distance;}
+vec3 computeClearCoatAbsorption(float NdotVRefract,float NdotLRefract,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {vec3 clearCoatAbsorption=mix(vec3(1.0),
+cocaLambert(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness),
+clearCoatIntensity);return clearCoatAbsorption;}
+#endif
+#ifdef MICROSURFACEAUTOMATIC
+float computeDefaultMicroSurface(float microSurface,vec3 reflectivityColor)
+{const float kReflectivityNoAlphaWorkflow_SmoothnessMax=0.95;float reflectivityLuminance=getLuminance(reflectivityColor);float reflectivityLuma=sqrt(reflectivityLuminance);microSurface=reflectivityLuma*kReflectivityNoAlphaWorkflow_SmoothnessMax;return microSurface;}
+#endif
+`;
+e.IncludesShadersStore[c] || (e.IncludesShadersStore[c] = k);
+const l = "pbrDirectLightingSetupFunctions", w = `struct preLightingInfo
+{vec3 lightOffset;float lightDistanceSquared;float lightDistance;float attenuation;vec3 L;vec3 H;float NdotV;float NdotLUnclamped;float NdotL;float VdotH;float LdotV;float roughness;float diffuseRoughness;vec3 surfaceAlbedo;
+#ifdef IRIDESCENCE
+float iridescenceIntensity;
+#endif
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+vec3 areaLightDiffuse;
+#ifdef SPECULARTERM
+vec3 areaLightSpecular;vec4 areaLightFresnel;
+#endif
+#endif
+};preLightingInfo computePointAndSpotPreLightingInfo(vec4 lightData,vec3 V,vec3 N,vec3 posW) {preLightingInfo result;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);result.LdotV=0.;result.roughness=0.;result.diffuseRoughness=0.;result.surfaceAlbedo=vec3(0.);return result;}
+preLightingInfo computeDirectionalPreLightingInfo(vec4 lightData,vec3 V,vec3 N) {preLightingInfo result;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);result.roughness=0.;result.diffuseRoughness=0.;result.surfaceAlbedo=vec3(0.);return result;}
+preLightingInfo computeHemisphericPreLightingInfo(vec4 lightData,vec3 V,vec3 N) {preLightingInfo result;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
+result.LdotV=0.;result.roughness=0.;result.diffuseRoughness=0.;result.surfaceAlbedo=vec3(0.);return result;}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+#include<ltcHelperFunctions>
+uniform sampler2D areaLightsLTC1Sampler;uniform sampler2D areaLightsLTC2Sampler;preLightingInfo computeAreaPreLightingInfo(sampler2D ltc1,sampler2D ltc2,vec3 viewDirectionW,vec3 vNormal,vec3 vPosition,vec4 lightData,vec3 halfWidth,vec3 halfHeight,float roughness )
+{preLightingInfo result;result.lightOffset=lightData.xyz-vPosition;result.lightDistanceSquared=dot(result.lightOffset,result.lightOffset);result.lightDistance=sqrt(result.lightDistanceSquared);areaLightData data=computeAreaLightSpecularDiffuseFresnel(ltc1,ltc2,viewDirectionW,vNormal,vPosition,lightData.xyz,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=vec3(0.);return result;}
+#endif
+`;
+e.IncludesShadersStore[l] || (e.IncludesShadersStore[l] = w);
+const d = "pbrDirectLightingFalloffFunctions", z = `float computeDistanceLightFalloff_Standard(vec3 lightOffset,float range)
+{return max(0.,1.0-length(lightOffset)/range);}
+float computeDistanceLightFalloff_Physical(float lightDistanceSquared)
+{return 1.0/maxEps(lightDistanceSquared);}
+float computeDistanceLightFalloff_GLTF(float lightDistanceSquared,float inverseSquaredRange)
+{float lightDistanceFalloff=1.0/maxEps(lightDistanceSquared);float factor=lightDistanceSquared*inverseSquaredRange;float attenuation=saturate(1.0-factor*factor);attenuation*=attenuation;lightDistanceFalloff*=attenuation;return lightDistanceFalloff;}
+float computeDistanceLightFalloff(vec3 lightOffset,float lightDistanceSquared,float range,float inverseSquaredRange)
+{
+#ifdef USEPHYSICALLIGHTFALLOFF
+return computeDistanceLightFalloff_Physical(lightDistanceSquared);
+#elif defined(USEGLTFLIGHTFALLOFF)
+return computeDistanceLightFalloff_GLTF(lightDistanceSquared,inverseSquaredRange);
+#else
+return computeDistanceLightFalloff_Standard(lightOffset,range);
+#endif
+}
+float computeDirectionalLightFalloff_Standard(vec3 lightDirection,vec3 directionToLightCenterW,float cosHalfAngle,float exponent)
+{float falloff=0.0;float cosAngle=maxEps(dot(-lightDirection,directionToLightCenterW));if (cosAngle>=cosHalfAngle)
+{falloff=max(0.,pow(cosAngle,exponent));}
+return falloff;}
+float computeDirectionalLightFalloff_IES(vec3 lightDirection,vec3 directionToLightCenterW,sampler2D iesLightSampler)
+{float cosAngle=dot(-lightDirection,directionToLightCenterW);float angle=acos(cosAngle)/PI;return texture2D(iesLightSampler,vec2(angle,0.)).r;}
+float computeDirectionalLightFalloff_Physical(vec3 lightDirection,vec3 directionToLightCenterW,float cosHalfAngle)
+{const float kMinusLog2ConeAngleIntensityRatio=6.64385618977; 
+float concentrationKappa=kMinusLog2ConeAngleIntensityRatio/(1.0-cosHalfAngle);vec4 lightDirectionSpreadSG=vec4(-lightDirection*concentrationKappa,-concentrationKappa);float falloff=exp2(dot(vec4(directionToLightCenterW,1.0),lightDirectionSpreadSG));return falloff;}
+float computeDirectionalLightFalloff_GLTF(vec3 lightDirection,vec3 directionToLightCenterW,float lightAngleScale,float lightAngleOffset)
+{float cd=dot(-lightDirection,directionToLightCenterW);float falloff=saturate(cd*lightAngleScale+lightAngleOffset);falloff*=falloff;return falloff;}
+float computeDirectionalLightFalloff(vec3 lightDirection,vec3 directionToLightCenterW,float cosHalfAngle,float exponent,float lightAngleScale,float lightAngleOffset)
+{
+#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.IncludesShadersStore[d] || (e.IncludesShadersStore[d] = z);
+const s = "hdrFilteringFunctions", K = `#if NUM_SAMPLES
+#if NUM_SAMPLES>0
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+float radicalInverse_VdC(uint bits) 
+{bits=(bits<<16u) | (bits>>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 float(bits)*2.3283064365386963e-10; }
+vec2 hammersley(uint i,uint N)
+{return vec2(float(i)/float(N),radicalInverse_VdC(i));}
+#else
+float vanDerCorpus(int n,int base)
+{float invBase=1.0/float(base);float denom =1.0;float result =0.0;for(int i=0; i<32; ++i)
+{if(n>0)
+{denom =mod(float(n),2.0);result+=denom*invBase;invBase=invBase/2.0;n =int(float(n)/2.0);}}
+return result;}
+vec2 hammersley(int i,int N)
+{return vec2(float(i)/float(N),vanDerCorpus(i,2));}
+#endif
+float log4(float x) {return log2(x)/2.;}
+vec3 uv_to_normal(vec2 uv) {vec3 N;vec2 uvRange=uv;float theta=uvRange.x*2.*PI;float phi=uvRange.y*PI;float sinPhi=sin(phi);N.x=cos(theta)*sinPhi;N.z=sin(theta)*sinPhi;N.y=cos(phi);return N;}
+const float NUM_SAMPLES_FLOAT=float(NUM_SAMPLES);const float NUM_SAMPLES_FLOAT_INVERSED=1./NUM_SAMPLES_FLOAT;const float K=4.;
+#define inline
+vec3 irradiance(samplerCube inputTexture,vec3 inputN,vec2 filteringInfo,float diffuseRoughness,vec3 surfaceAlbedo,vec3 inputV
+#if IBL_CDF_FILTERING
+,sampler2D icdfSampler
+#endif
+)
+{vec3 n=normalize(inputN);vec3 result=vec3(0.);
+#ifndef IBL_CDF_FILTERING
+vec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);tangent=normalize(cross(tangent,n));vec3 bitangent=cross(n,tangent);mat3 tbn=mat3(tangent,bitangent,n);mat3 tbnInverse=mat3(tangent.x,bitangent.x,n.x,tangent.y,bitangent.y,n.y,tangent.z,bitangent.z,n.z);
+#endif
+float maxLevel=filteringInfo.y;float dim0=filteringInfo.x;float omegaP=(4.*PI)/(6.*dim0*dim0);vec3 clampedAlbedo=clamp(surfaceAlbedo,vec3(0.1),vec3(1.0));
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+for(uint i=0u; i<NUM_SAMPLES; ++i)
+#else
+for(int i=0; i<NUM_SAMPLES; ++i)
+#endif
+{vec2 Xi=hammersley(i,NUM_SAMPLES);
+#if IBL_CDF_FILTERING
+vec2 T;T.x=texture2D(icdfSampler,vec2(Xi.x,0.)).x;T.y=texture2D(icdfSampler,vec2(T.x,Xi.y)).y;vec3 Ls=uv_to_normal(vec2(1.0-fract(T.x+0.25),T.y));float NoL=dot(n,Ls);float NoV=dot(n,inputV);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+float LoV=dot (Ls,inputV);
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+vec3 H=(inputV+Ls)*0.5;float VoH=dot(inputV,H);
+#endif
+#else
+vec3 Ls=hemisphereCosSample(Xi);Ls=normalize(Ls);float NoL=Ls.z; 
+vec3 V=tbnInverse*inputV;float NoV=V.z; 
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+float LoV=dot (Ls,V);
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+vec3 H=(V+Ls)*0.5;float VoH=dot(V,H);
+#endif
+#endif
+if (NoL>0.) {
+#if IBL_CDF_FILTERING
+float pdf=texture2D(icdfSampler,T).z;vec3 c=textureCubeLodEXT(inputTexture,Ls,0.).rgb;
+#else
+float pdf_inversed=PI/NoL;float omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;float l=log4(omegaS)-log4(omegaP)+log4(K);float mipLevel=clamp(l,0.,maxLevel);vec3 c=textureCubeLodEXT(inputTexture,tbn*Ls,mipLevel).rgb;
+#endif
+#if GAMMA_INPUT
+c=toLinearSpace(c);
+#endif
+vec3 diffuseRoughnessTerm=vec3(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=vec3(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+#if IBL_CDF_FILTERING
+vec3 light=pdf<1e-6 ? vec3(0.0) : vec3(1.0)/vec3(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;}
+#define inline
+vec3 radiance(float alphaG,samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)
+{vec3 n=normalize(inputN);vec3 c=textureCube(inputTexture,n).rgb; 
+if (alphaG==0.) {
+#if GAMMA_INPUT
+c=toLinearSpace(c);
+#endif
+return c;} else {vec3 result=vec3(0.);vec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);tangent=normalize(cross(tangent,n));vec3 bitangent=cross(n,tangent);mat3 tbn=mat3(tangent,bitangent,n);float maxLevel=filteringInfo.y;float dim0=filteringInfo.x;float omegaP=(4.*PI)/(6.*dim0*dim0);float weight=0.;
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+for(uint i=0u; i<NUM_SAMPLES; ++i)
+#else
+for(int i=0; i<NUM_SAMPLES; ++i)
+#endif
+{vec2 Xi=hammersley(i,NUM_SAMPLES);vec3 H=hemisphereImportanceSampleDggx(Xi,alphaG);float NoV=1.;float NoH=H.z;float NoH2=H.z*H.z;float NoL=2.*NoH2-1.;vec3 L=vec3(2.*NoH*H.x,2.*NoH*H.y,NoL);L=normalize(L);if (NoL>0.) {float pdf_inversed=4./normalDistributionFunction_TrowbridgeReitzGGX(NoH,alphaG);float omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;float l=log4(omegaS)-log4(omegaP)+log4(K);float mipLevel=clamp(float(l),0.0,maxLevel);weight+=NoL;vec3 c=textureCubeLodEXT(inputTexture,tbn*L,mipLevel).rgb;
+#if GAMMA_INPUT
+c=toLinearSpace(c);
+#endif
+result+=c*NoL;}}
+result=result/weight;return result;}}
+#endif
+#endif
+`;
+e.IncludesShadersStore[s] || (e.IncludesShadersStore[s] = K);
+const E = "pbrDirectLightingFunctions", $ = `#define CLEARCOATREFLECTANCE90 1.0
+struct lightingInfo
+{vec3 diffuse;
+#ifdef SS_TRANSLUCENCY
+vec3 diffuseTransmission;
+#endif
+#ifdef SPECULARTERM
+vec3 specular;
+#endif
+#ifdef CLEARCOAT
+vec4 clearCoat;
+#endif
+#ifdef SHEEN
+vec3 sheen;
+#endif
+};float adjustRoughnessFromLightProperties(float roughness,float lightRadius,float lightDistance) {
+#if defined(USEPHYSICALLIGHTFALLOFF) || defined(USEGLTFLIGHTFALLOFF)
+float lightRoughness=lightRadius/lightDistance;float totalRoughness=saturate(lightRoughness+roughness);return totalRoughness;
+#else
+return roughness;
+#endif
+}
+vec3 computeHemisphericDiffuseLighting(preLightingInfo info,vec3 lightColor,vec3 groundColor) {return mix(groundColor,lightColor,info.NdotL);}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+vec3 computeAreaDiffuseLighting(preLightingInfo info,vec3 lightColor) {return info.areaLightDiffuse*lightColor;}
+#endif
+vec3 computeDiffuseLighting(preLightingInfo info,vec3 lightColor) {vec3 diffuseTerm=vec3(1.0/PI);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_LEGACY
+diffuseTerm=vec3(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.roughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+diffuseTerm=vec3(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.diffuseRoughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+vec3 clampedAlbedo=clamp(info.surfaceAlbedo,vec3(0.1),vec3(1.0));diffuseTerm=diffuseBRDF_EON(clampedAlbedo,info.diffuseRoughness,info.NdotL,info.NdotV,info.LdotV);diffuseTerm/=clampedAlbedo;
+#endif
+return diffuseTerm*info.attenuation*info.NdotL*lightColor;}
+#define inline
+vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler,mat4 textureProjectionMatrix,vec3 posW){vec4 strq=textureProjectionMatrix*vec4(posW,1.0);strq/=strq.w;vec3 textureColor=texture2D(projectionLightSampler,strq.xy).rgb;return toLinearSpace(textureColor);}
+#ifdef SS_TRANSLUCENCY
+vec3 computeDiffuseTransmittedLighting(preLightingInfo info,vec3 lightColor,vec3 transmittance) {vec3 transmittanceNdotL=vec3(0.);float NdotL=absEps(info.NdotLUnclamped);
+#ifndef SS_TRANSLUCENCY_LEGACY
+if (info.NdotLUnclamped<0.0) {
+#endif
+float wrapNdotL=computeWrappedDiffuseNdotL(NdotL,0.02);float trAdapt=step(0.,info.NdotLUnclamped);transmittanceNdotL=mix(transmittance*wrapNdotL,vec3(wrapNdotL),trAdapt);
+#ifndef SS_TRANSLUCENCY_LEGACY
+}
+vec3 diffuseTerm=vec3(1.0/PI);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_LEGACY
+diffuseTerm=vec3(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.roughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+diffuseTerm=vec3(diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.diffuseRoughness));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+vec3 clampedAlbedo=clamp(info.surfaceAlbedo,vec3(0.1),vec3(1.0));diffuseTerm=diffuseBRDF_EON(clampedAlbedo,info.diffuseRoughness,info.NdotL,info.NdotV,info.LdotV);diffuseTerm/=clampedAlbedo;
+#endif
+#else
+float diffuseTerm=diffuseBRDF_Burley(NdotL,info.NdotV,info.VdotH,info.roughness);
+#endif
+return diffuseTerm*transmittanceNdotL*info.attenuation*lightColor;}
+#endif
+#ifdef SPECULARTERM
+vec3 computeSpecularLighting(preLightingInfo info,vec3 N,vec3 reflectance0,vec3 fresnel,float geometricRoughnessFactor,vec3 lightColor) {float NdotH=saturateEps(dot(N,info.H));float roughness=max(info.roughness,geometricRoughnessFactor);float alphaG=convertRoughnessToAverageSlope(roughness);
+#ifdef IRIDESCENCE
+fresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+float distribution=normalDistributionFunction_TrowbridgeReitzGGX(NdotH,alphaG);
+#ifdef BRDF_V_HEIGHT_CORRELATED
+float smithVisibility=smithVisibility_GGXCorrelated(info.NdotL,info.NdotV,alphaG);
+#else
+float smithVisibility=smithVisibility_TrowbridgeReitzGGXFast(info.NdotL,info.NdotV,alphaG);
+#endif
+vec3 specTerm=fresnel*distribution*smithVisibility;return specTerm*info.attenuation*info.NdotL*lightColor;}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+vec3 computeAreaSpecularLighting(preLightingInfo info,vec3 specularColor,vec3 reflectance0,vec3 reflectance90) {vec3 fresnel=specularColor*info.areaLightFresnel.x*reflectance0+( vec3( 1.0 )-specularColor )*info.areaLightFresnel.y*reflectance90;return specularColor*fresnel*info.areaLightSpecular;}
+#endif
+#endif
+#ifdef ANISOTROPIC
+vec3 computeAnisotropicSpecularLighting(preLightingInfo info,vec3 V,vec3 N,vec3 T,vec3 B,float anisotropy,vec3 reflectance0,vec3 reflectance90,float geometricRoughnessFactor,vec3 lightColor) {float NdotH=saturateEps(dot(N,info.H));float TdotH=dot(T,info.H);float BdotH=dot(B,info.H);float TdotV=dot(T,V);float BdotV=dot(B,V);float TdotL=dot(T,info.L);float BdotL=dot(B,info.L);float alphaG=convertRoughnessToAverageSlope(info.roughness);vec2 alphaTB=getAnisotropicRoughness(alphaG,anisotropy);alphaTB=max(alphaTB,square(geometricRoughnessFactor));vec3 fresnel=fresnelSchlickGGX(info.VdotH,reflectance0,reflectance90);
+#ifdef IRIDESCENCE
+fresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+float distribution=normalDistributionFunction_BurleyGGX_Anisotropic(NdotH,TdotH,BdotH,alphaTB);float smithVisibility=smithVisibility_GGXCorrelated_Anisotropic(info.NdotL,info.NdotV,TdotV,BdotV,TdotL,BdotL,alphaTB);vec3 specTerm=fresnel*distribution*smithVisibility;return specTerm*info.attenuation*info.NdotL*lightColor;}
+#endif
+#ifdef CLEARCOAT
+vec4 computeClearCoatLighting(preLightingInfo info,vec3 Ncc,float geometricRoughnessFactor,float clearCoatIntensity,vec3 lightColor) {float NccdotL=saturateEps(dot(Ncc,info.L));float NccdotH=saturateEps(dot(Ncc,info.H));float clearCoatRoughness=max(info.roughness,geometricRoughnessFactor);float alphaG=convertRoughnessToAverageSlope(clearCoatRoughness);float fresnel=fresnelSchlickGGX(info.VdotH,vClearCoatRefractionParams.x,CLEARCOATREFLECTANCE90);fresnel*=clearCoatIntensity;float distribution=normalDistributionFunction_TrowbridgeReitzGGX(NccdotH,alphaG);float kelemenVisibility=visibility_Kelemen(info.VdotH);float clearCoatTerm=fresnel*distribution*kelemenVisibility;return vec4(
+clearCoatTerm*info.attenuation*NccdotL*lightColor,
+1.0-fresnel
+);}
+vec3 computeClearCoatLightingAbsorption(float NdotVRefract,vec3 L,vec3 Ncc,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {vec3 LRefract=-refract(L,Ncc,vClearCoatRefractionParams.y);float NdotLRefract=saturateEps(dot(Ncc,LRefract));vec3 absorption=computeClearCoatAbsorption(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness,clearCoatIntensity);return absorption;}
+#endif
+#ifdef SHEEN
+vec3 computeSheenLighting(preLightingInfo info,vec3 N,vec3 reflectance0,vec3 reflectance90,float geometricRoughnessFactor,vec3 lightColor) {float NdotH=saturateEps(dot(N,info.H));float roughness=max(info.roughness,geometricRoughnessFactor);float alphaG=convertRoughnessToAverageSlope(roughness);float fresnel=1.;float distribution=normalDistributionFunction_CharlieSheen(NdotH,alphaG);/*#ifdef SHEEN_SOFTER
+float visibility=visibility_CharlieSheen(info.NdotL,info.NdotV,alphaG);
+#else */
+float visibility=visibility_Ashikhmin(info.NdotL,info.NdotV);/* #endif */
+float sheenTerm=fresnel*distribution*visibility;return sheenTerm*info.attenuation*info.NdotL*lightColor;}
+#endif
+`;
+e.IncludesShadersStore[E] || (e.IncludesShadersStore[E] = $);
+const R = "pbrIBLFunctions", q = `#if defined(REFLECTION) || defined(SS_REFRACTION)
+float getLodFromAlphaG(float cubeMapDimensionPixels,float microsurfaceAverageSlope) {float microsurfaceAverageSlopeTexels=cubeMapDimensionPixels*microsurfaceAverageSlope;float lod=log2(microsurfaceAverageSlopeTexels);return lod;}
+float getLinearLodFromRoughness(float cubeMapDimensionPixels,float roughness) {float lod=log2(cubeMapDimensionPixels)*roughness;return lod;}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(RADIANCEOCCLUSION)
+float environmentRadianceOcclusion(float ambientOcclusion,float NdotVUnclamped) {float temp=NdotVUnclamped+ambientOcclusion;return saturate(square(temp)-1.0+ambientOcclusion);}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(HORIZONOCCLUSION)
+float environmentHorizonOcclusion(vec3 view,vec3 normal,vec3 geometricNormal) {vec3 reflection=reflect(view,normal);float temp=saturate(1.0+1.1*dot(reflection,geometricNormal));return square(temp);}
+#endif
+#if defined(LODINREFLECTIONALPHA) || defined(SS_LODINREFRACTIONALPHA)
+#define UNPACK_LOD(x) (1.0-x)*255.0
+float getLodFromAlphaG(float cubeMapDimensionPixels,float alphaG,float NdotV) {float microsurfaceAverageSlope=alphaG;microsurfaceAverageSlope*=sqrt(abs(NdotV));return getLodFromAlphaG(cubeMapDimensionPixels,microsurfaceAverageSlope);}
+#endif
+`;
+e.IncludesShadersStore[R] || (e.IncludesShadersStore[R] = q);
+const u = "pbrBlockAlbedoOpacity", Z = `struct albedoOpacityOutParams
+{vec3 surfaceAlbedo;float alpha;};
+#define pbr_inline
+albedoOpacityOutParams albedoOpacityBlock(
+in vec4 vAlbedoColor
+#ifdef ALBEDO
+,in vec4 albedoTexture
+,in vec2 albedoInfos
+#endif
+,in float baseWeight
+#ifdef BASE_WEIGHT
+,in vec4 baseWeightTexture
+,in vec2 vBaseWeightInfos
+#endif
+#ifdef OPACITY
+,in vec4 opacityMap
+,in vec2 vOpacityInfos
+#endif
+#ifdef DETAIL
+,in vec4 detailColor
+,in vec4 vDetailInfos
+#endif
+#ifdef DECAL
+,in vec4 decalColor
+,in vec4 vDecalInfos
+#endif
+)
+{albedoOpacityOutParams outParams;vec3 surfaceAlbedo=vAlbedoColor.rgb;float alpha=vAlbedoColor.a;
+#ifdef ALBEDO
+#if defined(ALPHAFROMALBEDO) || defined(ALPHATEST)
+alpha*=albedoTexture.a;
+#endif
+#ifdef GAMMAALBEDO
+surfaceAlbedo*=toLinearSpace(albedoTexture.rgb);
+#else
+surfaceAlbedo*=albedoTexture.rgb;
+#endif
+surfaceAlbedo*=albedoInfos.y;
+#endif
+#ifndef DECAL_AFTER_DETAIL
+#include<decalFragment>
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+surfaceAlbedo*=vColor.rgb;
+#endif
+#ifdef DETAIL
+float detailAlbedo=2.0*mix(0.5,detailColor.r,vDetailInfos.y);surfaceAlbedo.rgb=surfaceAlbedo.rgb*detailAlbedo*detailAlbedo; 
+#endif
+#ifdef DECAL_AFTER_DETAIL
+#include<decalFragment>
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_ALBEDO
+surfaceAlbedo*=baseWeight;
+#ifdef BASE_WEIGHT
+surfaceAlbedo*=baseWeightTexture.r;
+#endif
+#ifdef OPACITY
+#ifdef OPACITYRGB
+alpha=getLuminance(opacityMap.rgb);
+#else
+alpha*=opacityMap.a;
+#endif
+alpha*=vOpacityInfos.y;
+#endif
+#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+alpha*=vColor.a;
+#endif
+#if !defined(SS_LINKREFRACTIONTOTRANSPARENCY) && !defined(ALPHAFRESNEL)
+#ifdef ALPHATEST
+#if DEBUGMODE != 88
+if (alpha<ALPHATESTVALUE)
+discard;
+#endif
+#ifndef ALPHABLEND
+alpha=1.0;
+#endif
+#endif
+#endif
+outParams.surfaceAlbedo=surfaceAlbedo;outParams.alpha=alpha;return outParams;}
+`;
+e.IncludesShadersStore[u] || (e.IncludesShadersStore[u] = Z);
+const C = "pbrBlockReflectivity", J = `struct reflectivityOutParams
+{float microSurface;float roughness;float diffuseRoughness;float reflectanceF0;vec3 reflectanceF90;vec3 colorReflectanceF0;vec3 colorReflectanceF90;
+#ifdef METALLICWORKFLOW
+vec3 surfaceAlbedo;float metallic;float specularWeight;vec3 dielectricColorF0;
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+vec3 ambientOcclusionColor;
+#endif
+#if DEBUGMODE>0
+#ifdef METALLICWORKFLOW
+#ifdef REFLECTIVITY
+vec4 surfaceMetallicColorMap;
+#endif
+vec3 metallicF0;
+#else
+#ifdef REFLECTIVITY
+vec4 surfaceReflectivityColorMap;
+#endif
+#endif
+#endif
+};
+#define pbr_inline
+reflectivityOutParams reflectivityBlock(
+in vec4 reflectivityColor
+#ifdef METALLICWORKFLOW
+,in vec3 surfaceAlbedo
+,in vec4 metallicReflectanceFactors
+#endif
+,in float baseDiffuseRoughness
+#ifdef BASE_DIFFUSE_ROUGHNESS
+,in float baseDiffuseRoughnessTexture
+,in vec2 baseDiffuseRoughnessInfos
+#endif
+#ifdef REFLECTIVITY
+,in vec3 reflectivityInfos
+,in vec4 surfaceMetallicOrReflectivityColorMap
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+,in vec3 ambientOcclusionColorIn
+#endif
+#ifdef MICROSURFACEMAP
+,in vec4 microSurfaceTexel
+#endif
+#ifdef DETAIL
+,in vec4 detailColor
+,in vec4 vDetailInfos
+#endif
+)
+{reflectivityOutParams outParams;float microSurface=reflectivityColor.a;vec3 surfaceReflectivityColor=reflectivityColor.rgb;
+#ifdef METALLICWORKFLOW
+vec2 metallicRoughness=surfaceReflectivityColor.rg;float ior=surfaceReflectivityColor.b;
+#ifdef REFLECTIVITY
+#if DEBUGMODE>0
+outParams.surfaceMetallicColorMap=surfaceMetallicOrReflectivityColorMap;
+#endif
+#ifdef AOSTOREINMETALMAPRED
+vec3 aoStoreInMetalMap=vec3(surfaceMetallicOrReflectivityColorMap.r,surfaceMetallicOrReflectivityColorMap.r,surfaceMetallicOrReflectivityColorMap.r);outParams.ambientOcclusionColor=mix(ambientOcclusionColorIn,aoStoreInMetalMap,reflectivityInfos.z);
+#endif
+#ifdef METALLNESSSTOREINMETALMAPBLUE
+metallicRoughness.r*=surfaceMetallicOrReflectivityColorMap.b;
+#else
+metallicRoughness.r*=surfaceMetallicOrReflectivityColorMap.r;
+#endif
+#ifdef ROUGHNESSSTOREINMETALMAPALPHA
+metallicRoughness.g*=surfaceMetallicOrReflectivityColorMap.a;
+#else
+#ifdef ROUGHNESSSTOREINMETALMAPGREEN
+metallicRoughness.g*=surfaceMetallicOrReflectivityColorMap.g;
+#endif
+#endif
+#endif
+#ifdef DETAIL
+float detailRoughness=mix(0.5,detailColor.b,vDetailInfos.w);float loLerp=mix(0.,metallicRoughness.g,detailRoughness*2.);float hiLerp=mix(metallicRoughness.g,1.,(detailRoughness-0.5)*2.);metallicRoughness.g=mix(loLerp,hiLerp,step(detailRoughness,0.5));
+#endif
+#ifdef MICROSURFACEMAP
+metallicRoughness.g*=microSurfaceTexel.r;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS
+microSurface=1.0-metallicRoughness.g;vec3 baseColor=surfaceAlbedo;outParams.metallic=metallicRoughness.r;outParams.specularWeight=metallicReflectanceFactors.a;float dielectricF0=reflectivityColor.a*outParams.specularWeight;surfaceReflectivityColor=metallicReflectanceFactors.rgb;
+#if DEBUGMODE>0
+outParams.metallicF0=vec3(dielectricF0)*surfaceReflectivityColor;
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+outParams.surfaceAlbedo=baseColor.rgb*(vec3(1.0)-vec3(dielectricF0)*surfaceReflectivityColor)*(1.0-outParams.metallic);
+#else
+outParams.surfaceAlbedo=baseColor.rgb;
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+{vec3 reflectivityColor=mix(dielectricF0*surfaceReflectivityColor,baseColor.rgb,outParams.metallic);outParams.reflectanceF0=max(reflectivityColor.r,max(reflectivityColor.g,reflectivityColor.b));}
+#else
+#if DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_GLTF
+float maxF0=max(surfaceReflectivityColor.r,max(surfaceReflectivityColor.g,surfaceReflectivityColor.b));outParams.reflectanceF0=mix(dielectricF0*maxF0,1.0,outParams.metallic);
+#else
+outParams.reflectanceF0=mix(dielectricF0,1.0,outParams.metallic);
+#endif
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+outParams.reflectanceF90=vec3(outParams.specularWeight);float f90Scale=1.0;
+#else
+float f90Scale=clamp(2.0*(ior-1.0),0.0,1.0);outParams.reflectanceF90=vec3(mix(outParams.specularWeight*f90Scale,1.0,outParams.metallic));
+#endif
+outParams.dielectricColorF0=vec3(dielectricF0*surfaceReflectivityColor);vec3 metallicColorF0=baseColor.rgb;outParams.colorReflectanceF0=mix(outParams.dielectricColorF0,metallicColorF0,outParams.metallic);
+#if (DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_OPENPBR)
+vec3 dielectricColorF90=surfaceReflectivityColor*vec3(outParams.specularWeight)*vec3(f90Scale);
+#else
+vec3 dielectricColorF90=vec3(outParams.specularWeight*f90Scale);
+#endif
+#if (CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR)
+vec3 conductorColorF90=surfaceReflectivityColor;
+#else
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+vec3 conductorColorF90=outParams.reflectanceF90;
+#else
+vec3 conductorColorF90=vec3(1.0);
+#endif
+#endif
+outParams.colorReflectanceF90=mix(dielectricColorF90,conductorColorF90,outParams.metallic);
+#else
+#ifdef REFLECTIVITY
+surfaceReflectivityColor*=surfaceMetallicOrReflectivityColorMap.rgb;
+#if DEBUGMODE>0
+outParams.surfaceReflectivityColorMap=surfaceMetallicOrReflectivityColorMap;
+#endif
+#ifdef MICROSURFACEFROMREFLECTIVITYMAP
+microSurface*=surfaceMetallicOrReflectivityColorMap.a;microSurface*=reflectivityInfos.z;
+#else
+#ifdef MICROSURFACEAUTOMATIC
+microSurface*=computeDefaultMicroSurface(microSurface,surfaceReflectivityColor);
+#endif
+#ifdef MICROSURFACEMAP
+microSurface*=microSurfaceTexel.r;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_MICROSURFACE
+#endif
+#endif
+outParams.colorReflectanceF0=surfaceReflectivityColor;outParams.reflectanceF0=max(surfaceReflectivityColor.r,max(surfaceReflectivityColor.g,surfaceReflectivityColor.b));outParams.reflectanceF90=vec3(1.0);
+#if (DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_OPENPBR)
+outParams.colorReflectanceF90=surfaceReflectivityColor;
+#else
+outParams.colorReflectanceF90=vec3(1.0);
+#endif
+#endif
+microSurface=saturate(microSurface);float roughness=1.-microSurface;float diffuseRoughness=baseDiffuseRoughness;
+#ifdef BASE_DIFFUSE_ROUGHNESS
+diffuseRoughness*=baseDiffuseRoughnessTexture*baseDiffuseRoughnessInfos.y;
+#endif
+outParams.microSurface=microSurface;outParams.roughness=roughness;outParams.diffuseRoughness=diffuseRoughness;return outParams;}
+`;
+e.IncludesShadersStore[C] || (e.IncludesShadersStore[C] = J);
+const S = "pbrBlockAmbientOcclusion", j = `struct ambientOcclusionOutParams
+{vec3 ambientOcclusionColor;
+#if DEBUGMODE>0 && defined(AMBIENT)
+vec3 ambientOcclusionColorMap;
+#endif
+};ambientOcclusionOutParams ambientOcclusionBlock(
+#ifdef AMBIENT
+in vec3 ambientOcclusionColorMap_,
+in vec4 vAmbientInfos
+#endif
+)
+{ambientOcclusionOutParams outParams;vec3 ambientOcclusionColor=vec3(1.,1.,1.);
+#ifdef AMBIENT
+vec3 ambientOcclusionColorMap=ambientOcclusionColorMap_*vAmbientInfos.y;
+#ifdef AMBIENTINGRAYSCALE
+ambientOcclusionColorMap=vec3(ambientOcclusionColorMap.r,ambientOcclusionColorMap.r,ambientOcclusionColorMap.r);
+#endif
+ambientOcclusionColor=mix(ambientOcclusionColor,ambientOcclusionColorMap,vAmbientInfos.z);
+#if DEBUGMODE>0
+outParams.ambientOcclusionColorMap=ambientOcclusionColorMap;
+#endif
+#endif
+outParams.ambientOcclusionColor=ambientOcclusionColor;return outParams;}
+`;
+e.IncludesShadersStore[S] || (e.IncludesShadersStore[S] = j);
+const A = "pbrBlockAlphaFresnel", Q = `#ifdef ALPHAFRESNEL
+#if defined(ALPHATEST) || defined(ALPHABLEND)
+struct alphaFresnelOutParams
+{float alpha;};
+#define pbr_inline
+alphaFresnelOutParams alphaFresnelBlock(
+in vec3 normalW,
+in vec3 viewDirectionW,
+in float alpha,
+in float microSurface
+)
+{alphaFresnelOutParams outParams;float opacityPerceptual=alpha;
+#ifdef LINEARALPHAFRESNEL
+float opacity0=opacityPerceptual;
+#else
+float opacity0=opacityPerceptual*opacityPerceptual;
+#endif
+float opacity90=fresnelGrazingReflectance(opacity0);vec3 normalForward=faceforward(normalW,-viewDirectionW,normalW);outParams.alpha=getReflectanceFromAnalyticalBRDFLookup_Jones(saturate(dot(viewDirectionW,normalForward)),vec3(opacity0),vec3(opacity90),sqrt(microSurface)).x;
+#ifdef ALPHATEST
+if (outParams.alpha<ALPHATESTVALUE)
+discard;
+#ifndef ALPHABLEND
+outParams.alpha=1.0;
+#endif
+#endif
+return outParams;}
+#endif
+#endif
+`;
+e.IncludesShadersStore[A] || (e.IncludesShadersStore[A] = Q);
+const m = "pbrBlockAnisotropic", ee = `#ifdef ANISOTROPIC
+struct anisotropicOutParams
+{float anisotropy;vec3 anisotropicTangent;vec3 anisotropicBitangent;vec3 anisotropicNormal;
+#if DEBUGMODE>0 && defined(ANISOTROPIC_TEXTURE)
+vec3 anisotropyMapData;
+#endif
+};
+#define pbr_inline
+anisotropicOutParams anisotropicBlock(
+in vec3 vAnisotropy,
+in float roughness,
+#ifdef ANISOTROPIC_TEXTURE
+in vec3 anisotropyMapData,
+#endif
+in mat3 TBN,
+in vec3 normalW,
+in vec3 viewDirectionW
+)
+{anisotropicOutParams outParams;float anisotropy=vAnisotropy.b;vec3 anisotropyDirection=vec3(vAnisotropy.xy,0.);
+#ifdef ANISOTROPIC_TEXTURE
+anisotropy*=anisotropyMapData.b;
+#if DEBUGMODE>0
+outParams.anisotropyMapData=anisotropyMapData;
+#endif
+anisotropyMapData.rg=anisotropyMapData.rg*2.0-1.0;
+#ifdef ANISOTROPIC_LEGACY
+anisotropyDirection.rg*=anisotropyMapData.rg;
+#else
+anisotropyDirection.xy=mat2(anisotropyDirection.x,anisotropyDirection.y,-anisotropyDirection.y,anisotropyDirection.x)*normalize(anisotropyMapData.rg);
+#endif
+#endif
+mat3 anisoTBN=mat3(normalize(TBN[0]),normalize(TBN[1]),normalize(TBN[2]));vec3 anisotropicTangent=normalize(anisoTBN*anisotropyDirection);vec3 anisotropicBitangent=normalize(cross(anisoTBN[2],anisotropicTangent));outParams.anisotropy=anisotropy;outParams.anisotropicTangent=anisotropicTangent;outParams.anisotropicBitangent=anisotropicBitangent;outParams.anisotropicNormal=getAnisotropicBentNormals(anisotropicTangent,anisotropicBitangent,normalW,viewDirectionW,anisotropy,roughness);return outParams;}
+#endif
+`;
+e.IncludesShadersStore[m] || (e.IncludesShadersStore[m] = ee);
+const I = "pbrBlockReflection", ie = `#ifdef REFLECTION
+struct reflectionOutParams
+{vec4 environmentRadiance;vec3 environmentIrradiance;
+#ifdef REFLECTIONMAP_3D
+vec3 reflectionCoords;
+#else
+vec2 reflectionCoords;
+#endif
+#ifdef SS_TRANSLUCENCY
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+vec3 irradianceVector;
+#endif
+#endif
+#endif
+};
+#define pbr_inline
+void createReflectionCoords(
+in vec3 vPositionW,
+in vec3 normalW,
+#ifdef ANISOTROPIC
+in anisotropicOutParams anisotropicOut,
+#endif
+#ifdef REFLECTIONMAP_3D
+out vec3 reflectionCoords
+#else
+out vec2 reflectionCoords
+#endif
+)
+{
+#ifdef ANISOTROPIC
+vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),anisotropicOut.anisotropicNormal);
+#else
+vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+reflectionCoords=reflectionVector;
+#else
+reflectionCoords=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0-reflectionCoords.y;
+#endif
+}
+#define pbr_inline
+#define inline
+void sampleReflectionTexture(
+in float alphaG,
+in vec3 vReflectionMicrosurfaceInfos,
+in vec2 vReflectionInfos,
+in vec3 vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+in float NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+in float roughness,
+#endif
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSampler,
+const vec3 reflectionCoords,
+#else
+in sampler2D reflectionSampler,
+const vec2 reflectionCoords,
+#endif
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSamplerLow,
+in samplerCube reflectionSamplerHigh,
+#else
+in sampler2D reflectionSamplerLow,
+in sampler2D reflectionSamplerHigh,
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+in vec2 vReflectionFilteringInfo,
+#endif
+out vec4 environmentRadiance
+)
+{
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG,NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+float reflectionLOD=getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x,roughness);
+#else
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG);
+#endif
+#ifdef LODBASEDMICROSFURACE
+reflectionLOD=reflectionLOD*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;
+#ifdef LODINREFLECTIONALPHA
+float automaticReflectionLOD=UNPACK_LOD(sampleReflection(reflectionSampler,reflectionCoords).a);float requestedReflectionLOD=max(automaticReflectionLOD,reflectionLOD);
+#else
+float requestedReflectionLOD=reflectionLOD;
+#endif
+#ifdef REALTIME_FILTERING
+environmentRadiance=vec4(radiance(alphaG,reflectionSampler,reflectionCoords,vReflectionFilteringInfo),1.0);
+#else
+environmentRadiance=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);
+#endif
+#else
+float lodReflectionNormalized=saturate(reflectionLOD/log2(vReflectionMicrosurfaceInfos.x));float lodReflectionNormalizedDoubled=lodReflectionNormalized*2.0;vec4 environmentMid=sampleReflection(reflectionSampler,reflectionCoords);if (lodReflectionNormalizedDoubled<1.0){environmentRadiance=mix(
+sampleReflection(reflectionSamplerHigh,reflectionCoords),
+environmentMid,
+lodReflectionNormalizedDoubled
+);} else {environmentRadiance=mix(
+environmentMid,
+sampleReflection(reflectionSamplerLow,reflectionCoords),
+lodReflectionNormalizedDoubled-1.0
+);}
+#endif
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb=fromRGBD(environmentRadiance);
+#endif
+#ifdef GAMMAREFLECTION
+environmentRadiance.rgb=toLinearSpace(environmentRadiance.rgb);
+#endif
+environmentRadiance.rgb*=vReflectionInfos.x;environmentRadiance.rgb*=vReflectionColor.rgb;}
+#define pbr_inline
+#define inline
+reflectionOutParams reflectionBlock(
+in vec3 vPositionW
+,in vec3 normalW
+,in float alphaG
+,in vec3 vReflectionMicrosurfaceInfos
+,in vec2 vReflectionInfos
+,in vec3 vReflectionColor
+#ifdef ANISOTROPIC
+,in anisotropicOutParams anisotropicOut
+#endif
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+,in float NdotVUnclamped
+#endif
+#ifdef LINEARSPECULARREFLECTION
+,in float roughness
+#endif
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSampler
+#else
+,in sampler2D reflectionSampler
+#endif
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,in vec3 vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,in mat4 reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+,in samplerCube irradianceSampler
+#else
+,in sampler2D irradianceSampler
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,in vec3 reflectionDominantDirection
+#endif
+#endif
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSamplerLow
+,in samplerCube reflectionSamplerHigh
+#else
+,in sampler2D reflectionSamplerLow
+,in sampler2D reflectionSamplerHigh
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,in sampler2D icdfSampler
+#endif
+#endif
+,in vec3 viewDirectionW
+,in float diffuseRoughness
+,in vec3 surfaceAlbedo
+)
+{reflectionOutParams outParams;vec4 environmentRadiance=vec4(0.,0.,0.,0.);
+#ifdef REFLECTIONMAP_3D
+vec3 reflectionCoords=vec3(0.);
+#else
+vec2 reflectionCoords=vec2(0.);
+#endif
+createReflectionCoords(
+vPositionW,
+normalW,
+#ifdef ANISOTROPIC
+anisotropicOut,
+#endif
+reflectionCoords
+);sampleReflectionTexture(
+alphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+roughness,
+#endif
+#ifdef REFLECTIONMAP_3D
+reflectionSampler,
+reflectionCoords,
+#else
+reflectionSampler,
+reflectionCoords,
+#endif
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+environmentRadiance
+);vec3 environmentIrradiance=vec3(0.,0.,0.);
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+#ifdef ANISOTROPIC
+vec3 irradianceVector=vec3(reflectionMatrix*vec4(anisotropicOut.anisotropicNormal,0)).xyz;
+#else
+vec3 irradianceVector=vec3(reflectionMatrix*vec4(normalW,0)).xyz;
+#endif
+vec3 irradianceView=vec3(reflectionMatrix*vec4(viewDirectionW,0)).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
+float NdotV=max(dot(normalW,viewDirectionW),0.0);irradianceVector=mix(irradianceVector,irradianceView,(0.5*(1.0-NdotV))*diffuseRoughness);
+#endif
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;
+#endif
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+environmentIrradiance=vEnvironmentIrradiance;
+#else
+#if defined(REALTIME_FILTERING)
+environmentIrradiance=irradiance(reflectionSampler,irradianceVector,vReflectionFilteringInfo,diffuseRoughness,surfaceAlbedo,irradianceView
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+);
+#else
+environmentIrradiance=computeEnvironmentIrradiance(irradianceVector);
+#endif
+#ifdef SS_TRANSLUCENCY
+outParams.irradianceVector=irradianceVector;
+#endif
+#endif
+#elif defined(USEIRRADIANCEMAP)
+#ifdef REFLECTIONMAP_3D
+vec4 environmentIrradiance4=sampleReflection(irradianceSampler,irradianceVector);
+#else
+vec4 environmentIrradiance4=sampleReflection(irradianceSampler,reflectionCoords);
+#endif
+environmentIrradiance=environmentIrradiance4.rgb;
+#ifdef RGBDREFLECTION
+environmentIrradiance.rgb=fromRGBD(environmentIrradiance4);
+#endif
+#ifdef GAMMAREFLECTION
+environmentIrradiance.rgb=toLinearSpace(environmentIrradiance.rgb);
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+vec3 Ls=normalize(reflectionDominantDirection);float NoL=dot(irradianceVector,Ls);float NoV=dot(irradianceVector,irradianceView);vec3 diffuseRoughnessTerm=vec3(1.0);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+float LoV=dot (Ls,irradianceView);float mag=length(reflectionDominantDirection)*2.0;vec3 clampedAlbedo=clamp(surfaceAlbedo,vec3(0.1),vec3(1.0));diffuseRoughnessTerm=diffuseBRDF_EON(clampedAlbedo,diffuseRoughness,NoL,NoV,LoV)*PI;diffuseRoughnessTerm=diffuseRoughnessTerm/clampedAlbedo;diffuseRoughnessTerm=mix(vec3(1.0),diffuseRoughnessTerm,sqrt(clamp(mag*NoV,0.0,1.0)));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+vec3 H=(irradianceView+Ls)*0.5;float VoH=dot(irradianceView,H);diffuseRoughnessTerm=vec3(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+environmentIrradiance=environmentIrradiance.rgb*diffuseRoughnessTerm;
+#endif
+#endif
+environmentIrradiance*=vReflectionColor.rgb*vReflectionInfos.x;
+#ifdef MIX_IBL_RADIANCE_WITH_IRRADIANCE
+outParams.environmentRadiance=vec4(mix(environmentRadiance.rgb,environmentIrradiance,alphaG),environmentRadiance.a);
+#else
+outParams.environmentRadiance=environmentRadiance;
+#endif
+outParams.environmentIrradiance=environmentIrradiance;outParams.reflectionCoords=reflectionCoords;return outParams;}
+#endif
+`;
+e.IncludesShadersStore[I] || (e.IncludesShadersStore[I] = ie);
+const v = "pbrBlockSheen", ne = `#ifdef SHEEN
+struct sheenOutParams
+{float sheenIntensity;vec3 sheenColor;float sheenRoughness;
+#ifdef SHEEN_LINKWITHALBEDO
+vec3 surfaceAlbedo;
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+float sheenAlbedoScaling;
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+vec3 finalSheenRadianceScaled;
+#endif
+#if DEBUGMODE>0
+#ifdef SHEEN_TEXTURE
+vec4 sheenMapData;
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+vec3 sheenEnvironmentReflectance;
+#endif
+#endif
+};
+#define pbr_inline
+#define inline
+sheenOutParams sheenBlock(
+in vec4 vSheenColor
+#ifdef SHEEN_ROUGHNESS
+,in float vSheenRoughness
+#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+,in vec4 sheenMapRoughnessData
+#endif
+#endif
+,in float roughness
+#ifdef SHEEN_TEXTURE
+,in vec4 sheenMapData
+,in float sheenMapLevel
+#endif
+,in float reflectance
+#ifdef SHEEN_LINKWITHALBEDO
+,in vec3 baseColor
+,in vec3 surfaceAlbedo
+#endif
+#ifdef ENVIRONMENTBRDF
+,in float NdotV
+,in vec3 environmentBrdf
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+,in vec2 AARoughnessFactors
+,in vec3 vReflectionMicrosurfaceInfos
+,in vec2 vReflectionInfos
+,in vec3 vReflectionColor
+,in vec4 vLightingIntensity
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSampler
+,in vec3 reflectionCoords
+#else
+,in sampler2D reflectionSampler
+,in vec2 reflectionCoords
+#endif
+,in float NdotVUnclamped
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSamplerLow
+,in samplerCube reflectionSamplerHigh
+#else
+,in sampler2D reflectionSamplerLow
+,in sampler2D reflectionSamplerHigh
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+,in float seo
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+,in float eho
+#endif
+#endif
+)
+{sheenOutParams outParams;float sheenIntensity=vSheenColor.a;
+#ifdef SHEEN_TEXTURE
+#if DEBUGMODE>0
+outParams.sheenMapData=sheenMapData;
+#endif
+#endif
+#ifdef SHEEN_LINKWITHALBEDO
+float sheenFactor=pow5(1.0-sheenIntensity);vec3 sheenColor=baseColor.rgb*(1.0-sheenFactor);float sheenRoughness=sheenIntensity;outParams.surfaceAlbedo=surfaceAlbedo*sheenFactor;
+#ifdef SHEEN_TEXTURE
+sheenIntensity*=sheenMapData.a;
+#endif
+#else
+vec3 sheenColor=vSheenColor.rgb;
+#ifdef SHEEN_TEXTURE
+#ifdef SHEEN_GAMMATEXTURE
+sheenColor.rgb*=toLinearSpace(sheenMapData.rgb);
+#else
+sheenColor.rgb*=sheenMapData.rgb;
+#endif
+sheenColor.rgb*=sheenMapLevel;
+#endif
+#ifdef SHEEN_ROUGHNESS
+float sheenRoughness=vSheenRoughness;
+#ifdef SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE
+#if defined(SHEEN_TEXTURE)
+sheenRoughness*=sheenMapData.a;
+#endif
+#elif defined(SHEEN_TEXTURE_ROUGHNESS)
+sheenRoughness*=sheenMapRoughnessData.a;
+#endif
+#else
+float sheenRoughness=roughness;
+#ifdef SHEEN_TEXTURE
+sheenIntensity*=sheenMapData.a;
+#endif
+#endif
+#if !defined(SHEEN_ALBEDOSCALING)
+sheenIntensity*=(1.-reflectance);
+#endif
+sheenColor*=sheenIntensity;
+#endif
+#ifdef ENVIRONMENTBRDF
+/*#ifdef SHEEN_SOFTER
+vec3 environmentSheenBrdf=vec3(0.,0.,getBRDFLookupCharlieSheen(NdotV,sheenRoughness));
+#else*/
+#ifdef SHEEN_ROUGHNESS
+vec3 environmentSheenBrdf=getBRDFLookup(NdotV,sheenRoughness);
+#else
+vec3 environmentSheenBrdf=environmentBrdf;
+#endif
+/*#endif*/
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+float sheenAlphaG=convertRoughnessToAverageSlope(sheenRoughness);
+#ifdef SPECULARAA
+sheenAlphaG+=AARoughnessFactors.y;
+#endif
+vec4 environmentSheenRadiance=vec4(0.,0.,0.,0.);sampleReflectionTexture(
+sheenAlphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+sheenRoughness,
+#endif
+reflectionSampler,
+reflectionCoords,
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+environmentSheenRadiance
+);vec3 sheenEnvironmentReflectance=getSheenReflectanceFromBRDFLookup(sheenColor,environmentSheenBrdf);
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+sheenEnvironmentReflectance*=seo;
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+sheenEnvironmentReflectance*=eho;
+#endif
+#if DEBUGMODE>0
+outParams.sheenEnvironmentReflectance=sheenEnvironmentReflectance;
+#endif
+outParams.finalSheenRadianceScaled=
+environmentSheenRadiance.rgb *
+sheenEnvironmentReflectance *
+vLightingIntensity.z;
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+outParams.sheenAlbedoScaling=1.0-sheenIntensity*max(max(sheenColor.r,sheenColor.g),sheenColor.b)*environmentSheenBrdf.b;
+#endif
+outParams.sheenIntensity=sheenIntensity;outParams.sheenColor=sheenColor;outParams.sheenRoughness=sheenRoughness;return outParams;}
+#endif
+`;
+e.IncludesShadersStore[v] || (e.IncludesShadersStore[v] = ne);
+const N = "pbrBlockClearcoat", ae = `struct clearcoatOutParams
+{vec3 specularEnvironmentR0;float conservationFactor;vec3 clearCoatNormalW;vec2 clearCoatAARoughnessFactors;float clearCoatIntensity;float clearCoatRoughness;
+#ifdef REFLECTION
+vec3 finalClearCoatRadianceScaled;
+#endif
+#ifdef CLEARCOAT_TINT
+vec3 absorption;float clearCoatNdotVRefract;vec3 clearCoatColor;float clearCoatThickness;
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+vec3 energyConservationFactorClearCoat;
+#endif
+#if DEBUGMODE>0
+#ifdef CLEARCOAT_BUMP
+mat3 TBNClearCoat;
+#endif
+#ifdef CLEARCOAT_TEXTURE
+vec2 clearCoatMapData;
+#endif
+#if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
+vec4 clearCoatTintMapData;
+#endif
+#ifdef REFLECTION
+vec4 environmentClearCoatRadiance;vec3 clearCoatEnvironmentReflectance;
+#endif
+float clearCoatNdotV;
+#endif
+};
+#ifdef CLEARCOAT
+#define pbr_inline
+#define inline
+clearcoatOutParams clearcoatBlock(
+in vec3 vPositionW
+,in vec3 geometricNormalW
+,in vec3 viewDirectionW
+,in vec2 vClearCoatParams
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+,in vec4 clearCoatMapRoughnessData
+#endif
+,in vec3 specularEnvironmentR0
+#ifdef CLEARCOAT_TEXTURE
+,in vec2 clearCoatMapData
+#endif
+#ifdef CLEARCOAT_TINT
+,in vec4 vClearCoatTintParams
+,in float clearCoatColorAtDistance
+,in vec4 vClearCoatRefractionParams
+#ifdef CLEARCOAT_TINT_TEXTURE
+,in vec4 clearCoatTintMapData
+#endif
+#endif
+#ifdef CLEARCOAT_BUMP
+,in vec2 vClearCoatBumpInfos
+,in vec4 clearCoatBumpMapData
+,in vec2 vClearCoatBumpUV
+#if defined(TANGENT) && defined(NORMAL)
+,in mat3 vTBN
+#else
+,in vec2 vClearCoatTangentSpaceParams
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+,in mat4 normalMatrix
+#endif
+#endif
+#if defined(FORCENORMALFORWARD) && defined(NORMAL)
+,in vec3 faceNormal
+#endif
+#ifdef REFLECTION
+,in vec3 vReflectionMicrosurfaceInfos
+,in vec2 vReflectionInfos
+,in vec3 vReflectionColor
+,in vec4 vLightingIntensity
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSampler
+#else
+,in sampler2D reflectionSampler
+#endif
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+,in samplerCube reflectionSamplerLow
+,in samplerCube reflectionSamplerHigh
+#else
+,in sampler2D reflectionSamplerLow
+,in sampler2D reflectionSamplerHigh
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vReflectionFilteringInfo
+#endif
+#endif
+#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)
+,in float frontFacingMultiplier
+#endif
+)
+{clearcoatOutParams outParams;float clearCoatIntensity=vClearCoatParams.x;float clearCoatRoughness=vClearCoatParams.y;
+#ifdef CLEARCOAT_TEXTURE
+clearCoatIntensity*=clearCoatMapData.x;
+#ifdef CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE
+clearCoatRoughness*=clearCoatMapData.y;
+#endif
+#if DEBUGMODE>0
+outParams.clearCoatMapData=clearCoatMapData;
+#endif
+#endif
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+clearCoatRoughness*=clearCoatMapRoughnessData.y;
+#endif
+outParams.clearCoatIntensity=clearCoatIntensity;outParams.clearCoatRoughness=clearCoatRoughness;
+#ifdef CLEARCOAT_TINT
+vec3 clearCoatColor=vClearCoatTintParams.rgb;float clearCoatThickness=vClearCoatTintParams.a;
+#ifdef CLEARCOAT_TINT_TEXTURE
+#ifdef CLEARCOAT_TINT_GAMMATEXTURE
+clearCoatColor*=toLinearSpace(clearCoatTintMapData.rgb);
+#else
+clearCoatColor*=clearCoatTintMapData.rgb;
+#endif
+clearCoatThickness*=clearCoatTintMapData.a;
+#if DEBUGMODE>0
+outParams.clearCoatTintMapData=clearCoatTintMapData;
+#endif
+#endif
+outParams.clearCoatColor=computeColorAtDistanceInMedia(clearCoatColor,clearCoatColorAtDistance);outParams.clearCoatThickness=clearCoatThickness;
+#endif
+#ifdef CLEARCOAT_REMAP_F0
+vec3 specularEnvironmentR0Updated=getR0RemappedForClearCoat(specularEnvironmentR0);
+#else
+vec3 specularEnvironmentR0Updated=specularEnvironmentR0;
+#endif
+outParams.specularEnvironmentR0=mix(specularEnvironmentR0,specularEnvironmentR0Updated,clearCoatIntensity);vec3 clearCoatNormalW=geometricNormalW;
+#ifdef CLEARCOAT_BUMP
+#ifdef NORMALXYSCALE
+float clearCoatNormalScale=1.0;
+#else
+float clearCoatNormalScale=vClearCoatBumpInfos.y;
+#endif
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBNClearCoat=vTBN;
+#else
+vec2 TBNClearCoatUV=vClearCoatBumpUV*frontFacingMultiplier;mat3 TBNClearCoat=cotangent_frame(clearCoatNormalW*clearCoatNormalScale,vPositionW,TBNClearCoatUV,vClearCoatTangentSpaceParams);
+#endif
+#if DEBUGMODE>0
+outParams.TBNClearCoat=TBNClearCoat;
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+clearCoatNormalW=normalize(clearCoatBumpMapData.xyz *2.0-1.0);clearCoatNormalW=normalize(mat3(normalMatrix)*clearCoatNormalW);
+#else
+clearCoatNormalW=perturbNormal(TBNClearCoat,clearCoatBumpMapData.xyz,vClearCoatBumpInfos.y);
+#endif
+#endif
+#if defined(FORCENORMALFORWARD) && defined(NORMAL)
+clearCoatNormalW*=sign(dot(clearCoatNormalW,faceNormal));
+#endif
+#if defined(TWOSIDEDLIGHTING) && defined(NORMAL)
+clearCoatNormalW=clearCoatNormalW*frontFacingMultiplier;
+#endif
+outParams.clearCoatNormalW=clearCoatNormalW;outParams.clearCoatAARoughnessFactors=getAARoughnessFactors(clearCoatNormalW.xyz);float clearCoatNdotVUnclamped=dot(clearCoatNormalW,viewDirectionW);float clearCoatNdotV=absEps(clearCoatNdotVUnclamped);
+#if DEBUGMODE>0
+outParams.clearCoatNdotV=clearCoatNdotV;
+#endif
+#ifdef CLEARCOAT_TINT
+vec3 clearCoatVRefract=refract(-viewDirectionW,clearCoatNormalW,vClearCoatRefractionParams.y);outParams.clearCoatNdotVRefract=absEps(dot(clearCoatNormalW,clearCoatVRefract));
+#endif
+#if defined(ENVIRONMENTBRDF) && (!defined(REFLECTIONMAP_SKYBOX) || defined(MS_BRDF_ENERGY_CONSERVATION))
+vec3 environmentClearCoatBrdf=getBRDFLookup(clearCoatNdotV,clearCoatRoughness);
+#endif
+#if defined(REFLECTION)
+float clearCoatAlphaG=convertRoughnessToAverageSlope(clearCoatRoughness);
+#ifdef SPECULARAA
+clearCoatAlphaG+=outParams.clearCoatAARoughnessFactors.y;
+#endif
+vec4 environmentClearCoatRadiance=vec4(0.,0.,0.,0.);vec3 clearCoatReflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),clearCoatNormalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+clearCoatReflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+vec3 clearCoatReflectionCoords=clearCoatReflectionVector;
+#else
+vec2 clearCoatReflectionCoords=clearCoatReflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+clearCoatReflectionCoords/=clearCoatReflectionVector.z;
+#endif
+clearCoatReflectionCoords.y=1.0-clearCoatReflectionCoords.y;
+#endif
+sampleReflectionTexture(
+clearCoatAlphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+clearCoatNdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+clearCoatRoughness,
+#endif
+reflectionSampler,
+clearCoatReflectionCoords,
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+environmentClearCoatRadiance
+);
+#if DEBUGMODE>0
+outParams.environmentClearCoatRadiance=environmentClearCoatRadiance;
+#endif
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+vec3 clearCoatEnvironmentReflectance=getReflectanceFromBRDFLookup(vec3(vClearCoatRefractionParams.x),environmentClearCoatBrdf);
+#ifdef HORIZONOCCLUSION
+#ifdef BUMP
+#ifdef REFLECTIONMAP_3D
+float clearCoatEho=environmentHorizonOcclusion(-viewDirectionW,clearCoatNormalW,geometricNormalW);clearCoatEnvironmentReflectance*=clearCoatEho;
+#endif
+#endif
+#endif
+#else
+vec3 clearCoatEnvironmentReflectance=getReflectanceFromAnalyticalBRDFLookup_Jones(clearCoatNdotV,vec3(1.),vec3(1.),sqrt(1.-clearCoatRoughness));
+#endif
+clearCoatEnvironmentReflectance*=clearCoatIntensity;
+#if DEBUGMODE>0
+outParams.clearCoatEnvironmentReflectance=clearCoatEnvironmentReflectance;
+#endif
+outParams.finalClearCoatRadianceScaled=
+environmentClearCoatRadiance.rgb *
+clearCoatEnvironmentReflectance *
+vLightingIntensity.z;
+#endif
+#if defined(CLEARCOAT_TINT)
+outParams.absorption=computeClearCoatAbsorption(outParams.clearCoatNdotVRefract,outParams.clearCoatNdotVRefract,outParams.clearCoatColor,clearCoatThickness,clearCoatIntensity);
+#endif
+float fresnelIBLClearCoat=fresnelSchlickGGX(clearCoatNdotV,vClearCoatRefractionParams.x,CLEARCOATREFLECTANCE90);fresnelIBLClearCoat*=clearCoatIntensity;outParams.conservationFactor=(1.-fresnelIBLClearCoat);
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+outParams.energyConservationFactorClearCoat=getEnergyConservationFactor(outParams.specularEnvironmentR0,environmentClearCoatBrdf);
+#endif
+return outParams;}
+#endif
+`;
+e.IncludesShadersStore[N] || (e.IncludesShadersStore[N] = ae);
+const O = "pbrBlockIridescence", oe = `struct iridescenceOutParams
+{float iridescenceIntensity;float iridescenceIOR;float iridescenceThickness;vec3 specularEnvironmentR0;};
+#ifdef IRIDESCENCE
+#define pbr_inline
+#define inline
+iridescenceOutParams iridescenceBlock(
+in vec4 vIridescenceParams
+,in float viewAngle
+,in vec3 specularEnvironmentR0
+#ifdef IRIDESCENCE_TEXTURE
+,in vec2 iridescenceMapData
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+,in vec2 iridescenceThicknessMapData
+#endif
+#ifdef CLEARCOAT
+,in float NdotVUnclamped
+,in vec2 vClearCoatParams
+#ifdef CLEARCOAT_TEXTURE
+,in vec2 clearCoatMapData
+#endif
+#endif
+)
+{iridescenceOutParams outParams;float iridescenceIntensity=vIridescenceParams.x;float iridescenceIOR=vIridescenceParams.y;float iridescenceThicknessMin=vIridescenceParams.z;float iridescenceThicknessMax=vIridescenceParams.w;float iridescenceThicknessWeight=1.;
+#ifdef IRIDESCENCE_TEXTURE
+iridescenceIntensity*=iridescenceMapData.x;
+#endif
+#if defined(IRIDESCENCE_THICKNESS_TEXTURE)
+iridescenceThicknessWeight=iridescenceThicknessMapData.g;
+#endif
+float iridescenceThickness=mix(iridescenceThicknessMin,iridescenceThicknessMax,iridescenceThicknessWeight);float topIor=1.; 
+#ifdef CLEARCOAT
+float clearCoatIntensity=vClearCoatParams.x;
+#ifdef CLEARCOAT_TEXTURE
+clearCoatIntensity*=clearCoatMapData.x;
+#endif
+topIor=mix(1.0,vClearCoatRefractionParams.w-1.,clearCoatIntensity);viewAngle=sqrt(1.0+square(1.0/topIor)*(square(NdotVUnclamped)-1.0));
+#endif
+vec3 iridescenceFresnel=evalIridescence(topIor,iridescenceIOR,viewAngle,iridescenceThickness,specularEnvironmentR0);outParams.specularEnvironmentR0=mix(specularEnvironmentR0,iridescenceFresnel,iridescenceIntensity);outParams.iridescenceIntensity=iridescenceIntensity;outParams.iridescenceThickness=iridescenceThickness;outParams.iridescenceIOR=iridescenceIOR;return outParams;}
+#endif
+`;
+e.IncludesShadersStore[O] || (e.IncludesShadersStore[O] = oe);
+const T = "pbrBlockSubSurface", re = `struct subSurfaceOutParams
+{vec3 specularEnvironmentReflectance;
+#ifdef SS_REFRACTION
+vec3 finalRefraction;vec3 surfaceAlbedo;
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+float alpha;
+#endif
+float refractionOpacity;
+#endif
+#ifdef SS_TRANSLUCENCY
+vec3 transmittance;float translucencyIntensity;
+#ifdef REFLECTION
+vec3 refractionIrradiance;
+#endif
+#endif
+#if DEBUGMODE>0
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+vec4 thicknessMap;
+#endif
+#ifdef SS_REFRACTION
+vec4 environmentRefraction;vec3 refractionTransmittance;
+#endif
+#endif
+};
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+#define pbr_inline
+#define inline
+vec4 sampleEnvironmentRefraction(
+in float ior
+,in float thickness
+,in float refractionLOD
+,in vec3 normalW
+,in vec3 vPositionW
+,in vec3 viewDirectionW
+,in mat4 view
+,in vec4 vRefractionInfos
+,in mat4 refractionMatrix
+,in vec4 vRefractionMicrosurfaceInfos
+,in float alphaG
+#ifdef SS_REFRACTIONMAP_3D
+,in samplerCube refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,in samplerCube refractionSamplerLow
+,in samplerCube refractionSamplerHigh
+#endif
+#else
+,in sampler2D refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,in sampler2D refractionSamplerLow
+,in sampler2D refractionSamplerHigh
+#endif
+#endif
+#ifdef ANISOTROPIC
+,in anisotropicOutParams anisotropicOut
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vRefractionFilteringInfo
+#endif
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+,in vec3 refractionPosition
+,in vec3 refractionSize
+#endif
+) {vec4 environmentRefraction=vec4(0.,0.,0.,0.);
+#ifdef ANISOTROPIC
+vec3 refractionVector=refract(-viewDirectionW,anisotropicOut.anisotropicNormal,ior);
+#else
+vec3 refractionVector=refract(-viewDirectionW,normalW,ior);
+#endif
+#ifdef SS_REFRACTIONMAP_OPPOSITEZ
+refractionVector.z*=-1.0;
+#endif
+#ifdef SS_REFRACTIONMAP_3D
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+refractionVector=parallaxCorrectNormal(vPositionW,refractionVector,refractionSize,refractionPosition);
+#endif
+refractionVector.y=refractionVector.y*vRefractionInfos.w;vec3 refractionCoords=refractionVector;refractionCoords=vec3(refractionMatrix*vec4(refractionCoords,0));
+#else
+#ifdef SS_USE_THICKNESS_AS_DEPTH
+vec3 vRefractionUVW=vec3(refractionMatrix*(view*vec4(vPositionW+refractionVector*thickness,1.0)));
+#else
+vec3 vRefractionUVW=vec3(refractionMatrix*(view*vec4(vPositionW+refractionVector*vRefractionInfos.z,1.0)));
+#endif
+vec2 refractionCoords=vRefractionUVW.xy/vRefractionUVW.z;refractionCoords.y=1.0-refractionCoords.y;
+#endif
+#ifdef LODBASEDMICROSFURACE
+refractionLOD=refractionLOD*vRefractionMicrosurfaceInfos.y+vRefractionMicrosurfaceInfos.z;
+#ifdef SS_LODINREFRACTIONALPHA
+float automaticRefractionLOD=UNPACK_LOD(sampleRefraction(refractionSampler,refractionCoords).a);float requestedRefractionLOD=max(automaticRefractionLOD,refractionLOD);
+#else
+float requestedRefractionLOD=refractionLOD;
+#endif
+#if defined(REALTIME_FILTERING) && defined(SS_REFRACTIONMAP_3D)
+environmentRefraction=vec4(radiance(alphaG,refractionSampler,refractionCoords,vRefractionFilteringInfo),1.0);
+#else
+environmentRefraction=sampleRefractionLod(refractionSampler,refractionCoords,requestedRefractionLOD);
+#endif
+#else
+float lodRefractionNormalized=saturate(refractionLOD/log2(vRefractionMicrosurfaceInfos.x));float lodRefractionNormalizedDoubled=lodRefractionNormalized*2.0;vec4 environmentRefractionMid=sampleRefraction(refractionSampler,refractionCoords);if (lodRefractionNormalizedDoubled<1.0){environmentRefraction=mix(
+sampleRefraction(refractionSamplerHigh,refractionCoords),
+environmentRefractionMid,
+lodRefractionNormalizedDoubled
+);} else {environmentRefraction=mix(
+environmentRefractionMid,
+sampleRefraction(refractionSamplerLow,refractionCoords),
+lodRefractionNormalizedDoubled-1.0
+);}
+#endif
+#ifdef SS_RGBDREFRACTION
+environmentRefraction.rgb=fromRGBD(environmentRefraction);
+#endif
+#ifdef SS_GAMMAREFRACTION
+environmentRefraction.rgb=toLinearSpace(environmentRefraction.rgb);
+#endif
+return environmentRefraction;}
+#endif
+#define pbr_inline
+#define inline
+subSurfaceOutParams subSurfaceBlock(
+in vec3 vSubSurfaceIntensity
+,in vec2 vThicknessParam
+,in vec4 vTintColor
+,in vec3 normalW
+,in vec3 vSpecularEnvironmentReflectance
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+,in vec4 thicknessMap
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+,in vec4 refractionIntensityMap
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+,in vec4 translucencyIntensityMap
+#endif
+#ifdef REFLECTION
+#ifdef SS_TRANSLUCENCY
+,in mat4 reflectionMatrix
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+,in vec3 irradianceVector_
+#endif
+#if defined(REALTIME_FILTERING)
+,in samplerCube reflectionSampler
+,in vec2 vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,in sampler2D icdfSampler
+#endif
+#endif
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+,in samplerCube irradianceSampler
+#else
+,in sampler2D irradianceSampler
+#endif
+#endif
+#endif
+#endif
+#if defined(SS_REFRACTION) || defined(SS_TRANSLUCENCY)
+,in vec3 surfaceAlbedo
+#endif
+#ifdef SS_REFRACTION
+,in vec3 vPositionW
+,in vec3 viewDirectionW
+,in mat4 view
+,in vec4 vRefractionInfos
+,in mat4 refractionMatrix
+,in vec4 vRefractionMicrosurfaceInfos
+,in vec4 vLightingIntensity
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+,in float alpha
+#endif
+#ifdef SS_LODINREFRACTIONALPHA
+,in float NdotVUnclamped
+#endif
+#ifdef SS_LINEARSPECULARREFRACTION
+,in float roughness
+#endif
+,in float alphaG
+#ifdef SS_REFRACTIONMAP_3D
+,in samplerCube refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,in samplerCube refractionSamplerLow
+,in samplerCube refractionSamplerHigh
+#endif
+#else
+,in sampler2D refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,in sampler2D refractionSamplerLow
+,in sampler2D refractionSamplerHigh
+#endif
+#endif
+#ifdef ANISOTROPIC
+,in anisotropicOutParams anisotropicOut
+#endif
+#ifdef REALTIME_FILTERING
+,in vec2 vRefractionFilteringInfo
+#endif
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+,in vec3 refractionPosition
+,in vec3 refractionSize
+#endif
+#ifdef SS_DISPERSION
+,in float dispersion
+#endif
+#endif
+#ifdef SS_TRANSLUCENCY
+,in vec3 vDiffusionDistance
+,in vec4 vTranslucencyColor
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE
+,in vec4 translucencyColorMap
+#endif
+#endif
+)
+{subSurfaceOutParams outParams;outParams.specularEnvironmentReflectance=vSpecularEnvironmentReflectance;
+#ifdef SS_REFRACTION
+float refractionIntensity=vSubSurfaceIntensity.x;
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+refractionIntensity*=(1.0-alpha);outParams.alpha=1.0;
+#endif
+#endif
+#ifdef SS_TRANSLUCENCY
+float translucencyIntensity=vSubSurfaceIntensity.y;
+#endif
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+#ifdef SS_USE_GLTF_TEXTURES
+float thickness=thicknessMap.g*vThicknessParam.y+vThicknessParam.x;
+#else
+float thickness=thicknessMap.r*vThicknessParam.y+vThicknessParam.x;
+#endif
+#if DEBUGMODE>0
+outParams.thicknessMap=thicknessMap;
+#endif
+#if defined(SS_REFRACTION) && defined(SS_REFRACTION_USE_INTENSITY_FROM_THICKNESS)
+#ifdef SS_USE_GLTF_TEXTURES
+refractionIntensity*=thicknessMap.r;
+#else
+refractionIntensity*=thicknessMap.g;
+#endif
+#endif
+#if defined(SS_TRANSLUCENCY) && defined(SS_TRANSLUCENCY_USE_INTENSITY_FROM_THICKNESS)
+#ifdef SS_USE_GLTF_TEXTURES
+translucencyIntensity*=thicknessMap.a;
+#else
+translucencyIntensity*=thicknessMap.b;
+#endif
+#endif
+#else
+float thickness=vThicknessParam.y;
+#endif
+#if defined(SS_REFRACTION) && defined(SS_REFRACTIONINTENSITY_TEXTURE)
+#ifdef SS_USE_GLTF_TEXTURES
+refractionIntensity*=refractionIntensityMap.r;
+#else
+refractionIntensity*=refractionIntensityMap.g;
+#endif
+#endif
+#if defined(SS_TRANSLUCENCY) && defined(SS_TRANSLUCENCYINTENSITY_TEXTURE)
+#ifdef SS_USE_GLTF_TEXTURES
+translucencyIntensity*=translucencyIntensityMap.a;
+#else
+translucencyIntensity*=translucencyIntensityMap.b;
+#endif
+#endif
+#ifdef SS_TRANSLUCENCY
+thickness=maxEps(thickness);vec4 translucencyColor=vTranslucencyColor;
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE
+translucencyColor*=translucencyColorMap;
+#endif
+vec3 transmittance=transmittanceBRDF_Burley(translucencyColor.rgb,vDiffusionDistance,thickness);transmittance*=translucencyIntensity;outParams.transmittance=transmittance;outParams.translucencyIntensity=translucencyIntensity;
+#endif
+#ifdef SS_REFRACTION
+vec4 environmentRefraction=vec4(0.,0.,0.,0.);
+#ifdef SS_HAS_THICKNESS
+float ior=vRefractionInfos.y;
+#else
+float ior=vRefractionMicrosurfaceInfos.w;
+#endif
+#ifdef SS_LODINREFRACTIONALPHA
+float refractionAlphaG=alphaG;refractionAlphaG=mix(alphaG,0.0,clamp(ior*3.0-2.0,0.0,1.0));float refractionLOD=getLodFromAlphaG(vRefractionMicrosurfaceInfos.x,refractionAlphaG,NdotVUnclamped);
+#elif defined(SS_LINEARSPECULARREFRACTION)
+float refractionRoughness=alphaG;refractionRoughness=mix(alphaG,0.0,clamp(ior*3.0-2.0,0.0,1.0));float refractionLOD=getLinearLodFromRoughness(vRefractionMicrosurfaceInfos.x,refractionRoughness);
+#else
+float refractionAlphaG=alphaG;refractionAlphaG=mix(alphaG,0.0,clamp(ior*3.0-2.0,0.0,1.0));float refractionLOD=getLodFromAlphaG(vRefractionMicrosurfaceInfos.x,refractionAlphaG);
+#endif
+float refraction_ior=vRefractionInfos.y;
+#ifdef SS_DISPERSION
+float realIOR=1.0/refraction_ior;float iorDispersionSpread=0.04*dispersion*(realIOR-1.0);vec3 iors=vec3(1.0/(realIOR-iorDispersionSpread),refraction_ior,1.0/(realIOR+iorDispersionSpread));for (int i=0; i<3; i++) {refraction_ior=iors[i];
+#endif
+vec4 envSample=sampleEnvironmentRefraction(refraction_ior,thickness,refractionLOD,normalW,vPositionW,viewDirectionW,view,vRefractionInfos,refractionMatrix,vRefractionMicrosurfaceInfos,alphaG
+#ifdef SS_REFRACTIONMAP_3D
+,refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,refractionSamplerLow
+,refractionSamplerHigh
+#endif
+#else
+,refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,refractionSamplerLow
+,refractionSamplerHigh
+#endif
+#endif
+#ifdef ANISOTROPIC
+,anisotropicOut
+#endif
+#ifdef REALTIME_FILTERING
+,vRefractionFilteringInfo
+#endif
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+,refractionPosition
+,refractionSize
+#endif
+);
+#ifdef SS_DISPERSION
+environmentRefraction[i]=envSample[i];}
+#else
+environmentRefraction=envSample;
+#endif
+environmentRefraction.rgb*=vRefractionInfos.x;
+#endif
+#ifdef SS_REFRACTION
+vec3 refractionTransmittance=vec3(refractionIntensity);
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+vec3 volumeAlbedo=computeColorAtDistanceInMedia(vTintColor.rgb,vTintColor.w);refractionTransmittance*=cocaLambert(volumeAlbedo,thickness);
+#elif defined(SS_LINKREFRACTIONTOTRANSPARENCY)
+float maxChannel=max(max(surfaceAlbedo.r,surfaceAlbedo.g),surfaceAlbedo.b);vec3 volumeAlbedo=saturate(maxChannel*surfaceAlbedo);environmentRefraction.rgb*=volumeAlbedo;
+#else
+vec3 volumeAlbedo=computeColorAtDistanceInMedia(vTintColor.rgb,vTintColor.w);refractionTransmittance*=cocaLambert(volumeAlbedo,vThicknessParam.y);
+#endif
+#ifdef SS_ALBEDOFORREFRACTIONTINT
+environmentRefraction.rgb*=surfaceAlbedo.rgb;
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+outParams.surfaceAlbedo=surfaceAlbedo*(1.-refractionIntensity);outParams.refractionOpacity=1.0;
+#else
+outParams.surfaceAlbedo=surfaceAlbedo;outParams.refractionOpacity=(1.-refractionIntensity);
+#endif
+#ifdef UNUSED_MULTIPLEBOUNCES
+vec3 bounceSpecularEnvironmentReflectance=(2.0*vSpecularEnvironmentReflectance)/(1.0+vSpecularEnvironmentReflectance);outParams.specularEnvironmentReflectance=mix(bounceSpecularEnvironmentReflectance,vSpecularEnvironmentReflectance,refractionIntensity);
+#endif
+#if DEBUGMODE>0
+outParams.refractionTransmittance=refractionTransmittance;
+#endif
+outParams.finalRefraction=environmentRefraction.rgb*refractionTransmittance*vLightingIntensity.z;outParams.finalRefraction*=vec3(1.0)-vSpecularEnvironmentReflectance;
+#if DEBUGMODE>0
+outParams.environmentRefraction=environmentRefraction;
+#endif
+#endif
+#if defined(REFLECTION) && defined(SS_TRANSLUCENCY)
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX) || !defined(USESPHERICALFROMREFLECTIONMAP)
+vec3 irradianceVector=vec3(reflectionMatrix*vec4(normalW,0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;
+#endif
+#else
+vec3 irradianceVector=irradianceVector_;
+#endif
+#if defined(USESPHERICALFROMREFLECTIONMAP)
+#if defined(REALTIME_FILTERING)
+vec3 refractionIrradiance=irradiance(reflectionSampler,-irradianceVector,vReflectionFilteringInfo,0.0,surfaceAlbedo,irradianceVector
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+);
+#else
+vec3 refractionIrradiance=computeEnvironmentIrradiance(-irradianceVector);
+#endif
+#elif defined(USEIRRADIANCEMAP)
+#ifdef REFLECTIONMAP_3D
+vec3 irradianceCoords=irradianceVector;
+#else
+vec2 irradianceCoords=irradianceVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+irradianceCoords/=irradianceVector.z;
+#endif
+irradianceCoords.y=1.0-irradianceCoords.y;
+#endif
+vec4 refractionIrradiance=sampleReflection(irradianceSampler,-irradianceCoords);
+#ifdef RGBDREFLECTION
+refractionIrradiance.rgb=fromRGBD(refractionIrradiance);
+#endif
+#ifdef GAMMAREFLECTION
+refractionIrradiance.rgb=toLinearSpace(refractionIrradiance.rgb);
+#endif
+#else
+vec4 refractionIrradiance=vec4(0.);
+#endif
+refractionIrradiance.rgb*=transmittance;
+#ifdef SS_ALBEDOFORTRANSLUCENCYTINT
+refractionIrradiance.rgb*=surfaceAlbedo.rgb;
+#endif
+outParams.refractionIrradiance=refractionIrradiance.rgb;
+#endif
+return outParams;}
+#endif
+`;
+e.IncludesShadersStore[T] || (e.IncludesShadersStore[T] = re);
+const L = "pbrBlockNormalGeometric", te = `vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=normalize(cross(dFdx(vPositionW),dFdy(vPositionW)))*vEyePosition.w;
+#endif
+vec3 geometricNormalW=normalW;
+#if defined(TWOSIDEDLIGHTING) && defined(NORMAL)
+geometricNormalW=gl_FrontFacing ? geometricNormalW : -geometricNormalW;
+#endif
+`;
+e.IncludesShadersStore[L] || (e.IncludesShadersStore[L] = te);
+const p = "pbrBlockNormalFinal", fe = `#if defined(FORCENORMALFORWARD) && defined(NORMAL)
+vec3 faceNormal=normalize(cross(dFdx(vPositionW),dFdy(vPositionW)))*vEyePosition.w;
+#if defined(TWOSIDEDLIGHTING)
+faceNormal=gl_FrontFacing ? faceNormal : -faceNormal;
+#endif
+normalW*=sign(dot(normalW,faceNormal));
+#endif
+#if defined(TWOSIDEDLIGHTING) && defined(NORMAL)
+#if defined(MIRRORED)
+normalW=gl_FrontFacing ? -normalW : normalW;
+#else
+normalW=gl_FrontFacing ? normalW : -normalW;
+#endif
+#endif
+`;
+e.IncludesShadersStore[p] || (e.IncludesShadersStore[p] = fe);
+const g = "pbrBlockLightmapInit", ce = `#ifdef LIGHTMAP
+vec4 lightmapColor=texture2D(lightmapSampler,vLightmapUV+uvOffset);
+#ifdef RGBDLIGHTMAP
+lightmapColor.rgb=fromRGBD(lightmapColor);
+#endif
+#ifdef GAMMALIGHTMAP
+lightmapColor.rgb=toLinearSpace(lightmapColor.rgb);
+#endif
+lightmapColor.rgb*=vLightmapInfos.y;
+#endif
+`;
+e.IncludesShadersStore[g] || (e.IncludesShadersStore[g] = ce);
+const _ = "pbrBlockGeometryInfo", le = `float NdotVUnclamped=dot(normalW,viewDirectionW);float NdotV=absEps(NdotVUnclamped);float alphaG=convertRoughnessToAverageSlope(roughness);vec2 AARoughnessFactors=getAARoughnessFactors(normalW.xyz);
+#ifdef SPECULARAA
+alphaG+=AARoughnessFactors.y;
+#endif
+#if defined(ENVIRONMENTBRDF)
+vec3 environmentBrdf=getBRDFLookup(NdotV,roughness);
+#endif
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef RADIANCEOCCLUSION
+#ifdef AMBIENTINGRAYSCALE
+float ambientMonochrome=aoOut.ambientOcclusionColor.r;
+#else
+float ambientMonochrome=getLuminance(aoOut.ambientOcclusionColor);
+#endif
+float seo=environmentRadianceOcclusion(ambientMonochrome,NdotVUnclamped);
+#endif
+#ifdef HORIZONOCCLUSION
+#ifdef BUMP
+#ifdef REFLECTIONMAP_3D
+float eho=environmentHorizonOcclusion(-viewDirectionW,normalW,geometricNormalW);
+#endif
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[_] || (e.IncludesShadersStore[_] = le);
+const D = "pbrBlockReflectance0", de = `float reflectanceF0=reflectivityOut.reflectanceF0;vec3 specularEnvironmentR0=reflectivityOut.colorReflectanceF0;vec3 specularEnvironmentR90=reflectivityOut.colorReflectanceF90;
+#ifdef ALPHAFRESNEL
+float reflectance90=fresnelGrazingReflectance(reflectanceF0);specularEnvironmentR90=specularEnvironmentR90*reflectance90;
+#endif
+`;
+e.IncludesShadersStore[D] || (e.IncludesShadersStore[D] = de);
+const M = "pbrBlockReflectance", se = `#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+vec3 baseSpecularEnvironmentReflectance=getReflectanceFromBRDFLookup(vec3(reflectanceF0),reflectivityOut.reflectanceF90,environmentBrdf);
+#if (CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR)
+vec3 metalEnvironmentReflectance=reflectivityOut.specularWeight*getF82Specular(NdotV,clearcoatOut.specularEnvironmentR0,reflectivityOut.colorReflectanceF90,reflectivityOut.roughness);vec3 dielectricEnvironmentReflectance=getReflectanceFromBRDFLookup(reflectivityOut.dielectricColorF0,reflectivityOut.colorReflectanceF90,environmentBrdf);vec3 colorSpecularEnvironmentReflectance=mix(dielectricEnvironmentReflectance,metalEnvironmentReflectance,reflectivityOut.metallic);
+#else
+vec3 colorSpecularEnvironmentReflectance=getReflectanceFromBRDFLookup(clearcoatOut.specularEnvironmentR0,reflectivityOut.colorReflectanceF90,environmentBrdf);
+#endif
+#ifdef RADIANCEOCCLUSION
+colorSpecularEnvironmentReflectance*=seo;
+#endif
+#ifdef HORIZONOCCLUSION
+#ifdef BUMP
+#ifdef REFLECTIONMAP_3D
+colorSpecularEnvironmentReflectance*=eho;
+#endif
+#endif
+#endif
+#else
+vec3 colorSpecularEnvironmentReflectance=getReflectanceFromAnalyticalBRDFLookup_Jones(NdotV,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,sqrt(microSurface));vec3 baseSpecularEnvironmentReflectance=getReflectanceFromAnalyticalBRDFLookup_Jones(NdotV,vec3(reflectanceF0),reflectivityOut.reflectanceF90,sqrt(microSurface));
+#endif
+#ifdef CLEARCOAT
+colorSpecularEnvironmentReflectance*=clearcoatOut.conservationFactor;
+#if defined(CLEARCOAT_TINT)
+colorSpecularEnvironmentReflectance*=clearcoatOut.absorption;
+#endif
+#endif
+`;
+e.IncludesShadersStore[M] || (e.IncludesShadersStore[M] = se);
+const h = "pbrBlockDirectLighting", Ee = `vec3 diffuseBase=vec3(0.,0.,0.);
+#ifdef SS_TRANSLUCENCY
+vec3 diffuseTransmissionBase=vec3(0.,0.,0.);
+#endif
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+#ifdef CLEARCOAT
+vec3 clearCoatBase=vec3(0.,0.,0.);
+#endif
+#ifdef SHEEN
+vec3 sheenBase=vec3(0.,0.,0.);
+#endif
+#if defined(SPECULARTERM) && defined(LIGHT0)
+vec3 coloredFresnel;
+#endif
+preLightingInfo preInfo;lightingInfo info;float shadow=1.; 
+float aggShadow=0.;float numLights=0.;
+#if defined(CLEARCOAT) && defined(CLEARCOAT_TINT)
+vec3 absorption=vec3(0.);
+#endif
+`;
+e.IncludesShadersStore[h] || (e.IncludesShadersStore[h] = Ee);
+const F = "pbrBlockFinalLitComponents", Re = `aggShadow=aggShadow/numLights;
+#if defined(ENVIRONMENTBRDF)
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+vec3 baseSpecularEnergyConservationFactor=getEnergyConservationFactor(vec3(reflectanceF0),environmentBrdf);vec3 coloredEnergyConservationFactor=getEnergyConservationFactor(clearcoatOut.specularEnvironmentR0,environmentBrdf);
+#endif
+#endif
+#if defined(SHEEN) && defined(SHEEN_ALBEDOSCALING) && defined(ENVIRONMENTBRDF)
+surfaceAlbedo.rgb=sheenOut.sheenAlbedoScaling*surfaceAlbedo.rgb;
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+#ifndef METALLICWORKFLOW
+#ifdef SPECULAR_GLOSSINESS_ENERGY_CONSERVATION
+surfaceAlbedo.rgb=(1.-reflectanceF0)*surfaceAlbedo.rgb;
+#endif
+#endif
+#endif
+#ifdef REFLECTION
+vec3 finalIrradiance=reflectionOut.environmentIrradiance;
+#ifndef LEGACY_SPECULAR_ENERGY_CONSERVATION
+#if defined(METALLICWORKFLOW) || defined(SPECULAR_GLOSSINESS_ENERGY_CONSERVATION)
+vec3 baseSpecularEnergy=vec3(baseSpecularEnvironmentReflectance);
+#if defined(ENVIRONMENTBRDF)
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+baseSpecularEnergy*=baseSpecularEnergyConservationFactor;
+#endif
+#endif
+finalIrradiance*=clamp(vec3(1.0)-baseSpecularEnergy,0.0,1.0);
+#endif
+#endif
+#if defined(CLEARCOAT)
+finalIrradiance*=clearcoatOut.conservationFactor;
+#if defined(CLEARCOAT_TINT)
+finalIrradiance*=clearcoatOut.absorption;
+#endif
+#endif
+#ifndef SS_APPLY_ALBEDO_AFTER_SUBSURFACE
+finalIrradiance*=surfaceAlbedo.rgb;
+#endif
+#if defined(SS_REFRACTION)
+finalIrradiance*=subSurfaceOut.refractionOpacity;
+#endif
+#if defined(SS_TRANSLUCENCY)
+finalIrradiance*=(1.0-subSurfaceOut.translucencyIntensity);finalIrradiance+=subSurfaceOut.refractionIrradiance;
+#endif
+#ifdef SS_APPLY_ALBEDO_AFTER_SUBSURFACE
+finalIrradiance*=surfaceAlbedo.rgb;
+#endif
+finalIrradiance*=vLightingIntensity.z;finalIrradiance*=aoOut.ambientOcclusionColor;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase;finalSpecular=max(finalSpecular,0.0);vec3 finalSpecularScaled=finalSpecular*vLightingIntensity.x*vLightingIntensity.w;
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+finalSpecularScaled*=coloredEnergyConservationFactor;
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+finalSpecularScaled*=sheenOut.sheenAlbedoScaling;
+#endif
+#endif
+#ifdef REFLECTION
+vec3 finalRadiance=reflectionOut.environmentRadiance.rgb;finalRadiance*=colorSpecularEnvironmentReflectance;vec3 finalRadianceScaled=finalRadiance*vLightingIntensity.z;
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+finalRadianceScaled*=coloredEnergyConservationFactor;
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+finalRadianceScaled*=sheenOut.sheenAlbedoScaling;
+#endif
+#endif
+#ifdef SHEEN
+vec3 finalSheen=sheenBase*sheenOut.sheenColor;finalSheen=max(finalSheen,0.0);vec3 finalSheenScaled=finalSheen*vLightingIntensity.x*vLightingIntensity.w;
+#if defined(CLEARCOAT) && defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+sheenOut.finalSheenRadianceScaled*=clearcoatOut.conservationFactor;
+#if defined(CLEARCOAT_TINT)
+sheenOut.finalSheenRadianceScaled*=clearcoatOut.absorption;
+#endif
+#endif
+#endif
+#ifdef CLEARCOAT
+vec3 finalClearCoat=clearCoatBase;finalClearCoat=max(finalClearCoat,0.0);vec3 finalClearCoatScaled=finalClearCoat*vLightingIntensity.x*vLightingIntensity.w;
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+finalClearCoatScaled*=clearcoatOut.energyConservationFactorClearCoat;
+#endif
+#ifdef SS_REFRACTION
+subSurfaceOut.finalRefraction*=clearcoatOut.conservationFactor;
+#ifdef CLEARCOAT_TINT
+subSurfaceOut.finalRefraction*=clearcoatOut.absorption;
+#endif
+#endif
+#endif
+#ifdef ALPHABLEND
+float luminanceOverAlpha=0.0;
+#if defined(REFLECTION) && defined(RADIANCEOVERALPHA)
+luminanceOverAlpha+=getLuminance(finalRadianceScaled);
+#if defined(CLEARCOAT)
+luminanceOverAlpha+=getLuminance(clearcoatOut.finalClearCoatRadianceScaled);
+#endif
+#endif
+#if defined(SPECULARTERM) && defined(SPECULAROVERALPHA)
+luminanceOverAlpha+=getLuminance(finalSpecularScaled);
+#endif
+#if defined(CLEARCOAT) && defined(CLEARCOATOVERALPHA)
+luminanceOverAlpha+=getLuminance(finalClearCoatScaled);
+#endif
+#if defined(RADIANCEOVERALPHA) || defined(SPECULAROVERALPHA) || defined(CLEARCOATOVERALPHA)
+alpha=saturate(alpha+luminanceOverAlpha*luminanceOverAlpha);
+#endif
+#endif
+`;
+e.IncludesShadersStore[F] || (e.IncludesShadersStore[F] = Re);
+const P = "pbrBlockFinalUnlitComponents", ue = `vec3 finalDiffuse=diffuseBase;finalDiffuse*=surfaceAlbedo;
+#if defined(SS_REFRACTION) && !defined(UNLIT)
+finalDiffuse*=subSurfaceOut.refractionOpacity;
+#endif
+#if defined(SS_TRANSLUCENCY) && !defined(UNLIT)
+finalDiffuse+=diffuseTransmissionBase;
+#endif
+finalDiffuse=max(finalDiffuse,0.0);finalDiffuse*=vLightingIntensity.x;vec3 finalAmbient=vAmbientColor;finalAmbient*=surfaceAlbedo.rgb;vec3 finalEmissive=vEmissiveColor;
+#ifdef EMISSIVE
+vec3 emissiveColorTex=texture2D(emissiveSampler,vEmissiveUV+uvOffset).rgb;
+#ifdef GAMMAEMISSIVE
+finalEmissive*=toLinearSpace(emissiveColorTex.rgb);
+#else
+finalEmissive*=emissiveColorTex.rgb;
+#endif
+finalEmissive*= vEmissiveInfos.y;
+#endif
+finalEmissive*=vLightingIntensity.y;
+#ifdef AMBIENT
+vec3 ambientOcclusionForDirectDiffuse=mix(vec3(1.),aoOut.ambientOcclusionColor,vAmbientInfos.w);
+#else
+vec3 ambientOcclusionForDirectDiffuse=aoOut.ambientOcclusionColor;
+#endif
+finalAmbient*=aoOut.ambientOcclusionColor;finalDiffuse*=ambientOcclusionForDirectDiffuse;
+`;
+e.IncludesShadersStore[P] || (e.IncludesShadersStore[P] = ue);
+const U = "pbrBlockFinalColorComposition", Ce = `vec4 finalColor=vec4(
+#ifndef UNLIT
+#ifdef REFLECTION
+finalIrradiance +
+#endif
+#ifdef SPECULARTERM
+finalSpecularScaled +
+#endif
+#ifdef SHEEN
+finalSheenScaled +
+#endif
+#ifdef CLEARCOAT
+finalClearCoatScaled +
+#endif
+#ifdef REFLECTION
+finalRadianceScaled +
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF)
+sheenOut.finalSheenRadianceScaled +
+#endif
+#ifdef CLEARCOAT
+clearcoatOut.finalClearCoatRadianceScaled +
+#endif
+#endif
+#ifdef SS_REFRACTION
+subSurfaceOut.finalRefraction +
+#endif
+#endif
+finalAmbient +
+finalDiffuse,
+alpha);
+#ifdef LIGHTMAP
+#ifndef LIGHTMAPEXCLUDED
+#ifdef USELIGHTMAPASSHADOWMAP
+finalColor.rgb*=lightmapColor.rgb;
+#else
+finalColor.rgb+=lightmapColor.rgb;
+#endif
+#endif
+#endif
+finalColor.rgb+=finalEmissive;
+#define CUSTOM_FRAGMENT_BEFORE_FOG
+finalColor=max(finalColor,0.0);
+`;
+e.IncludesShadersStore[U] || (e.IncludesShadersStore[U] = Ce);
+const b = "pbrBlockImageProcessing", Se = `#if defined(IMAGEPROCESSINGPOSTPROCESS) || defined(SS_SCATTERING)
+#if !defined(SKIPFINALCOLORCLAMP)
+finalColor.rgb=clamp(finalColor.rgb,0.,30.0);
+#endif
+#else
+finalColor=applyImageProcessing(finalColor);
+#endif
+finalColor.a*=visibility;
+#ifdef PREMULTIPLYALPHA
+finalColor.rgb*=finalColor.a;
+#endif
+`;
+e.IncludesShadersStore[b] || (e.IncludesShadersStore[b] = Se);
+const B = "pbrBlockPrePass", Ae = `float writeGeometryInfo=finalColor.a>ALPHATESTVALUE ? 1.0 : 0.0;
+#ifdef PREPASS_POSITION
+gl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+gl_FragData[PREPASS_LOCAL_POSITION_INDEX]=vec4(vPosition,writeGeometryInfo);
+#endif
+#if defined(PREPASS_VELOCITY)
+vec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;vec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;vec2 velocity=abs(a-b);velocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;gl_FragData[PREPASS_VELOCITY_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
+#elif defined(PREPASS_VELOCITY_LINEAR)
+vec2 velocity=vec2(0.5)*((vPreviousPosition.xy/vPreviousPosition.w)-(vCurrentPosition.xy/vCurrentPosition.w));gl_FragData[PREPASS_VELOCITY_LINEAR_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_ALBEDO
+gl_FragData[PREPASS_ALBEDO_INDEX]=vec4(surfaceAlbedo,writeGeometryInfo);
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+vec3 sqAlbedo=sqrt(surfaceAlbedo); 
+#endif
+#ifdef PREPASS_IRRADIANCE
+vec3 irradiance=finalDiffuse;
+#ifndef UNLIT
+#ifdef REFLECTION
+irradiance+=finalIrradiance;
+#endif
+#endif
+#ifdef SS_SCATTERING
+#ifdef PREPASS_COLOR
+gl_FragData[PREPASS_COLOR_INDEX]=vec4(finalColor.rgb-irradiance,finalColor.a); 
+#endif
+irradiance/=sqAlbedo;
+#else
+#ifdef PREPASS_COLOR
+gl_FragData[PREPASS_COLOR_INDEX]=finalColor; 
+#endif
+float scatteringDiffusionProfile=255.;
+#endif
+gl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(clamp(irradiance,vec3(0.),vec3(1.)),writeGeometryInfo*scatteringDiffusionProfile/255.); 
+#elif defined(PREPASS_COLOR)
+gl_FragData[PREPASS_COLOR_INDEX]=vec4(finalColor.rgb,finalColor.a);
+#endif
+#ifdef PREPASS_DEPTH
+gl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_SCREENSPACE_DEPTH
+gl_FragData[PREPASS_SCREENSPACE_DEPTH_INDEX]=vec4(gl_FragCoord.z,0.0,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+gl_FragData[PREPASS_NORMALIZED_VIEW_DEPTH_INDEX]=vec4(vNormViewDepth,0.0,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_NORMAL
+#ifdef PREPASS_NORMAL_WORLDSPACE
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalW,writeGeometryInfo);
+#else
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo);
+#endif
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+gl_FragData[PREPASS_WORLD_NORMAL_INDEX]=vec4(normalW*0.5+0.5,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+gl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqAlbedo,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_REFLECTIVITY
+#ifndef UNLIT
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(specularEnvironmentR0,microSurface)*writeGeometryInfo;
+#else
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4( 0.0,0.0,0.0,1.0 )*writeGeometryInfo;
+#endif
+#endif
+`;
+e.IncludesShadersStore[B] || (e.IncludesShadersStore[B] = Ae);
+const G = "pbrDebug", me = `#if DEBUGMODE>0
+if (vClipSpacePosition.x/vClipSpacePosition.w>=vDebugMode.x) {
+#if DEBUGMODE==1
+gl_FragColor.rgb=vPositionW.rgb;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==2 && defined(NORMAL)
+gl_FragColor.rgb=vNormalW.rgb;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==3 && defined(BUMP) || DEBUGMODE==3 && defined(PARALLAX) || DEBUGMODE==3 && defined(ANISOTROPIC)
+gl_FragColor.rgb=TBN[0];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==4 && defined(BUMP) || DEBUGMODE==4 && defined(PARALLAX) || DEBUGMODE==4 && defined(ANISOTROPIC)
+gl_FragColor.rgb=TBN[1];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==5
+gl_FragColor.rgb=normalW;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==6 && defined(MAINUV1)
+gl_FragColor.rgb=vec3(vMainUV1,0.0);
+#elif DEBUGMODE==7 && defined(MAINUV2)
+gl_FragColor.rgb=vec3(vMainUV2,0.0);
+#elif DEBUGMODE==8 && defined(CLEARCOAT) && defined(CLEARCOAT_BUMP)
+gl_FragColor.rgb=clearcoatOut.TBNClearCoat[0];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==9 && defined(CLEARCOAT) && defined(CLEARCOAT_BUMP)
+gl_FragColor.rgb=clearcoatOut.TBNClearCoat[1];
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==10 && defined(CLEARCOAT)
+gl_FragColor.rgb=clearcoatOut.clearCoatNormalW;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==11 && defined(ANISOTROPIC)
+gl_FragColor.rgb=anisotropicOut.anisotropicNormal;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==12 && defined(ANISOTROPIC)
+gl_FragColor.rgb=anisotropicOut.anisotropicTangent;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==13 && defined(ANISOTROPIC)
+gl_FragColor.rgb=anisotropicOut.anisotropicBitangent;
+#define DEBUGMODE_NORMALIZE
+#elif DEBUGMODE==20 && defined(ALBEDO)
+gl_FragColor.rgb=albedoTexture.rgb;
+#ifndef GAMMAALBEDO
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==21 && defined(AMBIENT)
+gl_FragColor.rgb=aoOut.ambientOcclusionColorMap.rgb;
+#elif DEBUGMODE==22 && defined(OPACITY)
+gl_FragColor.rgb=opacityMap.rgb;
+#elif DEBUGMODE==23 && defined(EMISSIVE)
+gl_FragColor.rgb=emissiveColorTex.rgb;
+#ifndef GAMMAEMISSIVE
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==24 && defined(LIGHTMAP)
+gl_FragColor.rgb=lightmapColor.rgb;
+#ifndef GAMMALIGHTMAP
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==25 && defined(REFLECTIVITY) && defined(METALLICWORKFLOW)
+gl_FragColor.rgb=reflectivityOut.surfaceMetallicColorMap.rgb;
+#elif DEBUGMODE==26 && defined(REFLECTIVITY) && !defined(METALLICWORKFLOW)
+gl_FragColor.rgb=reflectivityOut.surfaceReflectivityColorMap.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==27 && defined(CLEARCOAT) && defined(CLEARCOAT_TEXTURE)
+gl_FragColor.rgb=vec3(clearcoatOut.clearCoatMapData.rg,0.0);
+#elif DEBUGMODE==28 && defined(CLEARCOAT) && defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
+gl_FragColor.rgb=clearcoatOut.clearCoatTintMapData.rgb;
+#elif DEBUGMODE==29 && defined(SHEEN) && defined(SHEEN_TEXTURE)
+gl_FragColor.rgb=sheenOut.sheenMapData.rgb;
+#elif DEBUGMODE==30 && defined(ANISOTROPIC) && defined(ANISOTROPIC_TEXTURE)
+gl_FragColor.rgb=anisotropicOut.anisotropyMapData.rgb;
+#elif DEBUGMODE==31 && defined(SUBSURFACE) && defined(SS_THICKNESSANDMASK_TEXTURE)
+gl_FragColor.rgb=subSurfaceOut.thicknessMap.rgb;
+#elif DEBUGMODE==32 && defined(BUMP)
+gl_FragColor.rgb=texture2D(bumpSampler,vBumpUV).rgb;
+#elif DEBUGMODE==40 && defined(SS_REFRACTION)
+gl_FragColor.rgb=subSurfaceOut.environmentRefraction.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==41 && defined(REFLECTION)
+gl_FragColor.rgb=reflectionOut.environmentRadiance.rgb;
+#ifndef GAMMAREFLECTION
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==42 && defined(CLEARCOAT) && defined(REFLECTION)
+gl_FragColor.rgb=clearcoatOut.environmentClearCoatRadiance.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==50
+gl_FragColor.rgb=diffuseBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==51 && defined(SPECULARTERM)
+gl_FragColor.rgb=specularBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==52 && defined(CLEARCOAT)
+gl_FragColor.rgb=clearCoatBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==53 && defined(SHEEN)
+gl_FragColor.rgb=sheenBase.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==54 && defined(REFLECTION)
+gl_FragColor.rgb=reflectionOut.environmentIrradiance.rgb;
+#ifndef GAMMAREFLECTION
+#define DEBUGMODE_GAMMA
+#endif
+#elif DEBUGMODE==60
+gl_FragColor.rgb=surfaceAlbedo.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==61
+gl_FragColor.rgb=clearcoatOut.specularEnvironmentR0;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==62 && defined(METALLICWORKFLOW)
+gl_FragColor.rgb=vec3(reflectivityOut.metallic);
+#elif DEBUGMODE==71 && defined(METALLICWORKFLOW)
+gl_FragColor.rgb=reflectivityOut.metallicF0;
+#elif DEBUGMODE==63
+gl_FragColor.rgb=vec3(roughness);
+#elif DEBUGMODE==64
+gl_FragColor.rgb=vec3(alphaG);
+#elif DEBUGMODE==65
+gl_FragColor.rgb=vec3(NdotV);
+#elif DEBUGMODE==66 && defined(CLEARCOAT) && defined(CLEARCOAT_TINT)
+gl_FragColor.rgb=clearcoatOut.clearCoatColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==67 && defined(CLEARCOAT)
+gl_FragColor.rgb=vec3(clearcoatOut.clearCoatRoughness);
+#elif DEBUGMODE==68 && defined(CLEARCOAT)
+gl_FragColor.rgb=vec3(clearcoatOut.clearCoatNdotV);
+#elif DEBUGMODE==69 && defined(SUBSURFACE) && defined(SS_TRANSLUCENCY)
+gl_FragColor.rgb=subSurfaceOut.transmittance;
+#elif DEBUGMODE==70 && defined(SUBSURFACE) && defined(SS_REFRACTION)
+gl_FragColor.rgb=subSurfaceOut.refractionTransmittance;
+#elif DEBUGMODE==72
+gl_FragColor.rgb=vec3(microSurface);
+#elif DEBUGMODE==73
+gl_FragColor.rgb=vAlbedoColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==74 && !defined(METALLICWORKFLOW)
+gl_FragColor.rgb=vReflectivityColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==75
+gl_FragColor.rgb=vEmissiveColor.rgb;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==80 && defined(RADIANCEOCCLUSION)
+gl_FragColor.rgb=vec3(seo);
+#elif DEBUGMODE==81 && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+gl_FragColor.rgb=vec3(eho);
+#elif DEBUGMODE==82 && defined(MS_BRDF_ENERGY_CONSERVATION)
+gl_FragColor.rgb=vec3(energyConservationFactor);
+#elif DEBUGMODE==83 && defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+gl_FragColor.rgb=baseSpecularEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==84 && defined(CLEARCOAT) && defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+gl_FragColor.rgb=clearcoatOut.clearCoatEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==85 && defined(SHEEN) && defined(REFLECTION)
+gl_FragColor.rgb=sheenOut.sheenEnvironmentReflectance;
+#define DEBUGMODE_GAMMA
+#elif DEBUGMODE==86 && defined(ALPHABLEND)
+gl_FragColor.rgb=vec3(luminanceOverAlpha);
+#elif DEBUGMODE==87
+gl_FragColor.rgb=vec3(alpha);
+#elif DEBUGMODE==88 && defined(ALBEDO)
+gl_FragColor.rgb=vec3(albedoTexture.a);
+#elif DEBUGMODE==89
+gl_FragColor.rgb=aoOut.ambientOcclusionColor.rgb;
+#else
+float stripeWidth=30.;float stripePos=floor(gl_FragCoord.x/stripeWidth);float whichColor=mod(stripePos,2.);vec3 color1=vec3(.6,.2,.2);vec3 color2=vec3(.3,.1,.1);gl_FragColor.rgb=mix(color1,color2,whichColor);
+#endif
+gl_FragColor.rgb*=vDebugMode.y;
+#ifdef DEBUGMODE_NORMALIZE
+gl_FragColor.rgb=normalize(gl_FragColor.rgb)*0.5+0.5;
+#endif
+#ifdef DEBUGMODE_GAMMA
+gl_FragColor.rgb=toGammaSpace(gl_FragColor.rgb);
+#endif
+gl_FragColor.a=1.0;
+#ifdef PREPASS
+gl_FragData[0]=toLinearSpace(gl_FragColor); 
+gl_FragData[1]=vec4(0.,0.,0.,0.); 
+#endif
+#ifdef DEBUGMODE_FORCERETURN
+return;
+#endif
+}
+#endif
+`;
+e.IncludesShadersStore[G] || (e.IncludesShadersStore[G] = me);
+const i = "pbrPixelShader", y = `#define PBR_FRAGMENT_SHADER
+#define CUSTOM_FRAGMENT_EXTENSION
+#if defined(BUMP) || !defined(NORMAL) || defined(FORCENORMALFORWARD) || defined(SPECULARAA) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#extension GL_OES_standard_derivatives : enable
+#endif
+#ifdef LODBASEDMICROSFURACE
+#extension GL_EXT_shader_texture_lod : enable
+#endif
+#define CUSTOM_FRAGMENT_BEGIN
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+#include<prePassDeclaration>[SCENE_MRT_COUNT]
+precision highp float;
+#include<oitDeclaration>
+#ifndef FROMLINEARSPACE
+#define FROMLINEARSPACE
+#endif
+#include<__decl__pbrFragment>
+#include<pbrFragmentExtraDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<pbrFragmentSamplersDeclaration>
+#include<imageProcessingDeclaration>
+#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#include<helperFunctions>
+#include<subSurfaceScatteringFunctions>
+#include<importanceSampling>
+#include<pbrHelperFunctions>
+#include<imageProcessingFunctions>
+#include<shadowsFragmentFunctions>
+#include<harmonicsFunctions>
+#include<pbrDirectLightingSetupFunctions>
+#include<pbrDirectLightingFalloffFunctions>
+#include<pbrBRDFFunctions>
+#include<hdrFilteringFunctions>
+#include<pbrDirectLightingFunctions>
+#include<pbrIBLFunctions>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#ifdef REFLECTION
+#include<reflectionFunction>
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+#include<pbrBlockAlbedoOpacity>
+#include<pbrBlockReflectivity>
+#include<pbrBlockAmbientOcclusion>
+#include<pbrBlockAlphaFresnel>
+#include<pbrBlockAnisotropic>
+#include<pbrBlockReflection>
+#include<pbrBlockSheen>
+#include<pbrBlockClearcoat>
+#include<pbrBlockIridescence>
+#include<pbrBlockSubSurface>
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+#include<pbrBlockNormalGeometric>
+#include<bumpFragment>
+#include<pbrBlockNormalFinal>
+albedoOpacityOutParams albedoOpacityOut;
+#ifdef ALBEDO
+vec4 albedoTexture=texture2D(albedoSampler,vAlbedoUV+uvOffset);
+#endif
+#ifdef BASE_WEIGHT
+vec4 baseWeightTexture=texture2D(baseWeightSampler,vBaseWeightUV+uvOffset);
+#endif
+#ifdef OPACITY
+vec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);
+#endif
+#ifdef DECAL
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#endif
+albedoOpacityOut=albedoOpacityBlock(
+vAlbedoColor
+#ifdef ALBEDO
+,albedoTexture
+,vAlbedoInfos
+#endif
+,baseWeight
+#ifdef BASE_WEIGHT
+,baseWeightTexture
+,vBaseWeightInfos
+#endif
+#ifdef OPACITY
+,opacityMap
+,vOpacityInfos
+#endif
+#ifdef DETAIL
+,detailColor
+,vDetailInfos
+#endif
+#ifdef DECAL
+,decalColor
+,vDecalInfos
+#endif
+);vec3 surfaceAlbedo=albedoOpacityOut.surfaceAlbedo;float alpha=albedoOpacityOut.alpha;
+#define CUSTOM_FRAGMENT_UPDATE_ALPHA
+#include<depthPrePass>
+#define CUSTOM_FRAGMENT_BEFORE_LIGHTS
+ambientOcclusionOutParams aoOut;
+#ifdef AMBIENT
+vec3 ambientOcclusionColorMap=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb;
+#endif
+aoOut=ambientOcclusionBlock(
+#ifdef AMBIENT
+ambientOcclusionColorMap,
+vAmbientInfos
+#endif
+);
+#include<pbrBlockLightmapInit>
+#ifdef UNLIT
+vec3 diffuseBase=vec3(1.,1.,1.);
+#else 
+vec3 baseColor=surfaceAlbedo;reflectivityOutParams reflectivityOut;
+#if defined(REFLECTIVITY)
+vec4 surfaceMetallicOrReflectivityColorMap=texture2D(reflectivitySampler,vReflectivityUV+uvOffset);vec4 baseReflectivity=surfaceMetallicOrReflectivityColorMap;
+#ifndef METALLICWORKFLOW
+#ifdef REFLECTIVITY_GAMMA
+surfaceMetallicOrReflectivityColorMap=toLinearSpace(surfaceMetallicOrReflectivityColorMap);
+#endif
+surfaceMetallicOrReflectivityColorMap.rgb*=vReflectivityInfos.y;
+#endif
+#endif
+#if defined(MICROSURFACEMAP)
+vec4 microSurfaceTexel=texture2D(microSurfaceSampler,vMicroSurfaceSamplerUV+uvOffset)*vMicroSurfaceSamplerInfos.y;
+#endif
+#ifdef METALLICWORKFLOW
+vec4 metallicReflectanceFactors=vMetallicReflectanceFactors;
+#ifdef REFLECTANCE
+vec4 reflectanceFactorsMap=texture2D(reflectanceSampler,vReflectanceUV+uvOffset);
+#ifdef REFLECTANCE_GAMMA
+reflectanceFactorsMap=toLinearSpace(reflectanceFactorsMap);
+#endif
+metallicReflectanceFactors.rgb*=reflectanceFactorsMap.rgb;
+#endif
+#ifdef METALLIC_REFLECTANCE
+vec4 metallicReflectanceFactorsMap=texture2D(metallicReflectanceSampler,vMetallicReflectanceUV+uvOffset);
+#ifdef METALLIC_REFLECTANCE_GAMMA
+metallicReflectanceFactorsMap=toLinearSpace(metallicReflectanceFactorsMap);
+#endif
+#ifndef METALLIC_REFLECTANCE_USE_ALPHA_ONLY
+metallicReflectanceFactors.rgb*=metallicReflectanceFactorsMap.rgb;
+#endif
+metallicReflectanceFactors.a*=metallicReflectanceFactorsMap.a;
+#endif
+#endif
+#ifdef BASE_DIFFUSE_ROUGHNESS
+float baseDiffuseRoughnessTexture=texture2D(baseDiffuseRoughnessSampler,vBaseDiffuseRoughnessUV+uvOffset).r;
+#endif
+reflectivityOut=reflectivityBlock(
+vReflectivityColor
+#ifdef METALLICWORKFLOW
+,surfaceAlbedo
+,metallicReflectanceFactors
+#endif
+,baseDiffuseRoughness
+#ifdef BASE_DIFFUSE_ROUGHNESS
+,baseDiffuseRoughnessTexture
+,vBaseDiffuseRoughnessInfos
+#endif
+#ifdef REFLECTIVITY
+,vReflectivityInfos
+,surfaceMetallicOrReflectivityColorMap
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+,aoOut.ambientOcclusionColor
+#endif
+#ifdef MICROSURFACEMAP
+,microSurfaceTexel
+#endif
+#ifdef DETAIL
+,detailColor
+,vDetailInfos
+#endif
+);float microSurface=reflectivityOut.microSurface;float roughness=reflectivityOut.roughness;float diffuseRoughness=reflectivityOut.diffuseRoughness;
+#ifdef METALLICWORKFLOW
+surfaceAlbedo=reflectivityOut.surfaceAlbedo;
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+aoOut.ambientOcclusionColor=reflectivityOut.ambientOcclusionColor;
+#endif
+#ifdef ALPHAFRESNEL
+#if defined(ALPHATEST) || defined(ALPHABLEND)
+alphaFresnelOutParams alphaFresnelOut;alphaFresnelOut=alphaFresnelBlock(
+normalW,
+viewDirectionW,
+alpha,
+microSurface
+);alpha=alphaFresnelOut.alpha;
+#endif
+#endif
+#include<pbrBlockGeometryInfo>
+#ifdef ANISOTROPIC
+anisotropicOutParams anisotropicOut;
+#ifdef ANISOTROPIC_TEXTURE
+vec3 anisotropyMapData=texture2D(anisotropySampler,vAnisotropyUV+uvOffset).rgb*vAnisotropyInfos.y;
+#endif
+anisotropicOut=anisotropicBlock(
+vAnisotropy,
+roughness,
+#ifdef ANISOTROPIC_TEXTURE
+anisotropyMapData,
+#endif
+TBN,
+normalW,
+viewDirectionW
+);
+#endif
+#ifdef REFLECTION
+reflectionOutParams reflectionOut;
+#ifndef USE_CUSTOM_REFLECTION
+reflectionOut=reflectionBlock(
+vPositionW
+,normalW
+,alphaG
+,vReflectionMicrosurfaceInfos
+,vReflectionInfos
+,vReflectionColor
+#ifdef ANISOTROPIC
+,anisotropicOut
+#endif
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+,NdotVUnclamped
+#endif
+#ifdef LINEARSPECULARREFLECTION
+,roughness
+#endif
+,reflectionSampler
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,vReflectionDominantDirection
+#endif
+#endif
+#ifndef LODBASEDMICROSFURACE
+,reflectionSamplerLow
+,reflectionSamplerHigh
+#endif
+#ifdef REALTIME_FILTERING
+,vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+#endif
+,viewDirectionW
+,diffuseRoughness
+,baseColor
+);
+#else
+#define CUSTOM_REFLECTION
+#endif
+#endif
+#include<pbrBlockReflectance0>
+#ifdef SHEEN
+sheenOutParams sheenOut;
+#ifdef SHEEN_TEXTURE
+vec4 sheenMapData=texture2D(sheenSampler,vSheenUV+uvOffset);
+#endif
+#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+vec4 sheenMapRoughnessData=texture2D(sheenRoughnessSampler,vSheenRoughnessUV+uvOffset)*vSheenInfos.w;
+#endif
+sheenOut=sheenBlock(
+vSheenColor
+#ifdef SHEEN_ROUGHNESS
+,vSheenRoughness
+#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+,sheenMapRoughnessData
+#endif
+#endif
+,roughness
+#ifdef SHEEN_TEXTURE
+,sheenMapData
+,vSheenInfos.y
+#endif
+,reflectanceF0
+#ifdef SHEEN_LINKWITHALBEDO
+,baseColor
+,surfaceAlbedo
+#endif
+#ifdef ENVIRONMENTBRDF
+,NdotV
+,environmentBrdf
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+,AARoughnessFactors
+,vReflectionMicrosurfaceInfos
+,vReflectionInfos
+,vReflectionColor
+,vLightingIntensity
+,reflectionSampler
+,reflectionOut.reflectionCoords
+,NdotVUnclamped
+#ifndef LODBASEDMICROSFURACE
+,reflectionSamplerLow
+,reflectionSamplerHigh
+#endif
+#ifdef REALTIME_FILTERING
+,vReflectionFilteringInfo
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+,seo
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+,eho
+#endif
+#endif
+);
+#ifdef SHEEN_LINKWITHALBEDO
+surfaceAlbedo=sheenOut.surfaceAlbedo;
+#endif
+#endif
+#ifdef CLEARCOAT
+#ifdef CLEARCOAT_TEXTURE
+vec2 clearCoatMapData=texture2D(clearCoatSampler,vClearCoatUV+uvOffset).rg*vClearCoatInfos.y;
+#endif
+#endif
+#ifdef IRIDESCENCE
+iridescenceOutParams iridescenceOut;
+#ifdef IRIDESCENCE_TEXTURE
+vec2 iridescenceMapData=texture2D(iridescenceSampler,vIridescenceUV+uvOffset).rg*vIridescenceInfos.y;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+vec2 iridescenceThicknessMapData=texture2D(iridescenceThicknessSampler,vIridescenceThicknessUV+uvOffset).rg*vIridescenceInfos.w;
+#endif
+iridescenceOut=iridescenceBlock(
+vIridescenceParams
+,NdotV
+,specularEnvironmentR0
+#ifdef IRIDESCENCE_TEXTURE
+,iridescenceMapData
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+,iridescenceThicknessMapData
+#endif
+#ifdef CLEARCOAT
+,NdotVUnclamped
+,vClearCoatParams
+#ifdef CLEARCOAT_TEXTURE
+,clearCoatMapData
+#endif
+#endif
+);float iridescenceIntensity=iridescenceOut.iridescenceIntensity;specularEnvironmentR0=iridescenceOut.specularEnvironmentR0;
+#endif
+clearcoatOutParams clearcoatOut;
+#ifdef CLEARCOAT
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+vec4 clearCoatMapRoughnessData=texture2D(clearCoatRoughnessSampler,vClearCoatRoughnessUV+uvOffset)*vClearCoatInfos.w;
+#endif
+#if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
+vec4 clearCoatTintMapData=texture2D(clearCoatTintSampler,vClearCoatTintUV+uvOffset);
+#endif
+#ifdef CLEARCOAT_BUMP
+vec4 clearCoatBumpMapData=texture2D(clearCoatBumpSampler,vClearCoatBumpUV+uvOffset);
+#endif
+clearcoatOut=clearcoatBlock(
+vPositionW
+,geometricNormalW
+,viewDirectionW
+,vClearCoatParams
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+,clearCoatMapRoughnessData
+#endif
+,specularEnvironmentR0
+#ifdef CLEARCOAT_TEXTURE
+,clearCoatMapData
+#endif
+#ifdef CLEARCOAT_TINT
+,vClearCoatTintParams
+,clearCoatColorAtDistance
+,vClearCoatRefractionParams
+#ifdef CLEARCOAT_TINT_TEXTURE
+,clearCoatTintMapData
+#endif
+#endif
+#ifdef CLEARCOAT_BUMP
+,vClearCoatBumpInfos
+,clearCoatBumpMapData
+,vClearCoatBumpUV
+#if defined(TANGENT) && defined(NORMAL)
+,vTBN
+#else
+,vClearCoatTangentSpaceParams
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+,normalMatrix
+#endif
+#endif
+#if defined(FORCENORMALFORWARD) && defined(NORMAL)
+,faceNormal
+#endif
+#ifdef REFLECTION
+,vReflectionMicrosurfaceInfos
+,vReflectionInfos
+,vReflectionColor
+,vLightingIntensity
+,reflectionSampler
+#ifndef LODBASEDMICROSFURACE
+,reflectionSamplerLow
+,reflectionSamplerHigh
+#endif
+#ifdef REALTIME_FILTERING
+,vReflectionFilteringInfo
+#endif
+#endif
+#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)
+,(gl_FrontFacing ? 1. : -1.)
+#endif
+);
+#else
+clearcoatOut.specularEnvironmentR0=specularEnvironmentR0;
+#endif
+#include<pbrBlockReflectance>
+subSurfaceOutParams subSurfaceOut;
+#ifdef SUBSURFACE
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+vec4 thicknessMap=texture2D(thicknessSampler,vThicknessUV+uvOffset);
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+vec4 refractionIntensityMap=texture2D(refractionIntensitySampler,vRefractionIntensityUV+uvOffset);
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+vec4 translucencyIntensityMap=texture2D(translucencyIntensitySampler,vTranslucencyIntensityUV+uvOffset);
+#endif
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE
+vec4 translucencyColorMap=texture2D(translucencyColorSampler,vTranslucencyColorUV+uvOffset);
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE_GAMMA
+translucencyColorMap=toLinearSpace(translucencyColorMap);
+#endif
+#endif
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+vec3 vSpecularEnvironmentReflectance=vec3(max(colorSpecularEnvironmentReflectance.r,max(colorSpecularEnvironmentReflectance.g,colorSpecularEnvironmentReflectance.b)));
+#endif
+subSurfaceOut=subSurfaceBlock(
+vSubSurfaceIntensity
+,vThicknessParam
+,vTintColor
+,normalW
+#ifdef LEGACY_SPECULAR_ENERGY_CONSERVATION
+,vSpecularEnvironmentReflectance
+#else
+,baseSpecularEnvironmentReflectance
+#endif
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+,thicknessMap
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+,refractionIntensityMap
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+,translucencyIntensityMap
+#endif
+#ifdef REFLECTION
+#ifdef SS_TRANSLUCENCY
+,reflectionMatrix
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+,reflectionOut.irradianceVector
+#endif
+#if defined(REALTIME_FILTERING)
+,reflectionSampler
+,vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+#endif
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+#endif
+#endif
+#endif
+#if defined(SS_REFRACTION) || defined(SS_TRANSLUCENCY)
+,surfaceAlbedo
+#endif
+#ifdef SS_REFRACTION
+,vPositionW
+,viewDirectionW
+,view
+,vRefractionInfos
+,refractionMatrix
+,vRefractionMicrosurfaceInfos
+,vLightingIntensity
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+,alpha
+#endif
+#ifdef SS_LODINREFRACTIONALPHA
+,NdotVUnclamped
+#endif
+#ifdef SS_LINEARSPECULARREFRACTION
+,roughness
+#endif
+,alphaG
+,refractionSampler
+#ifndef LODBASEDMICROSFURACE
+,refractionSamplerLow
+,refractionSamplerHigh
+#endif
+#ifdef ANISOTROPIC
+,anisotropicOut
+#endif
+#ifdef REALTIME_FILTERING
+,vRefractionFilteringInfo
+#endif
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+,vRefractionPosition
+,vRefractionSize
+#endif
+#ifdef SS_DISPERSION
+,dispersion
+#endif
+#endif
+#ifdef SS_TRANSLUCENCY
+,vDiffusionDistance
+,vTranslucencyColor
+#ifdef SS_TRANSLUCENCYCOLOR_TEXTURE
+,translucencyColorMap
+#endif
+#endif
+);
+#ifdef SS_REFRACTION
+surfaceAlbedo=subSurfaceOut.surfaceAlbedo;
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+alpha=subSurfaceOut.alpha;
+#endif
+#endif
+#else
+subSurfaceOut.specularEnvironmentReflectance=colorSpecularEnvironmentReflectance;
+#endif
+#include<pbrBlockDirectLighting>
+#include<lightFragment>[0..maxSimultaneousLights]
+#include<pbrBlockFinalLitComponents>
+#endif 
+#include<pbrBlockFinalUnlitComponents>
+#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION
+#include<pbrBlockFinalColorComposition>
+#include<logDepthFragment>
+#include<fogFragment>(color,finalColor)
+#include<pbrBlockImageProcessing>
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef PREPASS
+#include<pbrBlockPrePass>
+#endif
+#if !defined(PREPASS) || defined(WEBGL2)
+gl_FragColor=finalColor;
+#endif
+#include<oitFragment>
+#if ORDER_INDEPENDENT_TRANSPARENCY
+if (fragDepth==nearestDepth) {frontColor.rgb+=finalColor.rgb*finalColor.a*alphaMultiplier;frontColor.a=1.0-alphaMultiplier*(1.0-finalColor.a);} else {backColor+=finalColor;}
+#endif
+#include<pbrDebug>
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+e.ShadersStore[i] || (e.ShadersStore[i] = y);
+const Le = { name: i, shader: y };
+export {
+  Le as pbrPixelShader
+};
+//# sourceMappingURL=pbr.fragment-siOdCYqI.js.map