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

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

@@ -0,0 +1,5 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./sceneUboDeclaration.esm.js";
+const o = "geometryUboDeclaration", r = `#include<sceneUboDeclaration>
+`;
+e.IncludesShadersStore[o] = r;

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

@@ -0,0 +1,4 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "geometryVertexDeclaration", o = `uniform mat4 viewProjection;
+uniform mat4 view;`;
+e.IncludesShadersStore[r] = o;

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

@@ -0,0 +1,42 @@
+import { ShaderStore as r } from "../../Engines/shaderStore.esm.js";
+const e = "harmonicsFunctions", a = `#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+vec3 computeEnvironmentIrradiance(vec3 normal) {
+return vSphericalL00
++ vSphericalL1_1*(normal.y)
++ vSphericalL10*(normal.z)
++ vSphericalL11*(normal.x)
++ vSphericalL2_2*(normal.y*normal.x)
++ vSphericalL2_1*(normal.y*normal.z)
++ vSphericalL20*((3.0*normal.z*normal.z)-1.0)
++ vSphericalL21*(normal.z*normal.x)
++ vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));
+}
+#else
+vec3 computeEnvironmentIrradiance(vec3 normal) {
+float Nx=normal.x;
+float Ny=normal.y;
+float Nz=normal.z;
+vec3 C1=vSphericalZZ.rgb;
+vec3 Cx=vSphericalX.rgb;
+vec3 Cy=vSphericalY.rgb;
+vec3 Cz=vSphericalZ.rgb;
+vec3 Cxx_zz=vSphericalXX_ZZ.rgb;
+vec3 Cyy_zz=vSphericalYY_ZZ.rgb;
+vec3 Cxy=vSphericalXY.rgb;
+vec3 Cyz=vSphericalYZ.rgb;
+vec3 Czx=vSphericalZX.rgb;
+vec3 a1=Cyy_zz*Ny+Cy;
+vec3 a2=Cyz*Nz+a1;
+vec3 b1=Czx*Nz+Cx;
+vec3 b2=Cxy*Ny+b1;
+vec3 b3=Cxx_zz*Nx+b2;
+vec3 t1=Cz *Nz+C1;
+vec3 t2=a2 *Ny+t1;
+vec3 t3=b3 *Nx+t2;
+return t3;
+}
+#endif
+#endif
+`;
+r.IncludesShadersStore[e] = a;

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

@@ -0,0 +1,139 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "hdrFilteringFunctions", i = `#ifdef 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.;
+}
+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)
+{
+vec3 n=normalize(inputN);
+vec3 result=vec3(0.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);
+#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 Ls=hemisphereCosSample(Xi);
+Ls=normalize(Ls);
+vec3 Ns=vec3(0.,0.,1.);
+float NoL=dot(Ns,Ls);
+if (NoL>0.) {
+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.0,maxLevel);
+vec3 c=textureCubeLodEXT(inputTexture,tbn*Ls,mipLevel).rgb;
+#ifdef GAMMA_INPUT
+c=toLinearSpace(c);
+#endif
+result+=c;
+}
+}
+result=result*NUM_SAMPLES_FLOAT_INVERSED;
+return result;
+}
+#define inline
+vec3 radiance(float alphaG,samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)
+{
+vec3 n=normalize(inputN);
+if (alphaG==0.) {
+vec3 c=textureCube(inputTexture,n).rgb;
+#ifdef 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;
+#ifdef GAMMA_INPUT
+c=toLinearSpace(c);
+#endif
+result+=c*NoL;
+}
+}
+result=result/weight;
+return result;
+}
+}
+#endif
+#endif
+`;
+e.IncludesShadersStore[t] = i;

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

@@ -0,0 +1,166 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "helperFunctions", o = `const float PI=3.1415926535897932384626433832795;
+const float HALF_MIN=5.96046448e-08; 
+const float LinearEncodePowerApprox=2.2;
+const float GammaEncodePowerApprox=1.0/LinearEncodePowerApprox;
+const vec3 LuminanceEncodeApprox=vec3(0.2126,0.7152,0.0722);
+const float Epsilon=0.0000001;
+#define saturate(x) clamp(x,0.0,1.0)
+#define absEps(x) abs(x)+Epsilon
+#define maxEps(x) max(x,Epsilon)
+#define saturateEps(x) clamp(x,Epsilon,1.0)
+mat3 transposeMat3(mat3 inMatrix) {
+vec3 i0=inMatrix[0];
+vec3 i1=inMatrix[1];
+vec3 i2=inMatrix[2];
+mat3 outMatrix=mat3(
+vec3(i0.x,i1.x,i2.x),
+vec3(i0.y,i1.y,i2.y),
+vec3(i0.z,i1.z,i2.z)
+);
+return outMatrix;
+}
+mat3 inverseMat3(mat3 inMatrix) {
+float a00=inMatrix[0][0],a01=inMatrix[0][1],a02=inMatrix[0][2];
+float a10=inMatrix[1][0],a11=inMatrix[1][1],a12=inMatrix[1][2];
+float a20=inMatrix[2][0],a21=inMatrix[2][1],a22=inMatrix[2][2];
+float b01=a22*a11-a12*a21;
+float b11=-a22*a10+a12*a20;
+float b21=a21*a10-a11*a20;
+float det=a00*b01+a01*b11+a02*b21;
+return mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),
+b11,(a22*a00-a02*a20),(-a12*a00+a02*a10),
+b21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;
+}
+#if USE_EXACT_SRGB_CONVERSIONS
+vec3 toLinearSpaceExact(vec3 color)
+{
+vec3 nearZeroSection=0.0773993808*color;
+vec3 remainingSection=pow(0.947867299*(color+vec3(0.055)),vec3(2.4));
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.04045)));
+#else
+return
+vec3(
+color.r<=0.04045 ? nearZeroSection.r : remainingSection.r,
+color.g<=0.04045 ? nearZeroSection.g : remainingSection.g,
+color.b<=0.04045 ? nearZeroSection.b : remainingSection.b);
+#endif
+}
+vec3 toGammaSpaceExact(vec3 color)
+{
+vec3 nearZeroSection=12.92*color;
+vec3 remainingSection=1.055*pow(color,vec3(0.41666))-vec3(0.055);
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.0031308)));
+#else
+return
+vec3(
+color.r<=0.0031308 ? nearZeroSection.r : remainingSection.r,
+color.g<=0.0031308 ? nearZeroSection.g : remainingSection.g,
+color.b<=0.0031308 ? nearZeroSection.b : remainingSection.b);
+#endif
+}
+#endif
+float toLinearSpace(float color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+float nearZeroSection=0.0773993808*color;
+float remainingSection=pow(0.947867299*(color+0.055),2.4);
+return color<=0.04045 ? nearZeroSection : remainingSection;
+#else
+return pow(color,LinearEncodePowerApprox);
+#endif
+}
+vec3 toLinearSpace(vec3 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toLinearSpaceExact(color);
+#else
+return pow(color,vec3(LinearEncodePowerApprox));
+#endif
+}
+vec4 toLinearSpace(vec4 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4(toLinearSpaceExact(color.rgb),color.a);
+#else
+return vec4(pow(color.rgb,vec3(LinearEncodePowerApprox)),color.a);
+#endif
+}
+float toGammaSpace(float color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+float nearZeroSection=12.92*color;
+float remainingSection=1.055*pow(color,0.41666)-0.055;
+return color<=0.0031308 ? nearZeroSection : remainingSection;
+#else
+return pow(color,GammaEncodePowerApprox);
+#endif
+}
+vec3 toGammaSpace(vec3 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toGammaSpaceExact(color);
+#else
+return pow(color,vec3(GammaEncodePowerApprox));
+#endif
+}
+vec4 toGammaSpace(vec4 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4(toGammaSpaceExact(color.rgb),color.a);
+#else
+return vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);
+#endif
+}
+float square(float value)
+{
+return value*value;
+}
+vec3 square(vec3 value)
+{
+return value*value;
+}
+float pow5(float value) {
+float sq=value*value;
+return sq*sq*value;
+}
+float getLuminance(vec3 color)
+{
+return clamp(dot(color,LuminanceEncodeApprox),0.,1.);
+}
+float getRand(vec2 seed) {
+return fract(sin(dot(seed.xy ,vec2(12.9898,78.233)))*43758.5453);
+}
+float dither(vec2 seed,float varianceAmount) {
+float rand=getRand(seed);
+float normVariance=varianceAmount/255.0;
+float dither=mix(-normVariance,normVariance,rand);
+return dither;
+}
+const float rgbdMaxRange=255.0;
+vec4 toRGBD(vec3 color) {
+float maxRGB=maxEps(max(color.r,max(color.g,color.b)));
+float D =max(rgbdMaxRange/maxRGB,1.);
+D =clamp(floor(D)/255.0,0.,1.);
+vec3 rgb=color.rgb*D;
+rgb=toGammaSpace(rgb);
+return vec4(clamp(rgb,0.,1.),D); 
+}
+vec3 fromRGBD(vec4 rgbd) {
+rgbd.rgb=toLinearSpace(rgbd.rgb);
+return rgbd.rgb/rgbd.a;
+}
+vec3 parallaxCorrectNormal( vec3 vertexPos,vec3 origVec,vec3 cubeSize,vec3 cubePos ) {
+vec3 invOrigVec=vec3(1.0,1.0,1.0)/origVec;
+vec3 halfSize=cubeSize*0.5;
+vec3 intersecAtMaxPlane=(cubePos+halfSize-vertexPos)*invOrigVec;
+vec3 intersecAtMinPlane=(cubePos-halfSize-vertexPos)*invOrigVec;
+vec3 largestIntersec=max(intersecAtMaxPlane,intersecAtMinPlane);
+float distance=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);
+vec3 intersectPositionWS=vertexPos+origVec*distance;
+return intersectPositionWS-cubePos;
+}
+`;
+e.IncludesShadersStore[a] = o;

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

@@ -0,0 +1,32 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "imageProcessingDeclaration", i = `#ifdef EXPOSURE
+uniform float exposureLinear;
+#endif
+#ifdef CONTRAST
+uniform float contrast;
+#endif
+#if defined(VIGNETTE) || defined(DITHER)
+uniform vec2 vInverseScreenSize;
+#endif
+#ifdef VIGNETTE
+uniform vec4 vignetteSettings1;
+uniform vec4 vignetteSettings2;
+#endif
+#ifdef COLORCURVES
+uniform vec4 vCameraColorCurveNegative;
+uniform vec4 vCameraColorCurveNeutral;
+uniform vec4 vCameraColorCurvePositive;
+#endif
+#ifdef COLORGRADING
+#ifdef COLORGRADING3D
+uniform highp sampler3D txColorTransform;
+#else
+uniform sampler2D txColorTransform;
+#endif
+uniform vec4 colorTransformSettings;
+#endif
+#ifdef DITHER
+uniform float ditherIntensity;
+#endif
+`;
+e.IncludesShadersStore[r] = i;

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

@@ -0,0 +1,129 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "imageProcessingFunctions", t = `#if defined(COLORGRADING) && !defined(COLORGRADING3D)
+/** 
+* Polyfill for SAMPLE_TEXTURE_3D,which is unsupported in WebGL.
+* sampler3dSetting.x=textureOffset (0.5/textureSize).
+* sampler3dSetting.y=textureSize.
+*/
+#define inline
+vec3 sampleTexture3D(sampler2D colorTransform,vec3 color,vec2 sampler3dSetting)
+{
+float sliceSize=2.0*sampler3dSetting.x; 
+#ifdef SAMPLER3DGREENDEPTH
+float sliceContinuous=(color.g-sampler3dSetting.x)*sampler3dSetting.y;
+#else
+float sliceContinuous=(color.b-sampler3dSetting.x)*sampler3dSetting.y;
+#endif
+float sliceInteger=floor(sliceContinuous);
+float sliceFraction=sliceContinuous-sliceInteger;
+#ifdef SAMPLER3DGREENDEPTH
+vec2 sliceUV=color.rb;
+#else
+vec2 sliceUV=color.rg;
+#endif
+sliceUV.x*=sliceSize;
+sliceUV.x+=sliceInteger*sliceSize;
+sliceUV=saturate(sliceUV);
+vec4 slice0Color=texture2D(colorTransform,sliceUV);
+sliceUV.x+=sliceSize;
+sliceUV=saturate(sliceUV);
+vec4 slice1Color=texture2D(colorTransform,sliceUV);
+vec3 result=mix(slice0Color.rgb,slice1Color.rgb,sliceFraction);
+#ifdef SAMPLER3DBGRMAP
+color.rgb=result.rgb;
+#else
+color.rgb=result.bgr;
+#endif
+return color;
+}
+#endif
+#ifdef TONEMAPPING_ACES
+const mat3 ACESInputMat=mat3(
+vec3(0.59719,0.07600,0.02840),
+vec3(0.35458,0.90834,0.13383),
+vec3(0.04823,0.01566,0.83777)
+);
+const mat3 ACESOutputMat=mat3(
+vec3( 1.60475,-0.10208,-0.00327),
+vec3(-0.53108, 1.10813,-0.07276),
+vec3(-0.07367,-0.00605, 1.07602)
+);
+vec3 RRTAndODTFit(vec3 v)
+{
+vec3 a=v*(v+0.0245786)-0.000090537;
+vec3 b=v*(0.983729*v+0.4329510)+0.238081;
+return a/b;
+}
+vec3 ACESFitted(vec3 color)
+{
+color=ACESInputMat*color;
+color=RRTAndODTFit(color);
+color=ACESOutputMat*color;
+color=saturate(color);
+return color;
+}
+#endif
+#define CUSTOM_IMAGEPROCESSINGFUNCTIONS_DEFINITIONS
+vec4 applyImageProcessing(vec4 result) {
+#define CUSTOM_IMAGEPROCESSINGFUNCTIONS_UPDATERESULT_ATSTART
+#ifdef EXPOSURE
+result.rgb*=exposureLinear;
+#endif
+#ifdef VIGNETTE
+vec2 viewportXY=gl_FragCoord.xy*vInverseScreenSize;
+viewportXY=viewportXY*2.0-1.0;
+vec3 vignetteXY1=vec3(viewportXY*vignetteSettings1.xy+vignetteSettings1.zw,1.0);
+float vignetteTerm=dot(vignetteXY1,vignetteXY1);
+float vignette=pow(vignetteTerm,vignetteSettings2.w);
+vec3 vignetteColor=vignetteSettings2.rgb;
+#ifdef VIGNETTEBLENDMODEMULTIPLY
+vec3 vignetteColorMultiplier=mix(vignetteColor,vec3(1,1,1),vignette);
+result.rgb*=vignetteColorMultiplier;
+#endif
+#ifdef VIGNETTEBLENDMODEOPAQUE
+result.rgb=mix(vignetteColor,result.rgb,vignette);
+#endif
+#endif
+#ifdef TONEMAPPING
+#ifdef TONEMAPPING_ACES
+result.rgb=ACESFitted(result.rgb);
+#else
+const float tonemappingCalibration=1.590579;
+result.rgb=1.0-exp2(-tonemappingCalibration*result.rgb);
+#endif
+#endif
+result.rgb=toGammaSpace(result.rgb);
+result.rgb=saturate(result.rgb);
+#ifdef CONTRAST
+vec3 resultHighContrast=result.rgb*result.rgb*(3.0-2.0*result.rgb);
+if (contrast<1.0) {
+result.rgb=mix(vec3(0.5,0.5,0.5),result.rgb,contrast);
+} else {
+result.rgb=mix(result.rgb,resultHighContrast,contrast-1.0);
+}
+#endif
+#ifdef COLORGRADING
+vec3 colorTransformInput=result.rgb*colorTransformSettings.xxx+colorTransformSettings.yyy;
+#ifdef COLORGRADING3D
+vec3 colorTransformOutput=texture(txColorTransform,colorTransformInput).rgb;
+#else
+vec3 colorTransformOutput=sampleTexture3D(txColorTransform,colorTransformInput,colorTransformSettings.yz).rgb;
+#endif
+result.rgb=mix(result.rgb,colorTransformOutput,colorTransformSettings.www);
+#endif
+#ifdef COLORCURVES
+float luma=getLuminance(result.rgb);
+vec2 curveMix=clamp(vec2(luma*3.0-1.5,luma*-3.0+1.5),vec2(0.0),vec2(1.0));
+vec4 colorCurve=vCameraColorCurveNeutral+curveMix.x*vCameraColorCurvePositive-curveMix.y*vCameraColorCurveNegative;
+result.rgb*=colorCurve.rgb;
+result.rgb=mix(vec3(luma),result.rgb,colorCurve.a);
+#endif
+#ifdef DITHER
+float rand=getRand(gl_FragCoord.xy*vInverseScreenSize);
+float dither=mix(-ditherIntensity,ditherIntensity,rand);
+result.rgb=saturate(result.rgb+vec3(dither));
+#endif
+#define CUSTOM_IMAGEPROCESSINGFUNCTIONS_UPDATERESULT_ATEND
+return result;
+}`;
+e.IncludesShadersStore[r] = t;

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

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

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

@@ -0,0 +1,31 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "instancesDeclaration", d = `#ifdef INSTANCES
+attribute vec4 world0;
+attribute vec4 world1;
+attribute vec4 world2;
+attribute vec4 world3;
+#ifdef INSTANCESCOLOR
+attribute vec4 instanceColor;
+#endif
+#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)
+uniform mat4 world;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY)
+attribute vec4 previousWorld0;
+attribute vec4 previousWorld1;
+attribute vec4 previousWorld2;
+attribute vec4 previousWorld3;
+#ifdef THIN_INSTANCES
+uniform mat4 previousWorld;
+#endif
+#endif
+#else
+#if !defined(WORLD_UBO)
+uniform mat4 world;
+#endif
+#if defined(VELOCITY) || defined(PREPASS_VELOCITY)
+uniform mat4 previousWorld;
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = d;

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

@@ -0,0 +1,20 @@
+import { ShaderStore as d } from "../../Engines/shaderStore.esm.js";
+const e = "instancesVertex", r = `#ifdef INSTANCES
+mat4 finalWorld=mat4(world0,world1,world2,world3);
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY)
+mat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,previousWorld2,previousWorld3);
+#endif
+#ifdef THIN_INSTANCES
+finalWorld=world*finalWorld;
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY)
+finalPreviousWorld=previousWorld*finalPreviousWorld;
+#endif
+#endif
+#else
+mat4 finalWorld=world;
+#if defined(PREPASS_VELOCITY) || defined(VELOCITY)
+mat4 finalPreviousWorld=previousWorld;
+#endif
+#endif
+`;
+d.IncludesShadersStore[e] = r;

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

@@ -0,0 +1,15 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "kernelBlurFragment", r = `#ifdef DOF
+factor=sampleCoC(sampleCoord{X}); 
+computedWeight=KERNEL_WEIGHT{X}*factor;
+sumOfWeights+=computedWeight;
+#else
+computedWeight=KERNEL_WEIGHT{X};
+#endif
+#ifdef PACKEDFLOAT
+blend+=unpack(texture2D(textureSampler,sampleCoord{X}))*computedWeight;
+#else
+blend+=texture2D(textureSampler,sampleCoord{X})*computedWeight;
+#endif
+`;
+e.IncludesShadersStore[t] = r;

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

@@ -0,0 +1,15 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "kernelBlurFragment2", r = `#ifdef DOF
+factor=sampleCoC(sampleCenter+delta*KERNEL_DEP_OFFSET{X});
+computedWeight=KERNEL_DEP_WEIGHT{X}*factor;
+sumOfWeights+=computedWeight;
+#else
+computedWeight=KERNEL_DEP_WEIGHT{X};
+#endif
+#ifdef PACKEDFLOAT
+blend+=unpack(texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X}))*computedWeight;
+#else
+blend+=texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X})*computedWeight;
+#endif
+`;
+e.IncludesShadersStore[t] = r;

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

@@ -0,0 +1,3 @@
+import { ShaderStore as r } from "../../Engines/shaderStore.esm.js";
+const e = "kernelBlurVaryingDeclaration", a = "varying vec2 sampleCoord{X};";
+r.IncludesShadersStore[e] = a;

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

@@ -0,0 +1,3 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "kernelBlurVertex", o = "sampleCoord{X}=sampleCenter+delta*KERNEL_OFFSET{X};";
+e.IncludesShadersStore[r] = o;