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

package/dist/node_modules/@babylonjs/core/Shaders/screenSpaceReflection2BlurCombiner.fragment.esm.js

@@ -0,0 +1,59 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/pbrBRDFFunctions.esm.js";
+import "./ShadersInclude/screenSpaceRayTrace.esm.js";
+const r = "screenSpaceReflection2BlurCombinerPixelShader", i = `uniform sampler2D textureSampler; 
+uniform sampler2D mainSampler;
+uniform sampler2D reflectivitySampler;
+uniform float strength;
+uniform float reflectionSpecularFalloffExponent;
+uniform float reflectivityThreshold;
+varying vec2 vUV;
+#include<helperFunctions>
+#ifdef SSR_BLEND_WITH_FRESNEL
+#include<pbrBRDFFunctions>
+#include<screenSpaceRayTrace>
+uniform mat4 projection;
+uniform mat4 invProjectionMatrix;
+uniform sampler2D normalSampler;
+uniform sampler2D depthSampler;
+#endif
+void main()
+{
+#ifdef SSRAYTRACE_DEBUG
+gl_FragColor=texture2D(textureSampler,vUV);
+#else
+vec3 SSR=texture2D(textureSampler,vUV).rgb;
+vec4 color=texture2D(mainSampler,vUV);
+vec4 reflectivity=texture2D(reflectivitySampler,vUV);
+#ifndef SSR_DISABLE_REFLECTIVITY_TEST
+if (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {
+gl_FragColor=color;
+return;
+}
+#endif
+#ifdef SSR_INPUT_IS_GAMMA_SPACE
+color=toLinearSpace(color);
+#endif
+#ifdef SSR_BLEND_WITH_FRESNEL
+vec2 texSize=vec2(textureSize(depthSampler,0));
+vec3 csNormal=texelFetch(normalSampler,ivec2(vUV*texSize),0).xyz;
+float depth=texelFetch(depthSampler,ivec2(vUV*texSize),0).r;
+vec3 csPosition=computeViewPosFromUVDepth(vUV,depth,projection,invProjectionMatrix);
+vec3 csViewDirection=normalize(csPosition);
+vec3 F0=reflectivity.rgb;
+vec3 fresnel=fresnelSchlickGGX(max(dot(csNormal,-csViewDirection),0.0),F0,vec3(1.));
+vec3 reflectionMultiplier=clamp(pow(fresnel*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+#else
+vec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+#endif
+vec3 colorMultiplier=1.0-reflectionMultiplier;
+vec3 finalColor=(color.rgb*colorMultiplier)+(SSR*reflectionMultiplier);
+#ifdef SSR_OUTPUT_IS_GAMMA_SPACE
+finalColor=toGammaSpace(finalColor);
+#endif
+gl_FragColor=vec4(finalColor,color.a);
+#endif
+}
+`;
+e.ShadersStore[r] = i;

package/dist/node_modules/@babylonjs/core/Shaders/sharpen.fragment.esm.js

@@ -0,0 +1,18 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const r = "sharpenPixelShader", t = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform vec2 screenSize;
+uniform vec2 sharpnessAmounts;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+vec2 onePixel=vec2(1.0,1.0)/screenSize;
+vec4 color=texture2D(textureSampler,vUV);
+vec4 edgeDetection=texture2D(textureSampler,vUV+onePixel*vec2(0,-1)) +
+texture2D(textureSampler,vUV+onePixel*vec2(-1,0)) +
+texture2D(textureSampler,vUV+onePixel*vec2(1,0)) +
+texture2D(textureSampler,vUV+onePixel*vec2(0,1)) -
+color*4.0;
+gl_FragColor=max(vec4(color.rgb*sharpnessAmounts.y,color.a)-(sharpnessAmounts.x*vec4(edgeDetection.rgb,0)),0.);
+}`;
+e.ShadersStore[r] = t;

package/dist/node_modules/@babylonjs/core/Shaders/ssao.fragment.esm.js

@@ -0,0 +1,55 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const r = "ssaoPixelShader", o = `uniform sampler2D textureSampler;
+varying vec2 vUV;
+#ifdef SSAO
+uniform sampler2D randomSampler;
+uniform float randTextureTiles;
+uniform float samplesFactor;
+uniform vec3 sampleSphere[SAMPLES];
+uniform float totalStrength;
+uniform float radius;
+uniform float area;
+uniform float fallOff;
+uniform float base;
+vec3 normalFromDepth(float depth,vec2 coords)
+{
+vec2 offset1=vec2(0.0,radius);
+vec2 offset2=vec2(radius,0.0);
+float depth1=texture2D(textureSampler,coords+offset1).r;
+float depth2=texture2D(textureSampler,coords+offset2).r;
+vec3 p1=vec3(offset1,depth1-depth);
+vec3 p2=vec3(offset2,depth2-depth);
+vec3 normal=cross(p1,p2);
+normal.z=-normal.z;
+return normalize(normal);
+}
+void main()
+{
+vec3 random=normalize(texture2D(randomSampler,vUV*randTextureTiles).rgb);
+float depth=texture2D(textureSampler,vUV).r;
+vec3 position=vec3(vUV,depth);
+vec3 normal=normalFromDepth(depth,vUV);
+float radiusDepth=radius/depth;
+float occlusion=0.0;
+vec3 ray;
+vec3 hemiRay;
+float occlusionDepth;
+float difference;
+for (int i=0; i<SAMPLES; i++)
+{
+ray=radiusDepth*reflect(sampleSphere[i],random);
+hemiRay=position+sign(dot(ray,normal))*ray;
+occlusionDepth=texture2D(textureSampler,clamp(hemiRay.xy,vec2(0.001,0.001),vec2(0.999,0.999))).r;
+difference=depth-occlusionDepth;
+occlusion+=step(fallOff,difference)*(1.0-smoothstep(fallOff,area,difference));
+}
+float ao=1.0-totalStrength*occlusion*samplesFactor;
+float result=clamp(ao+base,0.0,1.0);
+gl_FragColor.r=result;
+gl_FragColor.g=result;
+gl_FragColor.b=result;
+gl_FragColor.a=1.0;
+}
+#endif
+`;
+e.ShadersStore[r] = o;

package/dist/node_modules/@babylonjs/core/Shaders/ssao2.fragment.esm.js

@@ -0,0 +1,165 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const t = "ssao2PixelShader", o = `precision highp float;
+uniform sampler2D textureSampler;
+varying vec2 vUV;
+#ifdef SSAO
+float scales[16]=float[16](
+0.1,
+0.11406250000000001,
+0.131640625,
+0.15625,
+0.187890625,
+0.2265625,
+0.272265625,
+0.325,
+0.384765625,
+0.4515625,
+0.525390625,
+0.60625,
+0.694140625,
+0.7890625,
+0.891015625,
+1.0
+);
+uniform float near;
+uniform float radius;
+uniform sampler2D depthSampler;
+uniform sampler2D randomSampler;
+uniform sampler2D normalSampler;
+uniform float randTextureTiles;
+uniform float samplesFactor;
+uniform vec3 sampleSphere[SAMPLES];
+uniform float totalStrength;
+uniform float base;
+uniform float xViewport;
+uniform float yViewport;
+uniform mat3 depthProjection;
+uniform float maxZ;
+uniform float minZAspect;
+uniform vec2 texelSize;
+uniform mat4 projection;
+void main()
+{
+vec3 random=textureLod(randomSampler,vUV*randTextureTiles,0.0).rgb;
+float depth=textureLod(depthSampler,vUV,0.0).r;
+float depthSign=depth/abs(depth);
+depth=depth*depthSign;
+vec3 normal=textureLod(normalSampler,vUV,0.0).rgb;
+float occlusion=0.0;
+float correctedRadius=min(radius,minZAspect*depth/near);
+vec3 vViewRay=vec3((vUV.x*2.0-1.0)*xViewport,(vUV.y*2.0-1.0)*yViewport,depthSign);
+vec3 vDepthFactor=depthProjection*vec3(1.0,1.0,depth);
+vec3 origin=vViewRay*vDepthFactor;
+vec3 rvec=random*2.0-1.0;
+rvec.z=0.0;
+float dotProduct=dot(rvec,normal);
+rvec=1.0-abs(dotProduct)>1e-2 ? rvec : vec3(-rvec.y,0.0,rvec.x);
+vec3 tangent=normalize(rvec-normal*dot(rvec,normal));
+vec3 bitangent=cross(normal,tangent);
+mat3 tbn=mat3(tangent,bitangent,normal);
+float difference;
+for (int i=0; i<SAMPLES; ++i) {
+vec3 samplePosition=scales[(i+int(random.x*16.0)) % 16]*tbn*sampleSphere[(i+int(random.y*16.0)) % 16];
+samplePosition=samplePosition*correctedRadius+origin;
+vec4 offset=vec4(samplePosition,1.0);
+offset=projection*offset;
+offset.xyz/=offset.w;
+offset.xy=offset.xy*0.5+0.5;
+if (offset.x<0.0 || offset.y<0.0 || offset.x>1.0 || offset.y>1.0) {
+continue;
+}
+float sampleDepth=abs(textureLod(depthSampler,offset.xy,0.0).r);
+difference=depthSign*samplePosition.z-sampleDepth;
+float rangeCheck=1.0-smoothstep(correctedRadius*0.5,correctedRadius,difference);
+occlusion+=step(EPSILON,difference)*rangeCheck;
+}
+occlusion=occlusion*(1.0-smoothstep(maxZ*0.75,maxZ,depth));
+float ao=1.0-totalStrength*occlusion*samplesFactor;
+float result=clamp(ao+base,0.0,1.0);
+gl_FragColor=vec4(vec3(result),1.0);
+}
+#endif
+#ifdef BLUR
+uniform float outSize;
+uniform float soften;
+uniform float tolerance;
+uniform int samples;
+#ifndef BLUR_BYPASS
+uniform sampler2D depthSampler;
+#ifdef BLUR_LEGACY
+#define inline
+float blur13Bilateral(sampler2D image,vec2 uv,vec2 step) {
+float result=0.0;
+vec2 off1=vec2(1.411764705882353)*step;
+vec2 off2=vec2(3.2941176470588234)*step;
+vec2 off3=vec2(5.176470588235294)*step;
+float compareDepth=abs(textureLod(depthSampler,uv,0.0).r);
+float sampleDepth;
+float weight;
+float weightSum=30.0;
+result+=textureLod(image,uv,0.0).r*30.0;
+sampleDepth=abs(textureLod(depthSampler,uv+off1,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+= weight;
+result+=textureLod(image,uv+off1,0.0).r*weight;
+sampleDepth=abs(textureLod(depthSampler,uv-off1,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+= weight;
+result+=textureLod(image,uv-off1,0.0).r*weight;
+sampleDepth=abs(textureLod(depthSampler,uv+off2,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+=weight;
+result+=textureLod(image,uv+off2,0.0).r*weight;
+sampleDepth=abs(textureLod(depthSampler,uv-off2,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+=weight;
+result+=textureLod(image,uv-off2,0.0).r*weight;
+sampleDepth=abs(textureLod(depthSampler,uv+off3,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+=weight;
+result+=textureLod(image,uv+off3,0.0).r*weight;
+sampleDepth=abs(textureLod(depthSampler,uv-off3,0.0).r);
+weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);
+weightSum+=weight;
+result+=textureLod(image,uv-off3,0.0).r*weight;
+return result/weightSum;
+}
+#endif
+#endif
+void main()
+{
+float result=0.0;
+#ifdef BLUR_BYPASS
+result=textureLod(textureSampler,vUV,0.0).r;
+#else
+#ifdef BLUR_H
+vec2 step=vec2(1.0/outSize,0.0);
+#else
+vec2 step=vec2(0.0,1.0/outSize);
+#endif
+#ifdef BLUR_LEGACY
+result=blur13Bilateral(textureSampler,vUV,step);
+#else
+float compareDepth=abs(textureLod(depthSampler,vUV,0.0).r);
+float weightSum=0.0;
+for (int i=-samples; i<samples; i+=2)
+{
+vec2 samplePos=vUV+step*(float(i)+0.5);
+float sampleDepth=abs(textureLod(depthSampler,samplePos,0.0).r);
+float falloff=smoothstep(0.0,
+float(samples),
+float(samples)-abs(float(i))*soften);
+float minDivider=tolerance*0.5+0.003;
+float weight=falloff/( minDivider+abs(compareDepth-sampleDepth));
+result+=textureLod(textureSampler,samplePos,0.0).r*weight;
+weightSum+=weight;
+}
+result/=weightSum;
+#endif
+#endif
+gl_FragColor.rgb=vec3(result);
+gl_FragColor.a=1.0;
+}
+#endif
+`;
+e.ShadersStore[t] = o;

package/dist/node_modules/@babylonjs/core/Shaders/ssaoCombine.fragment.esm.js

@@ -0,0 +1,15 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "ssaoCombinePixelShader", r = `uniform sampler2D textureSampler;
+uniform sampler2D originalColor;
+uniform vec4 viewport;
+varying vec2 vUV;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+vec4 ssaoColor=texture2D(textureSampler,viewport.xy+vUV*viewport.zw);
+vec4 sceneColor=texture2D(originalColor,vUV);
+gl_FragColor=sceneColor*ssaoColor;
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+e.ShadersStore[o] = r;

package/dist/node_modules/@babylonjs/core/Shaders/standard.fragment.esm.js

@@ -0,0 +1,339 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/packingFunctions.esm.js";
+const r = "standardPixelShader", t = `uniform sampler2D textureSampler;
+varying vec2 vUV;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+#if defined(PASS_POST_PROCESS)
+void main(void)
+{
+vec4 color=texture2D(textureSampler,vUV);
+gl_FragColor=color;
+}
+#endif
+#if defined(DOWN_SAMPLE_X4)
+uniform vec2 dsOffsets[16];
+void main(void)
+{
+vec4 average=vec4(0.0,0.0,0.0,0.0);
+average=texture2D(textureSampler,vUV+dsOffsets[0]);
+average+=texture2D(textureSampler,vUV+dsOffsets[1]);
+average+=texture2D(textureSampler,vUV+dsOffsets[2]);
+average+=texture2D(textureSampler,vUV+dsOffsets[3]);
+average+=texture2D(textureSampler,vUV+dsOffsets[4]);
+average+=texture2D(textureSampler,vUV+dsOffsets[5]);
+average+=texture2D(textureSampler,vUV+dsOffsets[6]);
+average+=texture2D(textureSampler,vUV+dsOffsets[7]);
+average+=texture2D(textureSampler,vUV+dsOffsets[8]);
+average+=texture2D(textureSampler,vUV+dsOffsets[9]);
+average+=texture2D(textureSampler,vUV+dsOffsets[10]);
+average+=texture2D(textureSampler,vUV+dsOffsets[11]);
+average+=texture2D(textureSampler,vUV+dsOffsets[12]);
+average+=texture2D(textureSampler,vUV+dsOffsets[13]);
+average+=texture2D(textureSampler,vUV+dsOffsets[14]);
+average+=texture2D(textureSampler,vUV+dsOffsets[15]);
+average/=16.0;
+gl_FragColor=average;
+}
+#endif
+#if defined(BRIGHT_PASS)
+uniform vec2 dsOffsets[4];
+uniform float brightThreshold;
+void main(void)
+{
+vec4 average=vec4(0.0,0.0,0.0,0.0);
+average=texture2D(textureSampler,vUV+vec2(dsOffsets[0].x,dsOffsets[0].y));
+average+=texture2D(textureSampler,vUV+vec2(dsOffsets[1].x,dsOffsets[1].y));
+average+=texture2D(textureSampler,vUV+vec2(dsOffsets[2].x,dsOffsets[2].y));
+average+=texture2D(textureSampler,vUV+vec2(dsOffsets[3].x,dsOffsets[3].y));
+average*=0.25;
+float luminance=length(average.rgb);
+if (luminance<brightThreshold) {
+average=vec4(0.0,0.0,0.0,1.0);
+}
+gl_FragColor=average;
+}
+#endif
+#if defined(TEXTURE_ADDER)
+uniform sampler2D otherSampler;
+uniform sampler2D lensSampler;
+uniform float exposure;
+void main(void)
+{
+vec3 colour=texture2D(textureSampler,vUV).rgb;
+colour*=exposure;
+vec3 X=max(vec3(0.0,0.0,0.0),colour-0.004);
+vec3 retColor=(X*(6.2*X+0.5))/(X*(6.2*X+1.7)+0.06);
+colour=retColor*retColor;
+colour+=colour*texture2D(lensSampler,vUV).rgb;
+vec4 finalColor=vec4(colour.rgb,1.0)+texture2D(otherSampler,vUV);
+gl_FragColor=finalColor;
+}
+#endif
+#if defined(VLS)
+#define PI 3.1415926535897932384626433832795
+uniform mat4 shadowViewProjection;
+uniform mat4 lightWorld;
+uniform vec3 cameraPosition;
+uniform vec3 sunDirection;
+uniform vec3 sunColor;
+uniform vec2 depthValues;
+uniform float scatteringCoefficient;
+uniform float scatteringPower;
+uniform sampler2D shadowMapSampler;
+uniform sampler2D positionSampler;
+float computeScattering(float lightDotView)
+{
+float result=1.0-scatteringCoefficient*scatteringCoefficient;
+result/=(4.0*PI*pow(1.0+scatteringCoefficient*scatteringCoefficient-(2.0*scatteringCoefficient)*lightDotView,1.5));
+return result;
+}
+void main(void)
+{
+vec3 worldPos=texture2D(positionSampler,vUV).rgb;
+vec3 startPosition=cameraPosition;
+vec3 rayVector=worldPos-startPosition;
+float rayLength=length(rayVector);
+vec3 rayDirection=rayVector/rayLength;
+float stepLength=rayLength/NB_STEPS;
+vec3 stepL=rayDirection*stepLength;
+vec3 currentPosition=startPosition;
+vec3 accumFog=vec3(0.0);
+for (int i=0; i<int(NB_STEPS); i++)
+{
+vec4 worldInShadowCameraSpace=shadowViewProjection*vec4(currentPosition,1.0);
+float depthMetric= (worldInShadowCameraSpace.z+depthValues.x)/(depthValues.y);
+float shadowPixelDepth=clamp(depthMetric,0.0,1.0);
+worldInShadowCameraSpace.xyz/=worldInShadowCameraSpace.w;
+worldInShadowCameraSpace.xyz=0.5*worldInShadowCameraSpace.xyz+vec3(0.5);
+float shadowMapValue=texture2D(shadowMapSampler,worldInShadowCameraSpace.xy).r;
+if (shadowMapValue>shadowPixelDepth)
+accumFog+=sunColor*computeScattering(dot(rayDirection,sunDirection));
+currentPosition+=stepL;
+}
+accumFog/=NB_STEPS;
+vec3 color=accumFog*scatteringPower;
+gl_FragColor=vec4(color*exp(color) ,1.0);
+}
+#endif
+#if defined(VLSMERGE)
+uniform sampler2D originalSampler;
+void main(void)
+{
+gl_FragColor=texture2D(originalSampler,vUV)+texture2D(textureSampler,vUV);
+}
+#endif
+#if defined(LUMINANCE)
+uniform vec2 lumOffsets[4];
+void main()
+{
+float average=0.0;
+vec4 color=vec4(0.0);
+float maximum=-1e20;
+vec3 weight=vec3(0.299,0.587,0.114);
+for (int i=0; i<4; i++)
+{
+color=texture2D(textureSampler,vUV+ lumOffsets[i]);
+float GreyValue=dot(color.rgb,vec3(0.33,0.33,0.33));
+#ifdef WEIGHTED_AVERAGE
+float GreyValue=dot(color.rgb,weight);
+#endif
+#ifdef BRIGHTNESS
+float GreyValue=max(color.r,max(color.g,color.b));
+#endif
+#ifdef HSL_COMPONENT
+float GreyValue=0.5*(max(color.r,max(color.g,color.b))+min(color.r,min(color.g,color.b)));
+#endif
+#ifdef MAGNITUDE
+float GreyValue=length(color.rgb);
+#endif
+maximum=max(maximum,GreyValue);
+average+=(0.25*log(1e-5+GreyValue));
+}
+average=exp(average);
+gl_FragColor=vec4(average,maximum,0.0,1.0);
+}
+#endif
+#if defined(LUMINANCE_DOWN_SAMPLE)
+uniform vec2 dsOffsets[9];
+uniform float halfDestPixelSize;
+#ifdef FINAL_DOWN_SAMPLER
+#include<packingFunctions>
+#endif
+void main()
+{
+vec4 color=vec4(0.0);
+float average=0.0;
+for (int i=0; i<9; i++)
+{
+color=texture2D(textureSampler,vUV+vec2(halfDestPixelSize,halfDestPixelSize)+dsOffsets[i]);
+average+=color.r;
+}
+average/=9.0;
+#ifdef FINAL_DOWN_SAMPLER
+gl_FragColor=pack(average);
+#else
+gl_FragColor=vec4(average,average,0.0,1.0);
+#endif
+}
+#endif
+#if defined(HDR)
+uniform sampler2D textureAdderSampler;
+uniform float averageLuminance;
+void main()
+{
+vec4 color=texture2D(textureAdderSampler,vUV);
+#ifndef AUTO_EXPOSURE
+vec4 adjustedColor=color/averageLuminance;
+color=adjustedColor;
+color.a=1.0;
+#endif
+gl_FragColor=color;
+}
+#endif
+#if defined(LENS_FLARE)
+#define GHOSTS 3
+uniform sampler2D lensColorSampler;
+uniform float strength;
+uniform float ghostDispersal;
+uniform float haloWidth;
+uniform vec2 resolution;
+uniform float distortionStrength;
+float hash(vec2 p)
+{
+float h=dot(p,vec2(127.1,311.7));
+return -1.0+2.0*fract(sin(h)*43758.5453123);
+}
+float noise(in vec2 p)
+{
+vec2 i=floor(p);
+vec2 f=fract(p);
+vec2 u=f*f*(3.0-2.0*f);
+return mix(mix(hash(i+vec2(0.0,0.0)),
+hash(i+vec2(1.0,0.0)),u.x),
+mix(hash(i+vec2(0.0,1.0)),
+hash(i+vec2(1.0,1.0)),u.x),u.y);
+}
+float fbm(vec2 p)
+{
+float f=0.0;
+f+=0.5000*noise(p); p*=2.02;
+f+=0.2500*noise(p); p*=2.03;
+f+=0.1250*noise(p); p*=2.01;
+f+=0.0625*noise(p); p*=2.04;
+f/=0.9375;
+return f;
+}
+vec3 pattern(vec2 uv)
+{
+vec2 p=-1.0+2.0*uv;
+float p2=dot(p,p);
+float f=fbm(vec2(15.0*p2))/2.0;
+float r=0.2+0.6*sin(12.5*length(uv-vec2(0.5)));
+float g=0.2+0.6*sin(20.5*length(uv-vec2(0.5)));
+float b=0.2+0.6*sin(17.2*length(uv-vec2(0.5)));
+return (1.0-f)*vec3(r,g,b);
+}
+float luminance(vec3 color)
+{
+return dot(color.rgb,vec3(0.2126,0.7152,0.0722));
+}
+vec4 textureDistorted(sampler2D tex,vec2 texcoord,vec2 direction,vec3 distortion)
+{
+return vec4(
+texture2D(tex,texcoord+direction*distortion.r).r,
+texture2D(tex,texcoord+direction*distortion.g).g,
+texture2D(tex,texcoord+direction*distortion.b).b,
+1.0
+);
+}
+void main(void)
+{
+vec2 uv=-vUV+vec2(1.0);
+vec2 ghostDir=(vec2(0.5)-uv)*ghostDispersal;
+vec2 texelSize=1.0/resolution;
+vec3 distortion=vec3(-texelSize.x*distortionStrength,0.0,texelSize.x*distortionStrength);
+vec4 result=vec4(0.0);
+float ghostIndice=1.0;
+for (int i=0; i<GHOSTS; ++i)
+{
+vec2 offset=fract(uv+ghostDir*ghostIndice);
+float weight=length(vec2(0.5)-offset)/length(vec2(0.5));
+weight=pow(1.0-weight,10.0);
+result+=textureDistorted(textureSampler,offset,normalize(ghostDir),distortion)*weight*strength;
+ghostIndice+=1.0;
+}
+vec2 haloVec=normalize(ghostDir)*haloWidth;
+float weight=length(vec2(0.5)-fract(uv+haloVec))/length(vec2(0.5));
+weight=pow(1.0-weight,10.0);
+result+=textureDistorted(textureSampler,fract(uv+haloVec),normalize(ghostDir),distortion)*weight*strength;
+result*=texture2D(lensColorSampler,vec2(length(vec2(0.5)-uv)/length(vec2(0.5))));
+gl_FragColor=result;
+}
+#endif
+#if defined(LENS_FLARE_COMPOSE)
+uniform sampler2D otherSampler;
+uniform sampler2D lensDirtSampler;
+uniform sampler2D lensStarSampler;
+uniform mat4 lensStarMatrix;
+void main(void)
+{
+vec2 lensFlareCoords=(lensStarMatrix*vec4(vUV,1.0,1.0)).xy;
+vec4 lensMod=texture2D(lensDirtSampler,vUV);
+lensMod+=texture2D(lensStarSampler,vUV/*lensFlareCoords*/);
+vec4 result=texture2D(textureSampler,vUV)*lensMod;
+gl_FragColor=texture2D(otherSampler,vUV)+result;
+}
+#endif
+#if defined(DEPTH_OF_FIELD)
+uniform sampler2D otherSampler;
+uniform sampler2D depthSampler;
+uniform float distance;
+void main(void)
+{
+vec4 sharp=texture2D(otherSampler,vUV);
+vec4 blur=texture2D(textureSampler,vUV);
+float dist=clamp(texture2D(depthSampler,vUV).r*distance,0.0,1.0);
+float factor=0.0;
+if (dist<0.05)
+factor=1.0;
+else if (dist<0.1)
+factor=20.0*(0.1-dist);
+else if (dist<0.5)
+factor=0.0;
+else
+factor=2.0*(dist-0.5);
+factor=clamp(factor,0.0,0.90);
+gl_FragColor=mix(sharp,blur,factor);
+}
+#endif
+#if defined(MOTION_BLUR)
+uniform mat4 inverseViewProjection;
+uniform mat4 prevViewProjection;
+uniform vec2 screenSize;
+uniform float motionScale;
+uniform float motionStrength;
+uniform sampler2D depthSampler;
+void main(void)
+{
+vec2 texelSize=1.0/screenSize;
+float depth=texture2D(depthSampler,vUV).r;
+vec4 cpos=vec4(vUV*2.0-1.0,depth,1.0);
+cpos=cpos*inverseViewProjection;
+vec4 ppos=cpos*prevViewProjection;
+ppos.xyz/=ppos.w;
+ppos.xy=ppos.xy*0.5+0.5;
+vec2 velocity=(ppos.xy-vUV)*motionScale*motionStrength;
+float speed=length(velocity/texelSize);
+int nSamples=int(clamp(speed,1.0,MAX_MOTION_SAMPLES));
+vec4 result=texture2D(textureSampler,vUV);
+for (int i=1; i<int(MAX_MOTION_SAMPLES); ++i) {
+if (i>=nSamples)
+break;
+vec2 offset1=vUV+velocity*(float(i)/float(nSamples-1)-0.5);
+result+=texture2D(textureSampler,offset1);
+}
+gl_FragColor=result/float(nSamples);
+}
+#endif
+`;
+e.ShadersStore[r] = t;

package/dist/node_modules/@babylonjs/core/States/alphaCullingState.esm.js

@@ -0,0 +1,35 @@
+class a {
+  /**
+   * Initializes the state.
+   */
+  constructor() {
+    this._blendFunctionParameters = new Array(4), this._blendEquationParameters = new Array(2), this._blendConstants = new Array(4), this._isBlendConstantsDirty = !1, this._alphaBlend = !1, this._isAlphaBlendDirty = !1, this._isBlendFunctionParametersDirty = !1, this._isBlendEquationParametersDirty = !1, this.reset();
+  }
+  get isDirty() {
+    return this._isAlphaBlendDirty || this._isBlendFunctionParametersDirty || this._isBlendEquationParametersDirty;
+  }
+  get alphaBlend() {
+    return this._alphaBlend;
+  }
+  set alphaBlend(t) {
+    this._alphaBlend !== t && (this._alphaBlend = t, this._isAlphaBlendDirty = !0);
+  }
+  setAlphaBlendConstants(t, n, s, e) {
+    this._blendConstants[0] === t && this._blendConstants[1] === n && this._blendConstants[2] === s && this._blendConstants[3] === e || (this._blendConstants[0] = t, this._blendConstants[1] = n, this._blendConstants[2] = s, this._blendConstants[3] = e, this._isBlendConstantsDirty = !0);
+  }
+  setAlphaBlendFunctionParameters(t, n, s, e) {
+    this._blendFunctionParameters[0] === t && this._blendFunctionParameters[1] === n && this._blendFunctionParameters[2] === s && this._blendFunctionParameters[3] === e || (this._blendFunctionParameters[0] = t, this._blendFunctionParameters[1] = n, this._blendFunctionParameters[2] = s, this._blendFunctionParameters[3] = e, this._isBlendFunctionParametersDirty = !0);
+  }
+  setAlphaEquationParameters(t, n) {
+    this._blendEquationParameters[0] === t && this._blendEquationParameters[1] === n || (this._blendEquationParameters[0] = t, this._blendEquationParameters[1] = n, this._isBlendEquationParametersDirty = !0);
+  }
+  reset() {
+    this._alphaBlend = !1, this._blendFunctionParameters[0] = null, this._blendFunctionParameters[1] = null, this._blendFunctionParameters[2] = null, this._blendFunctionParameters[3] = null, this._blendEquationParameters[0] = null, this._blendEquationParameters[1] = null, this._blendConstants[0] = null, this._blendConstants[1] = null, this._blendConstants[2] = null, this._blendConstants[3] = null, this._isAlphaBlendDirty = !0, this._isBlendFunctionParametersDirty = !1, this._isBlendEquationParametersDirty = !1, this._isBlendConstantsDirty = !1;
+  }
+  apply(t) {
+    this.isDirty && (this._isAlphaBlendDirty && (this._alphaBlend ? t.enable(t.BLEND) : t.disable(t.BLEND), this._isAlphaBlendDirty = !1), this._isBlendFunctionParametersDirty && (t.blendFuncSeparate(this._blendFunctionParameters[0], this._blendFunctionParameters[1], this._blendFunctionParameters[2], this._blendFunctionParameters[3]), this._isBlendFunctionParametersDirty = !1), this._isBlendEquationParametersDirty && (t.blendEquationSeparate(this._blendEquationParameters[0], this._blendEquationParameters[1]), this._isBlendEquationParametersDirty = !1), this._isBlendConstantsDirty && (t.blendColor(this._blendConstants[0], this._blendConstants[1], this._blendConstants[2], this._blendConstants[3]), this._isBlendConstantsDirty = !1));
+  }
+}
+export {
+  a as AlphaState
+};