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

package/dist/node_modules/@babylonjs/core/Shaders/geometry.vertex.esm.js

@@ -0,0 +1,164 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/bonesDeclaration.esm.js";
+import "./ShadersInclude/bakedVertexAnimationDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexGlobalDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexDeclaration.esm.js";
+import "./ShadersInclude/instancesDeclaration.esm.js";
+import "./ShadersInclude/geometryVertexDeclaration.esm.js";
+import "./ShadersInclude/geometryUboDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneVertexDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexGlobal.esm.js";
+import "./ShadersInclude/morphTargetsVertex.esm.js";
+import "./ShadersInclude/instancesVertex.esm.js";
+import "./ShadersInclude/bonesVertex.esm.js";
+import "./ShadersInclude/bakedVertexAnimation.esm.js";
+import "./ShadersInclude/clipPlaneVertex.esm.js";
+import "./ShadersInclude/bumpVertex.esm.js";
+const i = "geometryVertexShader", n = `precision highp float;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<instancesDeclaration>
+#include<__decl__geometryVertex>
+#include<clipPlaneVertexDeclaration>
+attribute vec3 position;
+attribute vec3 normal;
+#ifdef NEED_UV
+varying vec2 vUV;
+#ifdef ALPHATEST
+uniform mat4 diffuseMatrix;
+#endif
+#ifdef BUMP
+uniform mat4 bumpMatrix;
+varying vec2 vBumpUV;
+#endif
+#ifdef REFLECTIVITY
+uniform mat4 reflectivityMatrix;
+uniform mat4 albedoMatrix;
+varying vec2 vReflectivityUV;
+varying vec2 vAlbedoUV;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#endif
+#ifdef BUMP
+varying mat4 vWorldView;
+#endif
+#ifdef BUMP
+varying vec3 vNormalW;
+#else
+varying vec3 vNormalV;
+#endif
+varying vec4 vViewPos;
+#if defined(POSITION) || defined(BUMP)
+varying vec3 vPositionW;
+#endif
+#ifdef VELOCITY
+uniform mat4 previousViewProjection;
+varying vec4 vCurrentPosition;
+varying vec4 vPreviousPosition;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void)
+{
+vec3 positionUpdated=position;
+vec3 normalUpdated=normal;
+#ifdef UV1
+vec2 uvUpdated=uv;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#if defined(VELOCITY) && !defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+vec4 worldPos=vec4(finalWorld*vec4(positionUpdated,1.0));
+#ifdef BUMP
+vWorldView=view*finalWorld;
+vNormalW=normalUpdated;
+#else
+vNormalV=normalize(vec3((view*finalWorld)*vec4(normalUpdated,0.0)));
+#endif
+vViewPos=view*worldPos;
+#if defined(VELOCITY) && defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#if NUM_BONE_INFLUENCERS>0
+mat4 previousInfluence;
+previousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+vPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);
+#else
+vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#endif
+#if defined(POSITION) || defined(BUMP)
+vPositionW=worldPos.xyz/worldPos.w;
+#endif
+gl_Position=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#include<clipPlaneVertex>
+#ifdef NEED_UV
+#ifdef UV1
+#if defined(ALPHATEST) && defined(ALPHATEST_UV1)
+vUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
+#else
+vUV=uv;
+#endif
+#ifdef BUMP_UV1
+vBumpUV=vec2(bumpMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV1
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef ALBEDO_UV1
+vAlbedoUV=vec2(albedoMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#endif
+#ifdef UV2
+#if defined(ALPHATEST) && defined(ALPHATEST_UV2)
+vUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+#else
+vUV=uv2;
+#endif
+#ifdef BUMP_UV2
+vBumpUV=vec2(bumpMatrix*vec4(uv2,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV2
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uv2,1.0,0.0));
+#endif
+#ifdef ALBEDO_UV2
+vAlbedoUV=vec2(albedoMatrix*vec4(uv2,1.0,0.0));
+#endif
+#endif
+#endif
+#include<bumpVertex>
+}
+`;
+e.ShadersStore[i] = n;

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

@@ -0,0 +1,39 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const t = "glowBlurPostProcessPixelShader", r = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform vec2 screenSize;
+uniform vec2 direction;
+uniform float blurWidth;
+float getLuminance(vec3 color)
+{
+return dot(color,vec3(0.2126,0.7152,0.0722));
+}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+float weights[7];
+weights[0]=0.05;
+weights[1]=0.1;
+weights[2]=0.2;
+weights[3]=0.3;
+weights[4]=0.2;
+weights[5]=0.1;
+weights[6]=0.05;
+vec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);
+vec2 texelStep=texelSize*direction*blurWidth;
+vec2 start=vUV-3.0*texelStep;
+vec4 baseColor=vec4(0.,0.,0.,0.);
+vec2 texelOffset=vec2(0.,0.);
+for (int i=0; i<7; i++)
+{
+vec4 texel=texture2D(textureSampler,start+texelOffset);
+baseColor.a+=texel.a*weights[i];
+float luminance=getLuminance(baseColor.rgb);
+float luminanceTexel=getLuminance(texel.rgb);
+float choice=step(luminanceTexel,luminance);
+baseColor.rgb=choice*baseColor.rgb+(1.0-choice)*texel.rgb;
+texelOffset+=texelStep;
+}
+gl_FragColor=baseColor;
+}`;
+e.ShadersStore[t] = r;

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

@@ -0,0 +1,73 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/clipPlaneFragmentDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneFragment.esm.js";
+const i = "glowMapGenerationPixelShader", a = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)
+#include<helperFunctions>
+#endif
+#ifdef DIFFUSE
+varying vec2 vUVDiffuse;
+uniform sampler2D diffuseSampler;
+#endif
+#ifdef OPACITY
+varying vec2 vUVOpacity;
+uniform sampler2D opacitySampler;
+uniform float opacityIntensity;
+#endif
+#ifdef EMISSIVE
+varying vec2 vUVEmissive;
+uniform sampler2D emissiveSampler;
+#endif
+#ifdef VERTEXALPHA
+varying vec4 vColor;
+#endif
+uniform vec4 glowColor;
+uniform float glowIntensity;
+#include<clipPlaneFragmentDeclaration>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+#include<clipPlaneFragment>
+vec4 finalColor=glowColor;
+#ifdef DIFFUSE
+vec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);
+#ifdef DIFFUSE_ISLINEAR
+albedoTexture=toGammaSpace(albedoTexture);
+#endif
+#ifdef GLOW
+finalColor.a*=albedoTexture.a;
+#endif
+#ifdef HIGHLIGHT
+finalColor.a=albedoTexture.a;
+#endif
+#endif
+#ifdef OPACITY
+vec4 opacityMap=texture2D(opacitySampler,vUVOpacity);
+#ifdef OPACITYRGB
+finalColor.a*=getLuminance(opacityMap.rgb);
+#else
+finalColor.a*=opacityMap.a;
+#endif
+finalColor.a*=opacityIntensity;
+#endif
+#ifdef VERTEXALPHA
+finalColor.a*=vColor.a;
+#endif
+#ifdef ALPHATEST
+if (finalColor.a<ALPHATESTVALUE)
+discard;
+#endif
+#ifdef EMISSIVE
+vec4 emissive=texture2D(emissiveSampler,vUVEmissive);
+#ifdef EMISSIVE_ISLINEAR
+emissive=toGammaSpace(emissive);
+#endif
+gl_FragColor=emissive*finalColor*glowIntensity;
+#else
+gl_FragColor=finalColor*glowIntensity;
+#endif
+#ifdef HIGHLIGHT
+gl_FragColor.a=glowColor.a;
+#endif
+}`;
+e.ShadersStore[i] = a;

package/dist/node_modules/@babylonjs/core/Shaders/glowMapGeneration.vertex.esm.js

@@ -0,0 +1,94 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/bonesDeclaration.esm.js";
+import "./ShadersInclude/bakedVertexAnimationDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexGlobalDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneVertexDeclaration.esm.js";
+import "./ShadersInclude/instancesDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexGlobal.esm.js";
+import "./ShadersInclude/morphTargetsVertex.esm.js";
+import "./ShadersInclude/instancesVertex.esm.js";
+import "./ShadersInclude/bonesVertex.esm.js";
+import "./ShadersInclude/bakedVertexAnimation.esm.js";
+import "./ShadersInclude/clipPlaneVertex.esm.js";
+const i = "glowMapGenerationVertexShader", t = `attribute vec3 position;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<clipPlaneVertexDeclaration>
+#include<instancesDeclaration>
+uniform mat4 viewProjection;
+varying vec4 vPosition;
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef DIFFUSE
+varying vec2 vUVDiffuse;
+uniform mat4 diffuseMatrix;
+#endif
+#ifdef OPACITY
+varying vec2 vUVOpacity;
+uniform mat4 opacityMatrix;
+#endif
+#ifdef EMISSIVE
+varying vec2 vUVEmissive;
+uniform mat4 emissiveMatrix;
+#endif
+#ifdef VERTEXALPHA
+attribute vec4 color;
+varying vec4 vColor;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void)
+{
+vec3 positionUpdated=position;
+#ifdef UV1
+vec2 uvUpdated=uv;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+vec4 worldPos=finalWorld*vec4(positionUpdated,1.0);
+#ifdef CUBEMAP
+vPosition=worldPos;
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+#else
+vPosition=viewProjection*worldPos;
+gl_Position=vPosition;
+#endif
+#ifdef DIFFUSE
+#ifdef DIFFUSEUV1
+vUVDiffuse=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef DIFFUSEUV2
+vUVDiffuse=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+#endif
+#endif
+#ifdef OPACITY
+#ifdef OPACITYUV1
+vUVOpacity=vec2(opacityMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef OPACITYUV2
+vUVOpacity=vec2(opacityMatrix*vec4(uv2,1.0,0.0));
+#endif
+#endif
+#ifdef EMISSIVE
+#ifdef EMISSIVEUV1
+vUVEmissive=vec2(emissiveMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef EMISSIVEUV2
+vUVEmissive=vec2(emissiveMatrix*vec4(uv2,1.0,0.0));
+#endif
+#endif
+#ifdef VERTEXALPHA
+vColor=color;
+#endif
+#include<clipPlaneVertex>
+}`;
+e.ShadersStore[i] = t;

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

@@ -0,0 +1,29 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "glowMapMergePixelShader", a = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+#ifdef EMISSIVE
+uniform sampler2D textureSampler2;
+#endif
+uniform float offset;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+vec4 baseColor=texture2D(textureSampler,vUV);
+#ifdef EMISSIVE
+baseColor+=texture2D(textureSampler2,vUV);
+baseColor*=offset;
+#else
+baseColor.a=abs(offset-baseColor.a);
+#ifdef STROKE
+float alpha=smoothstep(.0,.1,baseColor.a);
+baseColor.a=alpha;
+baseColor.rgb=baseColor.rgb*alpha;
+#endif
+#endif
+#if LDR
+baseColor=clamp(baseColor,0.,1.0);
+#endif
+gl_FragColor=baseColor;
+#define CUSTOM_FRAGMENT_MAIN_END
+}`;
+e.ShadersStore[o] = a;

package/dist/node_modules/@babylonjs/core/Shaders/glowMapMerge.vertex.esm.js

@@ -0,0 +1,12 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "glowMapMergeVertexShader", i = `attribute vec2 position;
+varying vec2 vUV;
+const vec2 madd=vec2(0.5,0.5);
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vUV=position*madd+madd;
+gl_Position=vec4(position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+e.ShadersStore[o] = i;

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

@@ -0,0 +1,19 @@
+import { ShaderStore as r } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+const e = "grainPixelShader", a = `#include<helperFunctions>
+uniform sampler2D textureSampler; 
+uniform float intensity;
+uniform float animatedSeed;
+varying vec2 vUV;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+gl_FragColor=texture2D(textureSampler,vUV);
+vec2 seed=vUV*(animatedSeed);
+float grain=dither(seed,intensity);
+float lum=getLuminance(gl_FragColor.rgb);
+float grainAmount=(cos(-PI+(lum*PI*2.))+1.)/2.;
+gl_FragColor.rgb+=grain*grainAmount;
+gl_FragColor.rgb=max(gl_FragColor.rgb,0.0);
+}`;
+r.ShadersStore[e] = a;

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

@@ -0,0 +1,19 @@
+import { ShaderStore as r } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/importanceSampling.esm.js";
+import "./ShadersInclude/pbrBRDFFunctions.esm.js";
+import "./ShadersInclude/hdrFilteringFunctions.esm.js";
+const i = "hdrFilteringPixelShader", e = `#include<helperFunctions>
+#include<importanceSampling>
+#include<pbrBRDFFunctions>
+#include<hdrFilteringFunctions>
+uniform float alphaG;
+uniform samplerCube inputTexture;
+uniform vec2 vFilteringInfo;
+uniform float hdrScale;
+varying vec3 direction;
+void main() {
+vec3 color=radiance(alphaG,inputTexture,direction,vFilteringInfo);
+gl_FragColor=vec4(color*hdrScale,1.0);
+}`;
+r.ShadersStore[i] = e;

package/dist/node_modules/@babylonjs/core/Shaders/hdrFiltering.vertex.esm.js

@@ -0,0 +1,15 @@
+import { ShaderStore as i } from "../Engines/shaderStore.esm.js";
+const e = "hdrFilteringVertexShader", o = `attribute vec2 position;
+varying vec3 direction;
+uniform vec3 up;
+uniform vec3 right;
+uniform vec3 front;
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+mat3 view=mat3(up,right,front);
+direction=view*vec3(position,1.0);
+gl_Position=vec4(position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+i.ShadersStore[e] = o;

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

@@ -0,0 +1,26 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/imageProcessingDeclaration.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/imageProcessingFunctions.esm.js";
+const r = "imageProcessingPixelShader", i = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+#include<imageProcessingDeclaration>
+#include<helperFunctions>
+#include<imageProcessingFunctions>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+vec4 result=texture2D(textureSampler,vUV);
+#ifdef IMAGEPROCESSING
+#ifndef FROMLINEARSPACE
+result.rgb=toLinearSpace(result.rgb);
+#endif
+result=applyImageProcessing(result);
+#else
+#ifdef FROMLINEARSPACE
+result=applyImageProcessing(result);
+#endif
+#endif
+gl_FragColor=result;
+}`;
+e.ShadersStore[r] = i;

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

@@ -0,0 +1,49 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/kernelBlurVaryingDeclaration.esm.js";
+import "./ShadersInclude/packingFunctions.esm.js";
+import "./ShadersInclude/kernelBlurFragment.esm.js";
+import "./ShadersInclude/kernelBlurFragment2.esm.js";
+const r = "kernelBlurPixelShader", n = `uniform sampler2D textureSampler;
+uniform vec2 delta;
+varying vec2 sampleCenter;
+#ifdef DOF
+uniform sampler2D circleOfConfusionSampler;
+float sampleCoC(in vec2 offset) {
+float coc=texture2D(circleOfConfusionSampler,offset).r;
+return coc; 
+}
+#endif
+#include<kernelBlurVaryingDeclaration>[0..varyingCount]
+#ifdef PACKEDFLOAT
+#include<packingFunctions>
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+float computedWeight=0.0;
+#ifdef PACKEDFLOAT
+float blend=0.;
+#else
+vec4 blend=vec4(0.);
+#endif
+#ifdef DOF
+float sumOfWeights=CENTER_WEIGHT; 
+float factor=0.0;
+#ifdef PACKEDFLOAT
+blend+=unpack(texture2D(textureSampler,sampleCenter))*CENTER_WEIGHT;
+#else
+blend+=texture2D(textureSampler,sampleCenter)*CENTER_WEIGHT;
+#endif
+#endif
+#include<kernelBlurFragment>[0..varyingCount]
+#include<kernelBlurFragment2>[0..depCount]
+#ifdef PACKEDFLOAT
+gl_FragColor=pack(blend);
+#else
+gl_FragColor=blend;
+#endif
+#ifdef DOF
+gl_FragColor/=sumOfWeights;
+#endif
+}`;
+e.ShadersStore[r] = n;

package/dist/node_modules/@babylonjs/core/Shaders/kernelBlur.vertex.esm.js

@@ -0,0 +1,17 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/kernelBlurVaryingDeclaration.esm.js";
+import "./ShadersInclude/kernelBlurVertex.esm.js";
+const n = "kernelBlurVertexShader", r = `attribute vec2 position;
+uniform vec2 delta;
+varying vec2 sampleCenter;
+#include<kernelBlurVaryingDeclaration>[0..varyingCount]
+const vec2 madd=vec2(0.5,0.5);
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+sampleCenter=(position*madd+madd);
+#include<kernelBlurVertex>[0..varyingCount]
+gl_Position=vec4(position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+e.ShadersStore[n] = r;

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

@@ -0,0 +1,115 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const r = "lensHighlightsPixelShader", t = `uniform sampler2D textureSampler; 
+uniform float gain;
+uniform float threshold;
+uniform float screen_width;
+uniform float screen_height;
+varying vec2 vUV;
+vec4 highlightColor(vec4 color) {
+vec4 highlight=color;
+float luminance=dot(highlight.rgb,vec3(0.2125,0.7154,0.0721));
+float lum_threshold;
+if (threshold>1.0) { lum_threshold=0.94+0.01*threshold; }
+else { lum_threshold=0.5+0.44*threshold; }
+luminance=clamp((luminance-lum_threshold)*(1.0/(1.0-lum_threshold)),0.0,1.0);
+highlight*=luminance*gain;
+highlight.a=1.0;
+return highlight;
+}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+vec4 original=texture2D(textureSampler,vUV);
+if (gain==-1.0) {
+gl_FragColor=vec4(0.0,0.0,0.0,1.0);
+return;
+}
+float w=2.0/screen_width;
+float h=2.0/screen_height;
+float weight=1.0;
+vec4 blurred=vec4(0.0,0.0,0.0,0.0);
+#ifdef PENTAGON
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.84*w,0.43*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.48*w,-1.29*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.61*w,1.51*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.55*w,-0.74*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.71*w,-0.52*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.94*w,1.59*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.40*w,-1.87*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.62*w,1.16*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.09*w,0.25*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.46*w,-1.71*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.08*w,2.42*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.85*w,-1.89*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.89*w,0.16*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.29*w,1.88*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.40*w,-2.81*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.54*w,2.26*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.60*w,-0.61*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.31*w,-1.30*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.83*w,2.53*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.12*w,-2.48*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.60*w,1.11*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.99*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.50*w,-2.81*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.85*w,3.33*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.94*w,-1.92*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.27*w,-0.53*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.95*w,2.48*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.23*w,-3.04*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.17*w,2.05*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.97*w,-0.04*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.25*w,-2.00*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.31*w,3.08*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.94*w,-2.59*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.37*w,0.64*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.13*w,1.93*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.03*w,-3.65*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.60*w,3.17*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.14*w,-1.19*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.00*w,-1.19*h)));
+#else
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.85*w,0.36*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.52*w,-1.14*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.46*w,1.42*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.46*w,-0.83*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.79*w,-0.42*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.11*w,1.62*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.29*w,-2.07*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.69*w,1.39*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.28*w,0.12*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.65*w,-1.69*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.08*w,2.44*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.63*w,-1.90*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.55*w,0.31*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.13*w,1.52*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.56*w,-2.61*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.38*w,2.34*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.64*w,-0.81*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.53*w,-1.21*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.06*w,2.63*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.00*w,-2.69*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.59*w,1.32*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.78*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.57*w,-2.50*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.54*w,2.93*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.39*w,-1.81*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,-0.28*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.04*w,2.25*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.02*w,-3.05*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.09*w,2.25*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.07*w,-0.25*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.44*w,-1.90*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.52*w,3.05*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.68*w,-2.61*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,0.79*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.76*w,1.46*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.05*w,-2.94*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.21*w,2.88*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.84*w,-1.30*h)));
+blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.98*w,-0.96*h)));
+#endif
+blurred/=39.0;
+gl_FragColor=blurred;
+}`;
+e.ShadersStore[r] = t;