@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockClearcoat.esm.js

@@ -0,0 +1,276 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "pbrBlockClearcoat", o = `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
+void 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(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef RADIANCEOCCLUSION
+in float ambientMonochrome,
+#endif
+#endif
+#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)
+in float frontFacingMultiplier,
+#endif
+out 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)
+#ifdef CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL
+clearCoatRoughness*=clearCoatMapData.y;
+#else
+clearCoatRoughness*=clearCoatMapRoughnessData.y;
+#endif
+#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
+}
+#endif
+`;
+e.IncludesShadersStore[a] = o;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockDirectLighting.esm.js

@@ -0,0 +1,19 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const f = "pbrBlockDirectLighting", i = `vec3 diffuseBase=vec3(0.,0.,0.);
+#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
+preLightingInfo preInfo;
+lightingInfo info;
+float shadow=1.; 
+#if defined(CLEARCOAT) && defined(CLEARCOAT_TINT)
+vec3 absorption=vec3(0.);
+#endif
+`;
+e.IncludesShadersStore[f] = i;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockFinalColorComposition.esm.js

@@ -0,0 +1,45 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const f = "pbrBlockFinalColorComposition", i = `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[f] = i;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockFinalLitComponents.esm.js

@@ -0,0 +1,100 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const n = "pbrBlockFinalLitComponents", a = `#if defined(ENVIRONMENTBRDF)
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+vec3 energyConservationFactor=getEnergyConservationFactor(clearcoatOut.specularEnvironmentR0,environmentBrdf);
+#endif
+#endif
+#ifndef METALLICWORKFLOW
+#ifdef SPECULAR_GLOSSINESS_ENERGY_CONSERVATION
+surfaceAlbedo.rgb=(1.-reflectance)*surfaceAlbedo.rgb;
+#endif
+#endif
+#if defined(SHEEN) && defined(SHEEN_ALBEDOSCALING) && defined(ENVIRONMENTBRDF)
+surfaceAlbedo.rgb=sheenOut.sheenAlbedoScaling*surfaceAlbedo.rgb;
+#endif
+#ifdef REFLECTION
+vec3 finalIrradiance=reflectionOut.environmentIrradiance;
+#if defined(CLEARCOAT)
+finalIrradiance*=clearcoatOut.conservationFactor;
+#if defined(CLEARCOAT_TINT)
+finalIrradiance*=clearcoatOut.absorption;
+#endif
+#endif
+#if defined(SS_REFRACTION)
+finalIrradiance*=subSurfaceOut.refractionFactorForIrradiance;
+#endif
+#if defined(SS_TRANSLUCENCY)
+finalIrradiance*=(1.0-subSurfaceOut.translucencyIntensity);
+finalIrradiance+=subSurfaceOut.refractionIrradiance;
+#endif
+finalIrradiance*=surfaceAlbedo.rgb;
+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*=energyConservationFactor;
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+finalSpecularScaled*=sheenOut.sheenAlbedoScaling;
+#endif
+#endif
+#ifdef REFLECTION
+vec3 finalRadiance=reflectionOut.environmentRadiance.rgb;
+finalRadiance*=subSurfaceOut.specularEnvironmentReflectance;
+vec3 finalRadianceScaled=finalRadiance*vLightingIntensity.z;
+#if defined(ENVIRONMENTBRDF) && defined(MS_BRDF_ENERGY_CONSERVATION)
+finalRadianceScaled*=energyConservationFactor;
+#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[n] = a;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockFinalUnlitComponents.esm.js

@@ -0,0 +1,27 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+const e = "pbrBlockFinalUnlitComponents", s = `vec3 finalDiffuse=diffuseBase;
+finalDiffuse*=surfaceAlbedo.rgb;
+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;
+`;
+i.IncludesShadersStore[e] = s;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockGeometryInfo.esm.js

@@ -0,0 +1,30 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "pbrBlockGeometryInfo", n = `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[o] = n;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockImageProcessing.esm.js

@@ -0,0 +1,14 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockImageProcessing", o = `#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[i] = o;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockIridescence.esm.js

@@ -0,0 +1,63 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockIridescence", n = `struct iridescenceOutParams
+{
+float iridescenceIntensity;
+float iridescenceIOR;
+float iridescenceThickness;
+vec3 specularEnvironmentR0;
+};
+#ifdef IRIDESCENCE
+#define pbr_inline
+#define inline
+void 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,
+#ifdef CLEARCOAT_TEXTURE
+in vec2 clearCoatMapData,
+#endif
+#endif
+out 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;
+#ifdef IRIDESCENCE_USE_THICKNESS_FROM_MAINTEXTURE
+iridescenceThicknessWeight=iridescenceMapData.g;
+#endif
+#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;
+}
+#endif
+`;
+e.IncludesShadersStore[i] = n;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockLightmapInit.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const r = "pbrBlockLightmapInit", e = `#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
+`;
+o.IncludesShadersStore[r] = e;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockNormalFinal.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const e = "pbrBlockNormalFinal", n = `#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)
+normalW=gl_FrontFacing ? normalW : -normalW;
+#endif
+`;
+o.IncludesShadersStore[e] = n;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockNormalGeometric.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "pbrBlockNormalGeometric", i = `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[o] = i;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockReflectance.esm.js

@@ -0,0 +1,24 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const n = "pbrBlockReflectance", c = `#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+vec3 specularEnvironmentReflectance=getReflectanceFromBRDFLookup(clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,environmentBrdf);
+#ifdef RADIANCEOCCLUSION
+specularEnvironmentReflectance*=seo;
+#endif
+#ifdef HORIZONOCCLUSION
+#ifdef BUMP
+#ifdef REFLECTIONMAP_3D
+specularEnvironmentReflectance*=eho;
+#endif
+#endif
+#endif
+#else
+vec3 specularEnvironmentReflectance=getReflectanceFromAnalyticalBRDFLookup_Jones(NdotV,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,sqrt(microSurface));
+#endif
+#ifdef CLEARCOAT
+specularEnvironmentReflectance*=clearcoatOut.conservationFactor;
+#if defined(CLEARCOAT_TINT)
+specularEnvironmentReflectance*=clearcoatOut.absorption;
+#endif
+#endif
+`;
+e.IncludesShadersStore[n] = c;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBlockReflectance0.esm.js

@@ -0,0 +1,14 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const c = "pbrBlockReflectance0", t = `float reflectance=max(max(reflectivityOut.surfaceReflectivityColor.r,reflectivityOut.surfaceReflectivityColor.g),reflectivityOut.surfaceReflectivityColor.b);
+vec3 specularEnvironmentR0=reflectivityOut.surfaceReflectivityColor.rgb;
+#ifdef METALLICWORKFLOW
+vec3 specularEnvironmentR90=vec3(metallicReflectanceFactors.a);
+#else 
+vec3 specularEnvironmentR90=vec3(1.0,1.0,1.0);
+#endif
+#ifdef ALPHAFRESNEL
+float reflectance90=fresnelGrazingReflectance(reflectance);
+specularEnvironmentR90=specularEnvironmentR90*reflectance90;
+#endif
+`;
+e.IncludesShadersStore[c] = t;