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

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

@@ -0,0 +1,19 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const e = "boundingBoxRendererUboDeclaration", r = `#ifdef WEBGL2
+uniform vec4 color;
+uniform mat4 world;
+uniform mat4 viewProjection;
+#ifdef MULTIVIEW
+uniform mat4 viewProjectionR;
+#endif
+#else
+layout(std140,column_major) uniform;
+uniform BoundingBoxRenderer {
+vec4 color;
+mat4 world;
+mat4 viewProjection;
+mat4 viewProjectionR;
+};
+#endif
+`;
+o.IncludesShadersStore[e] = r;

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

@@ -0,0 +1,8 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "boundingBoxRendererVertexDeclaration", r = `uniform mat4 world;
+uniform mat4 viewProjection;
+#ifdef MULTIVIEW
+uniform mat4 viewProjectionR;
+#endif
+`;
+e.IncludesShadersStore[o] = r;

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

@@ -0,0 +1,67 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "bumpFragment", l = `vec2 uvOffset=vec2(0.0,0.0);
+#if defined(BUMP) || defined(PARALLAX) || defined(DETAIL)
+#ifdef NORMALXYSCALE
+float normalScale=1.0;
+#elif defined(BUMP)
+float normalScale=vBumpInfos.y;
+#else
+float normalScale=1.0;
+#endif
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+#elif defined(BUMP)
+vec2 TBNUV=gl_FrontFacing ? vBumpUV : -vBumpUV;
+mat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vTangentSpaceParams);
+#else
+vec2 TBNUV=gl_FrontFacing ? vDetailUV : -vDetailUV;
+mat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vec2(1.,1.));
+#endif
+#elif defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+#else
+vec2 TBNUV=gl_FrontFacing ? vMainUV1 : -vMainUV1;
+mat3 TBN=cotangent_frame(normalW,vPositionW,TBNUV,vec2(1.,1.));
+#endif
+#endif
+#ifdef PARALLAX
+mat3 invTBN=transposeMat3(TBN);
+#ifdef PARALLAXOCCLUSION
+uvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,vBumpUV,vBumpInfos.z);
+#else
+uvOffset=parallaxOffset(invTBN*viewDirectionW,vBumpInfos.z);
+#endif
+#endif
+#ifdef DETAIL
+vec4 detailColor=texture2D(detailSampler,vDetailUV+uvOffset);
+vec2 detailNormalRG=detailColor.wy*2.0-1.0;
+float detailNormalB=sqrt(1.-saturate(dot(detailNormalRG,detailNormalRG)));
+vec3 detailNormal=vec3(detailNormalRG,detailNormalB);
+#endif
+#ifdef BUMP
+#ifdef OBJECTSPACE_NORMALMAP
+#define CUSTOM_FRAGMENT_BUMP_FRAGMENT
+normalW=normalize(texture2D(bumpSampler,vBumpUV).xyz *2.0-1.0);
+normalW=normalize(mat3(normalMatrix)*normalW);
+#elif !defined(DETAIL)
+normalW=perturbNormal(TBN,texture2D(bumpSampler,vBumpUV+uvOffset).xyz,vBumpInfos.y);
+#else
+vec3 bumpNormal=texture2D(bumpSampler,vBumpUV+uvOffset).xyz*2.0-1.0;
+#if DETAIL_NORMALBLENDMETHOD==0 
+detailNormal.xy*=vDetailInfos.z;
+vec3 blendedNormal=normalize(vec3(bumpNormal.xy+detailNormal.xy,bumpNormal.z*detailNormal.z));
+#elif DETAIL_NORMALBLENDMETHOD==1 
+detailNormal.xy*=vDetailInfos.z;
+bumpNormal+=vec3(0.0,0.0,1.0);
+detailNormal*=vec3(-1.0,-1.0,1.0);
+vec3 blendedNormal=bumpNormal*dot(bumpNormal,detailNormal)/bumpNormal.z-detailNormal;
+#endif
+normalW=perturbNormalBase(TBN,blendedNormal,vBumpInfos.y);
+#endif
+#elif defined(DETAIL)
+detailNormal.xy*=vDetailInfos.z;
+normalW=perturbNormalBase(TBN,detailNormal,vDetailInfos.z);
+#endif
+`;
+e.IncludesShadersStore[a] = l;

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

@@ -0,0 +1,58 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./samplerFragmentDeclaration.esm.js";
+const a = "bumpFragmentFunctions", t = `#if defined(BUMP)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)
+#endif
+#if defined(DETAIL)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)
+#endif
+#if defined(BUMP) && defined(PARALLAX)
+const float minSamples=4.;
+const float maxSamples=15.;
+const int iMaxSamples=15;
+vec2 parallaxOcclusion(vec3 vViewDirCoT,vec3 vNormalCoT,vec2 texCoord,float parallaxScale) {
+float parallaxLimit=length(vViewDirCoT.xy)/vViewDirCoT.z;
+parallaxLimit*=parallaxScale;
+vec2 vOffsetDir=normalize(vViewDirCoT.xy);
+vec2 vMaxOffset=vOffsetDir*parallaxLimit;
+float numSamples=maxSamples+(dot(vViewDirCoT,vNormalCoT)*(minSamples-maxSamples));
+float stepSize=1.0/numSamples;
+float currRayHeight=1.0;
+vec2 vCurrOffset=vec2(0,0);
+vec2 vLastOffset=vec2(0,0);
+float lastSampledHeight=1.0;
+float currSampledHeight=1.0;
+bool keepWorking=true;
+for (int i=0; i<iMaxSamples; i++)
+{
+currSampledHeight=texture2D(bumpSampler,texCoord+vCurrOffset).w;
+if (!keepWorking)
+{
+}
+else if (currSampledHeight>currRayHeight)
+{
+float delta1=currSampledHeight-currRayHeight;
+float delta2=(currRayHeight+stepSize)-lastSampledHeight;
+float ratio=delta1/(delta1+delta2);
+vCurrOffset=(ratio)* vLastOffset+(1.0-ratio)*vCurrOffset;
+keepWorking=false;
+}
+else
+{
+currRayHeight-=stepSize;
+vLastOffset=vCurrOffset;
+vCurrOffset+=stepSize*vMaxOffset;
+lastSampledHeight=currSampledHeight;
+}
+}
+return vCurrOffset;
+}
+vec2 parallaxOffset(vec3 viewDir,float heightScale)
+{
+float height=texture2D(bumpSampler,vBumpUV).w;
+vec2 texCoordOffset=heightScale*viewDir.xy*height;
+return -texCoordOffset;
+}
+#endif
+`;
+e.IncludesShadersStore[a] = t;

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

@@ -0,0 +1,93 @@
+import { ShaderStore as a } from "../../Engines/shaderStore.esm.js";
+const e = "bumpFragmentMainFunctions", t = `#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)
+#if defined(TANGENT) && defined(NORMAL) 
+varying mat3 vTBN;
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+uniform mat4 normalMatrix;
+#if defined(WEBGL2) || defined(WEBGPU)
+mat4 toNormalMatrix(mat4 wMatrix)
+{
+mat4 ret=inverse(wMatrix);
+ret=transpose(ret);
+ret[0][3]=0.;
+ret[1][3]=0.;
+ret[2][3]=0.;
+ret[3]=vec4(0.,0.,0.,1.);
+return ret;
+}
+#else
+mat4 toNormalMatrix(mat4 m)
+{
+float
+a00=m[0][0],a01=m[0][1],a02=m[0][2],a03=m[0][3],
+a10=m[1][0],a11=m[1][1],a12=m[1][2],a13=m[1][3],
+a20=m[2][0],a21=m[2][1],a22=m[2][2],a23=m[2][3],
+a30=m[3][0],a31=m[3][1],a32=m[3][2],a33=m[3][3],
+b00=a00*a11-a01*a10,
+b01=a00*a12-a02*a10,
+b02=a00*a13-a03*a10,
+b03=a01*a12-a02*a11,
+b04=a01*a13-a03*a11,
+b05=a02*a13-a03*a12,
+b06=a20*a31-a21*a30,
+b07=a20*a32-a22*a30,
+b08=a20*a33-a23*a30,
+b09=a21*a32-a22*a31,
+b10=a21*a33-a23*a31,
+b11=a22*a33-a23*a32,
+det=b00*b11-b01*b10+b02*b09+b03*b08-b04*b07+b05*b06;
+mat4 mi=mat4(
+a11*b11-a12*b10+a13*b09,
+a02*b10-a01*b11-a03*b09,
+a31*b05-a32*b04+a33*b03,
+a22*b04-a21*b05-a23*b03,
+a12*b08-a10*b11-a13*b07,
+a00*b11-a02*b08+a03*b07,
+a32*b02-a30*b05-a33*b01,
+a20*b05-a22*b02+a23*b01,
+a10*b10-a11*b08+a13*b06,
+a01*b08-a00*b10-a03*b06,
+a30*b04-a31*b02+a33*b00,
+a21*b02-a20*b04-a23*b00,
+a11*b07-a10*b09-a12*b06,
+a00*b09-a01*b07+a02*b06,
+a31*b01-a30*b03-a32*b00,
+a20*b03-a21*b01+a22*b00)/det;
+return mat4(mi[0][0],mi[1][0],mi[2][0],mi[3][0],
+mi[0][1],mi[1][1],mi[2][1],mi[3][1],
+mi[0][2],mi[1][2],mi[2][2],mi[3][2],
+mi[0][3],mi[1][3],mi[2][3],mi[3][3]);
+}
+#endif
+#endif
+vec3 perturbNormalBase(mat3 cotangentFrame,vec3 normal,float scale)
+{
+#ifdef NORMALXYSCALE
+normal=normalize(normal*vec3(scale,scale,1.0));
+#endif
+return normalize(cotangentFrame*normal);
+}
+vec3 perturbNormal(mat3 cotangentFrame,vec3 textureSample,float scale)
+{
+return perturbNormalBase(cotangentFrame,textureSample*2.0-1.0,scale);
+}
+mat3 cotangent_frame(vec3 normal,vec3 p,vec2 uv,vec2 tangentSpaceParams)
+{
+vec3 dp1=dFdx(p);
+vec3 dp2=dFdy(p);
+vec2 duv1=dFdx(uv);
+vec2 duv2=dFdy(uv);
+vec3 dp2perp=cross(dp2,normal);
+vec3 dp1perp=cross(normal,dp1);
+vec3 tangent=dp2perp*duv1.x+dp1perp*duv2.x;
+vec3 bitangent=dp2perp*duv1.y+dp1perp*duv2.y;
+tangent*=tangentSpaceParams.x;
+bitangent*=tangentSpaceParams.y;
+float det=max(dot(tangent,tangent),dot(bitangent,bitangent));
+float invmax=det==0.0 ? 0.0 : inversesqrt(det);
+return mat3(tangent*invmax,bitangent*invmax,normal);
+}
+#endif
+`;
+a.IncludesShadersStore[e] = t;

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

@@ -0,0 +1,11 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const n = "bumpVertex", t = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+vec3 tbnNormal=normalize(normalUpdated);
+vec3 tbnTangent=normalize(tangentUpdated.xyz);
+vec3 tbnBitangent=cross(tbnNormal,tbnTangent)*tangentUpdated.w;
+vTBN=mat3(finalWorld)*mat3(tbnTangent,tbnBitangent,tbnNormal);
+#endif
+#endif
+`;
+e.IncludesShadersStore[n] = t;

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

@@ -0,0 +1,8 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const d = "bumpVertexDeclaration", n = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL) 
+varying mat3 vTBN;
+#endif
+#endif
+`;
+e.IncludesShadersStore[d] = n;

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

@@ -0,0 +1,42 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "clipPlaneFragment", d = `#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)
+if (false) {}
+#endif
+#ifdef CLIPPLANE
+else if (fClipDistance>0.0)
+{
+discard;
+}
+#endif
+#ifdef CLIPPLANE2
+else if (fClipDistance2>0.0)
+{
+discard;
+}
+#endif
+#ifdef CLIPPLANE3
+else if (fClipDistance3>0.0)
+{
+discard;
+}
+#endif
+#ifdef CLIPPLANE4
+else if (fClipDistance4>0.0)
+{
+discard;
+}
+#endif
+#ifdef CLIPPLANE5
+else if (fClipDistance5>0.0)
+{
+discard;
+}
+#endif
+#ifdef CLIPPLANE6
+else if (fClipDistance6>0.0)
+{
+discard;
+}
+#endif
+`;
+e.IncludesShadersStore[i] = d;

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

@@ -0,0 +1,21 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+const f = "clipPlaneFragmentDeclaration", e = `#ifdef CLIPPLANE
+varying float fClipDistance;
+#endif
+#ifdef CLIPPLANE2
+varying float fClipDistance2;
+#endif
+#ifdef CLIPPLANE3
+varying float fClipDistance3;
+#endif
+#ifdef CLIPPLANE4
+varying float fClipDistance4;
+#endif
+#ifdef CLIPPLANE5
+varying float fClipDistance5;
+#endif
+#ifdef CLIPPLANE6
+varying float fClipDistance6;
+#endif
+`;
+i.IncludesShadersStore[f] = e;

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

@@ -0,0 +1,21 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "clipPlaneVertex", d = `#ifdef CLIPPLANE
+fClipDistance=dot(worldPos,vClipPlane);
+#endif
+#ifdef CLIPPLANE2
+fClipDistance2=dot(worldPos,vClipPlane2);
+#endif
+#ifdef CLIPPLANE3
+fClipDistance3=dot(worldPos,vClipPlane3);
+#endif
+#ifdef CLIPPLANE4
+fClipDistance4=dot(worldPos,vClipPlane4);
+#endif
+#ifdef CLIPPLANE5
+fClipDistance5=dot(worldPos,vClipPlane5);
+#endif
+#ifdef CLIPPLANE6
+fClipDistance6=dot(worldPos,vClipPlane6);
+#endif
+`;
+e.IncludesShadersStore[i] = d;

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

@@ -0,0 +1,27 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+const e = "clipPlaneVertexDeclaration", f = `#ifdef CLIPPLANE
+uniform vec4 vClipPlane;
+varying float fClipDistance;
+#endif
+#ifdef CLIPPLANE2
+uniform vec4 vClipPlane2;
+varying float fClipDistance2;
+#endif
+#ifdef CLIPPLANE3
+uniform vec4 vClipPlane3;
+varying float fClipDistance3;
+#endif
+#ifdef CLIPPLANE4
+uniform vec4 vClipPlane4;
+varying float fClipDistance4;
+#endif
+#ifdef CLIPPLANE5
+uniform vec4 vClipPlane5;
+varying float fClipDistance5;
+#endif
+#ifdef CLIPPLANE6
+uniform vec4 vClipPlane6;
+varying float fClipDistance6;
+#endif
+`;
+i.IncludesShadersStore[e] = f;

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

@@ -0,0 +1,12 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "decalFragment", o = `#ifdef DECAL
+#ifdef GAMMADECAL
+decalColor.rgb=toLinearSpace(decalColor.rgb);
+#endif
+#ifdef DECAL_SMOOTHALPHA
+decalColor.a*=decalColor.a;
+#endif
+surfaceAlbedo.rgb=mix(surfaceAlbedo.rgb,decalColor.rgb,decalColor.a);
+#endif
+`;
+e.IncludesShadersStore[r] = o;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "decalFragmentDeclaration", a = `#ifdef DECAL
+uniform vec4 vDecalInfos;
+#endif
+`;
+e.IncludesShadersStore[r] = a;

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

@@ -0,0 +1,7 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "decalVertexDeclaration", a = `#ifdef DECAL
+uniform vec4 vDecalInfos;
+uniform mat4 decalMatrix;
+#endif
+`;
+e.IncludesShadersStore[r] = a;

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

@@ -0,0 +1,86 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./decalFragmentDeclaration.esm.js";
+const f = "defaultFragmentDeclaration", i = `uniform vec4 vEyePosition;
+uniform vec4 vDiffuseColor;
+#ifdef SPECULARTERM
+uniform vec4 vSpecularColor;
+#endif
+uniform vec3 vEmissiveColor;
+uniform vec3 vAmbientColor;
+uniform float visibility;
+#ifdef DIFFUSE
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef AMBIENT
+uniform vec2 vAmbientInfos;
+#endif
+#ifdef OPACITY 
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;
+uniform vec2 vTangentSpaceParams;
+#endif
+#ifdef ALPHATEST
+uniform float alphaCutOff;
+#endif
+#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(REFRACTION) || defined(PREPASS)
+uniform mat4 view;
+#endif
+#ifdef REFRACTION
+uniform vec4 vRefractionInfos;
+#ifndef REFRACTIONMAP_3D
+uniform mat4 refractionMatrix;
+#endif
+#ifdef REFRACTIONFRESNEL
+uniform vec4 refractionLeftColor;
+uniform vec4 refractionRightColor;
+#endif
+#if defined(USE_LOCAL_REFRACTIONMAP_CUBIC) && defined(REFRACTIONMAP_3D)
+uniform vec3 vRefractionPosition;
+uniform vec3 vRefractionSize; 
+#endif
+#endif
+#if defined(SPECULAR) && defined(SPECULARTERM)
+uniform vec2 vSpecularInfos;
+#endif
+#ifdef DIFFUSEFRESNEL
+uniform vec4 diffuseLeftColor;
+uniform vec4 diffuseRightColor;
+#endif
+#ifdef OPACITYFRESNEL
+uniform vec4 opacityParts;
+#endif
+#ifdef EMISSIVEFRESNEL
+uniform vec4 emissiveLeftColor;
+uniform vec4 emissiveRightColor;
+#endif
+#ifdef REFLECTION
+uniform vec2 vReflectionInfos;
+#if defined(REFLECTIONMAP_PLANAR) || defined(REFLECTIONMAP_CUBIC) || defined(REFLECTIONMAP_PROJECTION) || defined(REFLECTIONMAP_EQUIRECTANGULAR) || defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_SKYBOX)
+uniform mat4 reflectionMatrix;
+#endif
+#ifndef REFLECTIONMAP_SKYBOX
+#if defined(USE_LOCAL_REFLECTIONMAP_CUBIC) && defined(REFLECTIONMAP_CUBIC)
+uniform vec3 vReflectionPosition;
+uniform vec3 vReflectionSize; 
+#endif
+#endif
+#ifdef REFLECTIONFRESNEL
+uniform vec4 reflectionLeftColor;
+uniform vec4 reflectionRightColor;
+#endif
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+#endif
+#include<decalFragmentDeclaration>
+#define ADDITIONAL_FRAGMENT_DECLARATION
+`;
+e.IncludesShadersStore[f] = i;

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

@@ -0,0 +1,50 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./sceneUboDeclaration.esm.js";
+import "./meshUboDeclaration.esm.js";
+const o = "defaultUboDeclaration", i = `layout(std140,column_major) uniform;
+uniform Material
+{
+vec4 diffuseLeftColor;
+vec4 diffuseRightColor;
+vec4 opacityParts;
+vec4 reflectionLeftColor;
+vec4 reflectionRightColor;
+vec4 refractionLeftColor;
+vec4 refractionRightColor;
+vec4 emissiveLeftColor;
+vec4 emissiveRightColor;
+vec2 vDiffuseInfos;
+vec2 vAmbientInfos;
+vec2 vOpacityInfos;
+vec2 vReflectionInfos;
+vec3 vReflectionPosition;
+vec3 vReflectionSize;
+vec2 vEmissiveInfos;
+vec2 vLightmapInfos;
+vec2 vSpecularInfos;
+vec3 vBumpInfos;
+mat4 diffuseMatrix;
+mat4 ambientMatrix;
+mat4 opacityMatrix;
+mat4 reflectionMatrix;
+mat4 emissiveMatrix;
+mat4 lightmapMatrix;
+mat4 specularMatrix;
+mat4 bumpMatrix;
+vec2 vTangentSpaceParams;
+float pointSize;
+float alphaCutOff;
+mat4 refractionMatrix;
+vec4 vRefractionInfos;
+vec3 vRefractionPosition;
+vec3 vRefractionSize;
+vec4 vSpecularColor;
+vec3 vEmissiveColor;
+vec4 vDiffuseColor;
+vec3 vAmbientColor;
+#define ADDITIONAL_UBO_DECLARATION
+};
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;
+e.IncludesShadersStore[o] = i;

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

@@ -0,0 +1,46 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+import "./decalVertexDeclaration.esm.js";
+const f = "defaultVertexDeclaration", e = `uniform mat4 viewProjection;
+uniform mat4 view;
+#ifdef DIFFUSE
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef AMBIENT
+uniform mat4 ambientMatrix;
+uniform vec2 vAmbientInfos;
+#endif
+#ifdef OPACITY
+uniform mat4 opacityMatrix;
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+uniform mat4 emissiveMatrix;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+uniform mat4 lightmapMatrix;
+#endif
+#if defined(SPECULAR) && defined(SPECULARTERM)
+uniform vec2 vSpecularInfos;
+uniform mat4 specularMatrix;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;
+uniform mat4 bumpMatrix;
+#endif
+#ifdef REFLECTION
+uniform mat4 reflectionMatrix;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+uniform mat4 detailMatrix;
+#endif
+#include<decalVertexDeclaration>
+#define ADDITIONAL_VERTEX_DECLARATION
+`;
+i.IncludesShadersStore[f] = e;

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

@@ -0,0 +1,7 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "depthPrePass", o = `#ifdef DEPTHPREPASS
+gl_FragColor=vec4(0.,0.,0.,1.0);
+return;
+#endif
+`;
+e.IncludesShadersStore[r] = o;

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

@@ -0,0 +1,10 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const r = "fogFragment", e = `#ifdef FOG
+float fog=CalcFogFactor();
+#ifdef PBR
+fog=toLinearSpace(fog);
+#endif
+color.rgb=mix(vFogColor,color.rgb,fog);
+#endif
+`;
+o.IncludesShadersStore[r] = e;

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

@@ -0,0 +1,34 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const f = "fogFragmentDeclaration", e = `#ifdef FOG
+#define FOGMODE_NONE 0.
+#define FOGMODE_EXP 1.
+#define FOGMODE_EXP2 2.
+#define FOGMODE_LINEAR 3.
+#define E 2.71828
+uniform vec4 vFogInfos;
+uniform vec3 vFogColor;
+varying vec3 vFogDistance;
+float CalcFogFactor()
+{
+float fogCoeff=1.0;
+float fogStart=vFogInfos.y;
+float fogEnd=vFogInfos.z;
+float fogDensity=vFogInfos.w;
+float fogDistance=length(vFogDistance);
+if (FOGMODE_LINEAR==vFogInfos.x)
+{
+fogCoeff=(fogEnd-fogDistance)/(fogEnd-fogStart);
+}
+else if (FOGMODE_EXP==vFogInfos.x)
+{
+fogCoeff=1.0/pow(E,fogDistance*fogDensity);
+}
+else if (FOGMODE_EXP2==vFogInfos.x)
+{
+fogCoeff=1.0/pow(E,fogDistance*fogDistance*fogDensity*fogDensity);
+}
+return clamp(fogCoeff,0.0,1.0);
+}
+#endif
+`;
+o.IncludesShadersStore[f] = e;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "fogVertex", r = `#ifdef FOG
+vFogDistance=(view*worldPos).xyz;
+#endif
+`;
+e.IncludesShadersStore[o] = r;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "fogVertexDeclaration", o = `#ifdef FOG
+varying vec3 vFogDistance;
+#endif
+`;
+e.IncludesShadersStore[r] = o;

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

@@ -0,0 +1,10 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "fresnelFunction", o = `#ifdef FRESNEL
+float computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float power)
+{
+float fresnelTerm=pow(bias+abs(dot(viewDirection,worldNormal)),power);
+return clamp(fresnelTerm,0.,1.);
+}
+#endif
+`;
+e.IncludesShadersStore[r] = o;