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

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

@@ -0,0 +1,278 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "lightFragment", o = `#ifdef LIGHT{X}
+#if defined(SHADOWONLY) || defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X}) && defined(LIGHTMAPNOSPECULAR{X})
+#else
+#ifdef PBR
+#ifdef SPOTLIGHT{X}
+preInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);
+#elif defined(POINTLIGHT{X})
+preInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);
+#elif defined(HEMILIGHT{X})
+preInfo=computeHemisphericPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);
+#elif defined(DIRLIGHT{X})
+preInfo=computeDirectionalPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);
+#endif
+preInfo.NdotV=NdotV;
+#ifdef SPOTLIGHT{X}
+#ifdef LIGHT_FALLOFF_GLTF{X}
+preInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);
+preInfo.attenuation*=computeDirectionalLightFalloff_GLTF(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);
+#elif defined(LIGHT_FALLOFF_PHYSICAL{X})
+preInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
+preInfo.attenuation*=computeDirectionalLightFalloff_Physical(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w);
+#elif defined(LIGHT_FALLOFF_STANDARD{X})
+preInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);
+preInfo.attenuation*=computeDirectionalLightFalloff_Standard(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w);
+#else
+preInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);
+preInfo.attenuation*=computeDirectionalLightFalloff(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);
+#endif
+#elif defined(POINTLIGHT{X})
+#ifdef LIGHT_FALLOFF_GLTF{X}
+preInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);
+#elif defined(LIGHT_FALLOFF_PHYSICAL{X})
+preInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
+#elif defined(LIGHT_FALLOFF_STANDARD{X})
+preInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);
+#else
+preInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);
+#endif
+#else
+preInfo.attenuation=1.0;
+#endif
+#ifdef HEMILIGHT{X}
+preInfo.roughness=roughness;
+#else
+preInfo.roughness=adjustRoughnessFromLightProperties(roughness,light{X}.vLightSpecular.a,preInfo.lightDistance);
+#endif
+#ifdef IRIDESCENCE
+preInfo.iridescenceIntensity=iridescenceIntensity;
+#endif
+#ifdef HEMILIGHT{X}
+info.diffuse=computeHemisphericDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb,light{X}.vLightGround);
+#elif defined(SS_TRANSLUCENCY)
+info.diffuse=computeDiffuseAndTransmittedLighting(preInfo,light{X}.vLightDiffuse.rgb,subSurfaceOut.transmittance);
+#else
+info.diffuse=computeDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb);
+#endif
+#ifdef SPECULARTERM
+#ifdef ANISOTROPIC
+info.specular=computeAnisotropicSpecularLighting(preInfo,viewDirectionW,normalW,anisotropicOut.anisotropicTangent,anisotropicOut.anisotropicBitangent,anisotropicOut.anisotropy,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);
+#else
+info.specular=computeSpecularLighting(preInfo,normalW,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);
+#endif
+#endif
+#ifdef SHEEN
+#ifdef SHEEN_LINKWITHALBEDO
+preInfo.roughness=sheenOut.sheenIntensity;
+#else
+#ifdef HEMILIGHT{X}
+preInfo.roughness=sheenOut.sheenRoughness;
+#else
+preInfo.roughness=adjustRoughnessFromLightProperties(sheenOut.sheenRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);
+#endif
+#endif
+info.sheen=computeSheenLighting(preInfo,normalW,sheenOut.sheenColor,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);
+#endif
+#ifdef CLEARCOAT
+#ifdef HEMILIGHT{X}
+preInfo.roughness=clearcoatOut.clearCoatRoughness;
+#else
+preInfo.roughness=adjustRoughnessFromLightProperties(clearcoatOut.clearCoatRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);
+#endif
+info.clearCoat=computeClearCoatLighting(preInfo,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatAARoughnessFactors.x,clearcoatOut.clearCoatIntensity,light{X}.vLightDiffuse.rgb);
+#ifdef CLEARCOAT_TINT
+absorption=computeClearCoatLightingAbsorption(clearcoatOut.clearCoatNdotVRefract,preInfo.L,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatColor,clearcoatOut.clearCoatThickness,clearcoatOut.clearCoatIntensity);
+info.diffuse*=absorption;
+#ifdef SPECULARTERM
+info.specular*=absorption;
+#endif
+#endif
+info.diffuse*=info.clearCoat.w;
+#ifdef SPECULARTERM
+info.specular*=info.clearCoat.w;
+#endif
+#ifdef SHEEN
+info.sheen*=info.clearCoat.w;
+#endif
+#endif
+#else
+#ifdef SPOTLIGHT{X}
+info=computeSpotLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDirection,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);
+#elif defined(HEMILIGHT{X})
+info=computeHemisphericLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightGround,glossiness);
+#elif defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
+info=computeLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);
+#endif
+#endif
+#ifdef PROJECTEDLIGHTTEXTURE{X}
+info.diffuse*=computeProjectionTextureDiffuseLighting(projectionLightSampler{X},textureProjectionMatrix{X});
+#endif
+#endif
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+for (int i=0; i<SHADOWCSMNUM_CASCADES{X}; i++) 
+{
+#ifdef SHADOWCSM_RIGHTHANDED{X}
+diff{X}=viewFrustumZ{X}[i]+vPositionFromCamera{X}.z;
+#else
+diff{X}=viewFrustumZ{X}[i]-vPositionFromCamera{X}.z;
+#endif
+if (diff{X}>=0.) {
+index{X}=i;
+break;
+}
+}
+#ifdef SHADOWCSMUSESHADOWMAXZ{X}
+if (index{X}>=0)
+#endif
+{
+#if defined(SHADOWPCF{X})
+#if defined(SHADOWLOWQUALITY{X})
+shadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#elif defined(SHADOWMEDIUMQUALITY{X})
+shadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#else
+shadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWPCSS{X})
+#if defined(SHADOWLOWQUALITY{X})
+shadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#elif defined(SHADOWMEDIUMQUALITY{X})
+shadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#else
+shadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#endif
+#else
+shadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#ifdef SHADOWCSMDEBUG{X}
+shadowDebug{X}=vec3(shadow)*vCascadeColorsMultiplier{X}[index{X}];
+#endif
+#ifndef SHADOWCSMNOBLEND{X}
+float frustumLength=frustumLengths{X}[index{X}];
+float diffRatio=clamp(diff{X}/frustumLength,0.,1.)*cascadeBlendFactor{X};
+if (index{X}<(SHADOWCSMNUM_CASCADES{X}-1) && diffRatio<1.)
+{
+index{X}+=1;
+float nextShadow=0.;
+#if defined(SHADOWPCF{X})
+#if defined(SHADOWLOWQUALITY{X})
+nextShadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#elif defined(SHADOWMEDIUMQUALITY{X})
+nextShadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#else
+nextShadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWPCSS{X})
+#if defined(SHADOWLOWQUALITY{X})
+nextShadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#elif defined(SHADOWMEDIUMQUALITY{X})
+nextShadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#else
+nextShadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});
+#endif
+#else
+nextShadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+shadow=mix(nextShadow,shadow,diffRatio);
+#ifdef SHADOWCSMDEBUG{X}
+shadowDebug{X}=mix(vec3(nextShadow)*vCascadeColorsMultiplier{X}[index{X}],shadowDebug{X},diffRatio);
+#endif
+}
+#endif
+}
+#elif defined(SHADOWCLOSEESM{X})
+#if defined(SHADOWCUBE{X})
+shadow=computeShadowWithCloseESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);
+#else
+shadow=computeShadowWithCloseESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWESM{X})
+#if defined(SHADOWCUBE{X})
+shadow=computeShadowWithESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);
+#else
+shadow=computeShadowWithESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWPOISSON{X})
+#if defined(SHADOWCUBE{X})
+shadow=computeShadowWithPoissonSamplingCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.depthValues);
+#else
+shadow=computeShadowWithPoissonSampling(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWPCF{X})
+#if defined(SHADOWLOWQUALITY{X})
+shadow=computeShadowWithPCF1(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#elif defined(SHADOWMEDIUMQUALITY{X})
+shadow=computeShadowWithPCF3(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#else
+shadow=computeShadowWithPCF5(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#elif defined(SHADOWPCSS{X})
+#if defined(SHADOWLOWQUALITY{X})
+shadow=computeShadowWithPCSS16(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#elif defined(SHADOWMEDIUMQUALITY{X})
+shadow=computeShadowWithPCSS32(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#else
+shadow=computeShadowWithPCSS64(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#else
+#if defined(SHADOWCUBE{X})
+shadow=computeShadowCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.depthValues);
+#else
+shadow=computeShadow(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);
+#endif
+#endif
+#ifdef SHADOWONLY
+#ifndef SHADOWINUSE
+#define SHADOWINUSE
+#endif
+globalShadow+=shadow;
+shadowLightCount+=1.0;
+#endif
+#else
+shadow=1.;
+#endif
+#ifndef SHADOWONLY
+#ifdef CUSTOMUSERLIGHTING
+diffuseBase+=computeCustomDiffuseLighting(info,diffuseBase,shadow);
+#ifdef SPECULARTERM
+specularBase+=computeCustomSpecularLighting(info,specularBase,shadow);
+#endif
+#elif defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X})
+diffuseBase+=lightmapColor.rgb*shadow;
+#ifdef SPECULARTERM
+#ifndef LIGHTMAPNOSPECULAR{X}
+specularBase+=info.specular*shadow*lightmapColor.rgb;
+#endif
+#endif
+#ifdef CLEARCOAT
+#ifndef LIGHTMAPNOSPECULAR{X}
+clearCoatBase+=info.clearCoat.rgb*shadow*lightmapColor.rgb;
+#endif
+#endif
+#ifdef SHEEN
+#ifndef LIGHTMAPNOSPECULAR{X}
+sheenBase+=info.sheen.rgb*shadow;
+#endif
+#endif
+#else
+#ifdef SHADOWCSMDEBUG{X}
+diffuseBase+=info.diffuse*shadowDebug{X};
+#else 
+diffuseBase+=info.diffuse*shadow;
+#endif
+#ifdef SPECULARTERM
+specularBase+=info.specular*shadow;
+#endif
+#ifdef CLEARCOAT
+clearCoatBase+=info.clearCoat.rgb*shadow;
+#endif
+#ifdef SHEEN
+sheenBase+=info.sheen.rgb*shadow;
+#endif
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = o;

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

@@ -0,0 +1,82 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "lightFragmentDeclaration", r = `#ifdef LIGHT{X}
+uniform vec4 vLightData{X};
+uniform vec4 vLightDiffuse{X};
+#ifdef SPECULARTERM
+uniform vec4 vLightSpecular{X};
+#else
+vec4 vLightSpecular{X}=vec4(0.);
+#endif
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform mat4 lightMatrix{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float viewFrustumZ{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float frustumLengths{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float cascadeBlendFactor{X};
+varying vec4 vPositionFromLight{X}[SHADOWCSMNUM_CASCADES{X}];
+varying float vDepthMetric{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromCamera{X};
+#if defined(SHADOWPCSS{X})
+uniform highp sampler2DArrayShadow shadowSampler{X};
+uniform highp sampler2DArray depthSampler{X};
+uniform vec2 lightSizeUVCorrection{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float depthCorrection{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float penumbraDarkness{X};
+#elif defined(SHADOWPCF{X})
+uniform highp sampler2DArrayShadow shadowSampler{X};
+#else
+uniform highp sampler2DArray shadowSampler{X};
+#endif
+#ifdef SHADOWCSMDEBUG{X}
+const vec3 vCascadeColorsMultiplier{X}[8]=vec3[8]
+(
+vec3 ( 1.5,0.0,0.0 ),
+vec3 ( 0.0,1.5,0.0 ),
+vec3 ( 0.0,0.0,5.5 ),
+vec3 ( 1.5,0.0,5.5 ),
+vec3 ( 1.5,1.5,0.0 ),
+vec3 ( 1.0,1.0,1.0 ),
+vec3 ( 0.0,1.0,5.5 ),
+vec3 ( 0.5,3.5,0.75 )
+);
+vec3 shadowDebug{X};
+#endif
+#ifdef SHADOWCSMUSESHADOWMAXZ{X}
+int index{X}=-1;
+#else
+int index{X}=SHADOWCSMNUM_CASCADES{X}-1;
+#endif
+float diff{X}=0.;
+#elif defined(SHADOWCUBE{X})
+uniform samplerCube shadowSampler{X};
+#else
+varying vec4 vPositionFromLight{X};
+varying float vDepthMetric{X};
+#if defined(SHADOWPCSS{X})
+uniform highp sampler2DShadow shadowSampler{X};
+uniform highp sampler2D depthSampler{X};
+#elif defined(SHADOWPCF{X})
+uniform highp sampler2DShadow shadowSampler{X};
+#else
+uniform sampler2D shadowSampler{X};
+#endif
+uniform mat4 lightMatrix{X};
+#endif
+uniform vec4 shadowsInfo{X};
+uniform vec2 depthValues{X};
+#endif
+#ifdef SPOTLIGHT{X}
+uniform vec4 vLightDirection{X};
+uniform vec4 vLightFalloff{X};
+#elif defined(POINTLIGHT{X})
+uniform vec4 vLightFalloff{X};
+#elif defined(HEMILIGHT{X})
+uniform vec3 vLightGround{X};
+#endif
+#ifdef PROJECTEDLIGHTTEXTURE{X}
+uniform mat4 textureProjectionMatrix{X};
+uniform sampler2D projectionLightSampler{X};
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = r;

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

@@ -0,0 +1,81 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "lightUboDeclaration", r = `#ifdef LIGHT{X}
+uniform Light{X}
+{
+vec4 vLightData;
+vec4 vLightDiffuse;
+vec4 vLightSpecular;
+#ifdef SPOTLIGHT{X}
+vec4 vLightDirection;
+vec4 vLightFalloff;
+#elif defined(POINTLIGHT{X})
+vec4 vLightFalloff;
+#elif defined(HEMILIGHT{X})
+vec3 vLightGround;
+#endif
+vec4 shadowsInfo;
+vec2 depthValues;
+} light{X};
+#ifdef PROJECTEDLIGHTTEXTURE{X}
+uniform mat4 textureProjectionMatrix{X};
+uniform sampler2D projectionLightSampler{X};
+#endif
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform mat4 lightMatrix{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float viewFrustumZ{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float frustumLengths{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float cascadeBlendFactor{X};
+varying vec4 vPositionFromLight{X}[SHADOWCSMNUM_CASCADES{X}];
+varying float vDepthMetric{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromCamera{X};
+#if defined(SHADOWPCSS{X})
+uniform highp sampler2DArrayShadow shadowSampler{X};
+uniform highp sampler2DArray depthSampler{X};
+uniform vec2 lightSizeUVCorrection{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float depthCorrection{X}[SHADOWCSMNUM_CASCADES{X}];
+uniform float penumbraDarkness{X};
+#elif defined(SHADOWPCF{X})
+uniform highp sampler2DArrayShadow shadowSampler{X};
+#else
+uniform highp sampler2DArray shadowSampler{X};
+#endif
+#ifdef SHADOWCSMDEBUG{X}
+const vec3 vCascadeColorsMultiplier{X}[8]=vec3[8]
+(
+vec3 ( 1.5,0.0,0.0 ),
+vec3 ( 0.0,1.5,0.0 ),
+vec3 ( 0.0,0.0,5.5 ),
+vec3 ( 1.5,0.0,5.5 ),
+vec3 ( 1.5,1.5,0.0 ),
+vec3 ( 1.0,1.0,1.0 ),
+vec3 ( 0.0,1.0,5.5 ),
+vec3 ( 0.5,3.5,0.75 )
+);
+vec3 shadowDebug{X};
+#endif
+#ifdef SHADOWCSMUSESHADOWMAXZ{X}
+int index{X}=-1;
+#else
+int index{X}=SHADOWCSMNUM_CASCADES{X}-1;
+#endif
+float diff{X}=0.;
+#elif defined(SHADOWCUBE{X})
+uniform samplerCube shadowSampler{X}; 
+#else
+varying vec4 vPositionFromLight{X};
+varying float vDepthMetric{X};
+#if defined(SHADOWPCSS{X})
+uniform highp sampler2DShadow shadowSampler{X};
+uniform highp sampler2D depthSampler{X};
+#elif defined(SHADOWPCF{X})
+uniform highp sampler2DShadow shadowSampler{X};
+#else
+uniform sampler2D shadowSampler{X};
+#endif
+uniform mat4 lightMatrix{X};
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = r;

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

@@ -0,0 +1,35 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+const e = "lightVxFragmentDeclaration", f = `#ifdef LIGHT{X}
+uniform vec4 vLightData{X};
+uniform vec4 vLightDiffuse{X};
+#ifdef SPECULARTERM
+uniform vec4 vLightSpecular{X};
+#else
+vec4 vLightSpecular{X}=vec4(0.);
+#endif
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform mat4 lightMatrix{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromLight{X}[SHADOWCSMNUM_CASCADES{X}];
+varying float vDepthMetric{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromCamera{X};
+#elif defined(SHADOWCUBE{X})
+#else
+varying vec4 vPositionFromLight{X};
+varying float vDepthMetric{X};
+uniform mat4 lightMatrix{X};
+#endif
+uniform vec4 shadowsInfo{X};
+uniform vec2 depthValues{X};
+#endif
+#ifdef SPOTLIGHT{X}
+uniform vec4 vLightDirection{X};
+uniform vec4 vLightFalloff{X};
+#elif defined(POINTLIGHT{X})
+uniform vec4 vLightFalloff{X};
+#elif defined(HEMILIGHT{X})
+uniform vec3 vLightGround{X};
+#endif
+#endif
+`;
+i.IncludesShadersStore[e] = f;

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

@@ -0,0 +1,34 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+const e = "lightVxUboDeclaration", t = `#ifdef LIGHT{X}
+uniform Light{X}
+{
+vec4 vLightData;
+vec4 vLightDiffuse;
+vec4 vLightSpecular;
+#ifdef SPOTLIGHT{X}
+vec4 vLightDirection;
+vec4 vLightFalloff;
+#elif defined(POINTLIGHT{X})
+vec4 vLightFalloff;
+#elif defined(HEMILIGHT{X})
+vec3 vLightGround;
+#endif
+vec4 shadowsInfo;
+vec2 depthValues;
+} light{X};
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform mat4 lightMatrix{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromLight{X}[SHADOWCSMNUM_CASCADES{X}];
+varying float vDepthMetric{X}[SHADOWCSMNUM_CASCADES{X}];
+varying vec4 vPositionFromCamera{X};
+#elif defined(SHADOWCUBE{X})
+#else
+varying vec4 vPositionFromLight{X};
+varying float vDepthMetric{X};
+uniform mat4 lightMatrix{X};
+#endif
+#endif
+#endif
+`;
+i.IncludesShadersStore[e] = t;

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

@@ -0,0 +1,93 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "lightsFragmentFunctions", o = `struct lightingInfo
+{
+vec3 diffuse;
+#ifdef SPECULARTERM
+vec3 specular;
+#endif
+#ifdef NDOTL
+float ndl;
+#endif
+};
+lightingInfo computeLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec3 diffuseColor,vec3 specularColor,float range,float glossiness) {
+lightingInfo result;
+vec3 lightVectorW;
+float attenuation=1.0;
+if (lightData.w==0.)
+{
+vec3 direction=lightData.xyz-vPositionW;
+attenuation=max(0.,1.0-length(direction)/range);
+lightVectorW=normalize(direction);
+}
+else
+{
+lightVectorW=normalize(-lightData.xyz);
+}
+float ndl=max(0.,dot(vNormal,lightVectorW));
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=ndl*diffuseColor*attenuation;
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightVectorW);
+float specComp=max(0.,dot(vNormal,angleW));
+specComp=pow(specComp,max(1.,glossiness));
+result.specular=specComp*specularColor*attenuation;
+#endif
+return result;
+}
+lightingInfo computeSpotLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec4 lightDirection,vec3 diffuseColor,vec3 specularColor,float range,float glossiness) {
+lightingInfo result;
+vec3 direction=lightData.xyz-vPositionW;
+vec3 lightVectorW=normalize(direction);
+float attenuation=max(0.,1.0-length(direction)/range);
+float cosAngle=max(0.,dot(lightDirection.xyz,-lightVectorW));
+if (cosAngle>=lightDirection.w)
+{
+cosAngle=max(0.,pow(cosAngle,lightData.w));
+attenuation*=cosAngle;
+float ndl=max(0.,dot(vNormal,lightVectorW));
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=ndl*diffuseColor*attenuation;
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightVectorW);
+float specComp=max(0.,dot(vNormal,angleW));
+specComp=pow(specComp,max(1.,glossiness));
+result.specular=specComp*specularColor*attenuation;
+#endif
+return result;
+}
+result.diffuse=vec3(0.);
+#ifdef SPECULARTERM
+result.specular=vec3(0.);
+#endif
+#ifdef NDOTL
+result.ndl=0.;
+#endif
+return result;
+}
+lightingInfo computeHemisphericLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec3 diffuseColor,vec3 specularColor,vec3 groundColor,float glossiness) {
+lightingInfo result;
+float ndl=dot(vNormal,lightData.xyz)*0.5+0.5;
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=mix(groundColor,diffuseColor,ndl);
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightData.xyz);
+float specComp=max(0.,dot(vNormal,angleW));
+specComp=pow(specComp,max(1.,glossiness));
+result.specular=specComp*specularColor;
+#endif
+return result;
+}
+#define inline
+vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler,mat4 textureProjectionMatrix){
+vec4 strq=textureProjectionMatrix*vec4(vPositionW,1.0);
+strq/=strq.w;
+vec3 textureColor=texture2D(projectionLightSampler,strq.xy).rgb;
+return textureColor;
+}`;
+e.IncludesShadersStore[t] = o;

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

@@ -0,0 +1,7 @@
+import { ShaderStore as t } from "../../Engines/shaderStore.esm.js";
+const e = "logDepthDeclaration", o = `#ifdef LOGARITHMICDEPTH
+uniform float logarithmicDepthConstant;
+varying float vFragmentDepth;
+#endif
+`;
+t.IncludesShadersStore[e] = o;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "logDepthFragment", r = `#ifdef LOGARITHMICDEPTH
+gl_FragDepthEXT=log2(vFragmentDepth)*logarithmicDepthConstant*0.5;
+#endif
+`;
+e.IncludesShadersStore[t] = r;

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

@@ -0,0 +1,7 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "logDepthVertex", o = `#ifdef LOGARITHMICDEPTH
+vFragmentDepth=1.0+gl_Position.w;
+gl_Position.z=log2(max(0.000001,vFragmentDepth))*logarithmicDepthConstant;
+#endif
+`;
+e.IncludesShadersStore[t] = o;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "mainUVVaryingDeclaration", n = `#ifdef MAINUV{X}
+varying vec2 vMainUV{X};
+#endif
+`;
+e.IncludesShadersStore[a] = n;

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

@@ -0,0 +1,15 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const i = "meshUboDeclaration", e = `#ifdef WEBGL2
+uniform mat4 world;
+uniform float visibility;
+#else
+layout(std140,column_major) uniform;
+uniform Mesh
+{
+mat4 world;
+float visibility;
+};
+#endif
+#define WORLD_UBO
+`;
+o.IncludesShadersStore[i] = e;

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

@@ -0,0 +1,32 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "morphTargetsVertex", t = `#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE 
+vertexID=float(gl_VertexID)*morphTargetTextureInfo.x;
+positionUpdated+=(readVector3FromRawSampler({X},vertexID)-position)*morphTargetInfluences[{X}];
+vertexID+=1.0;
+#ifdef MORPHTARGETS_NORMAL
+normalUpdated+=(readVector3FromRawSampler({X},vertexID) -normal)*morphTargetInfluences[{X}];
+vertexID+=1.0;
+#endif
+#ifdef MORPHTARGETS_UV
+uvUpdated+=(readVector3FromRawSampler({X},vertexID).xy-uv)*morphTargetInfluences[{X}];
+vertexID+=1.0;
+#endif
+#ifdef MORPHTARGETS_TANGENT
+tangentUpdated.xyz+=(readVector3FromRawSampler({X},vertexID) -tangent.xyz)*morphTargetInfluences[{X}];
+#endif
+#else
+positionUpdated+=(position{X}-position)*morphTargetInfluences[{X}];
+#ifdef MORPHTARGETS_NORMAL
+normalUpdated+=(normal{X}-normal)*morphTargetInfluences[{X}];
+#endif
+#ifdef MORPHTARGETS_TANGENT
+tangentUpdated.xyz+=(tangent{X}-tangent.xyz)*morphTargetInfluences[{X}];
+#endif
+#ifdef MORPHTARGETS_UV
+uvUpdated+=(uv_{X}-uv)*morphTargetInfluences[{X}];
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[r] = t;