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

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

@@ -0,0 +1,72 @@
+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 = "depthVertexShader", t = `attribute vec3 position;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<clipPlaneVertexDeclaration>
+#include<instancesDeclaration>
+uniform mat4 viewProjection;
+uniform vec2 depthValues;
+#if defined(ALPHATEST) || defined(NEED_UV)
+varying vec2 vUV;
+uniform mat4 diffuseMatrix;
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#endif
+#ifdef STORE_CAMERASPACE_Z
+uniform mat4 view;
+varying vec4 vViewPos;
+#endif
+varying float vDepthMetric;
+#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);
+#include<clipPlaneVertex>
+gl_Position=viewProjection*worldPos;
+#ifdef STORE_CAMERASPACE_Z
+vViewPos=view*worldPos;
+#else
+#ifdef USE_REVERSE_DEPTHBUFFER
+vDepthMetric=((-gl_Position.z+depthValues.x)/(depthValues.y));
+#else
+vDepthMetric=((gl_Position.z+depthValues.x)/(depthValues.y));
+#endif
+#endif
+#if defined(ALPHATEST) || defined(BASIC_RENDER)
+#ifdef UV1
+vUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef UV2
+vUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+#endif
+#endif
+}
+`;
+e.ShadersStore[i] = t;

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

@@ -0,0 +1,137 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "depthOfFieldPixelShader", t = `uniform sampler2D textureSampler;
+uniform sampler2D highlightsSampler;
+uniform sampler2D depthSampler;
+uniform sampler2D grainSampler;
+uniform float grain_amount;
+uniform bool blur_noise;
+uniform float screen_width;
+uniform float screen_height;
+uniform float distortion;
+uniform bool dof_enabled;
+uniform float screen_distance; 
+uniform float aperture;
+uniform float darken;
+uniform float edge_blur;
+uniform bool highlights;
+uniform float near;
+uniform float far;
+varying vec2 vUV;
+#define PI 3.14159265
+#define TWOPI 6.28318530
+#define inverse_focal_length 0.1 
+vec2 centered_screen_pos;
+vec2 distorted_coords;
+float radius2;
+float radius;
+vec2 rand(vec2 co)
+{
+float noise1=(fract(sin(dot(co,vec2(12.9898,78.233)))*43758.5453));
+float noise2=(fract(sin(dot(co,vec2(12.9898,78.233)*2.0))*43758.5453));
+return clamp(vec2(noise1,noise2),0.0,1.0);
+}
+vec2 getDistortedCoords(vec2 coords) {
+if (distortion==0.0) { return coords; }
+vec2 direction=1.0*normalize(centered_screen_pos);
+vec2 dist_coords=vec2(0.5,0.5);
+dist_coords.x=0.5+direction.x*radius2*1.0;
+dist_coords.y=0.5+direction.y*radius2*1.0;
+float dist_amount=clamp(distortion*0.23,0.0,1.0);
+dist_coords=mix(coords,dist_coords,dist_amount);
+return dist_coords;
+}
+float sampleScreen(inout vec4 color,in vec2 offset,in float weight) {
+vec2 coords=distorted_coords;
+float angle=rand(coords*100.0).x*TWOPI;
+coords+=vec2(offset.x*cos(angle)-offset.y*sin(angle),offset.x*sin(angle)+offset.y*cos(angle));
+color+=texture2D(textureSampler,coords)*weight;
+return weight;
+}
+float getBlurLevel(float size) {
+return min(3.0,ceil(size/1.0));
+}
+vec4 getBlurColor(float size) {
+vec4 col=texture2D(textureSampler,distorted_coords);
+float blur_level=getBlurLevel(size);
+float w=(size/screen_width);
+float h=(size/screen_height);
+float total_weight=1.0;
+vec2 sample_coords;
+total_weight+=sampleScreen(col,vec2(-0.50*w,0.24*h),0.93);
+total_weight+=sampleScreen(col,vec2(0.30*w,-0.75*h),0.90);
+total_weight+=sampleScreen(col,vec2(0.36*w,0.96*h),0.87);
+total_weight+=sampleScreen(col,vec2(-1.08*w,-0.55*h),0.85);
+total_weight+=sampleScreen(col,vec2(1.33*w,-0.37*h),0.83);
+total_weight+=sampleScreen(col,vec2(-0.82*w,1.31*h),0.80);
+total_weight+=sampleScreen(col,vec2(-0.31*w,-1.67*h),0.78);
+total_weight+=sampleScreen(col,vec2(1.47*w,1.11*h),0.76);
+total_weight+=sampleScreen(col,vec2(-1.97*w,0.19*h),0.74);
+total_weight+=sampleScreen(col,vec2(1.42*w,-1.57*h),0.72);
+if (blur_level>1.0) {
+total_weight+=sampleScreen(col,vec2(0.01*w,2.25*h),0.70);
+total_weight+=sampleScreen(col,vec2(-1.62*w,-1.74*h),0.67);
+total_weight+=sampleScreen(col,vec2(2.49*w,0.20*h),0.65);
+total_weight+=sampleScreen(col,vec2(-2.07*w,1.61*h),0.63);
+total_weight+=sampleScreen(col,vec2(0.46*w,-2.70*h),0.61);
+total_weight+=sampleScreen(col,vec2(1.55*w,2.40*h),0.59);
+total_weight+=sampleScreen(col,vec2(-2.88*w,-0.75*h),0.56);
+total_weight+=sampleScreen(col,vec2(2.73*w,-1.44*h),0.54);
+total_weight+=sampleScreen(col,vec2(-1.08*w,3.02*h),0.52);
+total_weight+=sampleScreen(col,vec2(-1.28*w,-3.05*h),0.49);
+}
+if (blur_level>2.0) {
+total_weight+=sampleScreen(col,vec2(3.11*w,1.43*h),0.46);
+total_weight+=sampleScreen(col,vec2(-3.36*w,1.08*h),0.44);
+total_weight+=sampleScreen(col,vec2(1.80*w,-3.16*h),0.41);
+total_weight+=sampleScreen(col,vec2(0.83*w,3.65*h),0.38);
+total_weight+=sampleScreen(col,vec2(-3.16*w,-2.19*h),0.34);
+total_weight+=sampleScreen(col,vec2(3.92*w,-0.53*h),0.31);
+total_weight+=sampleScreen(col,vec2(-2.59*w,3.12*h),0.26);
+total_weight+=sampleScreen(col,vec2(-0.20*w,-4.15*h),0.22);
+total_weight+=sampleScreen(col,vec2(3.02*w,3.00*h),0.15);
+}
+col/=total_weight; 
+if (darken>0.0) {
+col.rgb*=clamp(0.3,1.0,1.05-size*0.5*darken);
+}
+return col;
+}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+centered_screen_pos=vec2(vUV.x-0.5,vUV.y-0.5);
+radius2=centered_screen_pos.x*centered_screen_pos.x+centered_screen_pos.y*centered_screen_pos.y;
+radius=sqrt(radius2);
+distorted_coords=getDistortedCoords(vUV); 
+vec2 texels_coords=vec2(vUV.x*screen_width,vUV.y*screen_height); 
+float depth=texture2D(depthSampler,distorted_coords).r; 
+float distance=near+(far-near)*depth; 
+vec4 color=texture2D(textureSampler,vUV); 
+float coc=abs(aperture*(screen_distance*(inverse_focal_length-1.0/distance)-1.0));
+if (dof_enabled==false || coc<0.07) { coc=0.0; }
+float edge_blur_amount=0.0;
+if (edge_blur>0.0) {
+edge_blur_amount=clamp((radius*2.0-1.0+0.15*edge_blur)*1.5,0.0,1.0)*1.3;
+}
+float blur_amount=max(edge_blur_amount,coc);
+if (blur_amount==0.0) {
+gl_FragColor=texture2D(textureSampler,distorted_coords);
+}
+else {
+gl_FragColor=getBlurColor(blur_amount*1.7);
+if (highlights) {
+gl_FragColor.rgb+=clamp(coc,0.0,1.0)*texture2D(highlightsSampler,distorted_coords).rgb;
+}
+if (blur_noise) {
+vec2 noise=rand(distorted_coords)*0.01*blur_amount;
+vec2 blurred_coord=vec2(distorted_coords.x+noise.x,distorted_coords.y+noise.y);
+gl_FragColor=0.04*texture2D(textureSampler,blurred_coord)+0.96*gl_FragColor;
+}
+}
+if (grain_amount>0.0) {
+vec4 grain_color=texture2D(grainSampler,texels_coords*0.003);
+gl_FragColor.rgb+=(-0.5+grain_color.rgb)*0.30*grain_amount;
+}
+}
+`;
+e.ShadersStore[o] = t;

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

@@ -0,0 +1,54 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const r = "depthOfFieldMergePixelShader", l = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)
+#else
+#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)
+#endif
+uniform sampler2D textureSampler;
+varying vec2 vUV;
+uniform sampler2D circleOfConfusionSampler;
+uniform sampler2D blurStep0;
+#if BLUR_LEVEL>0
+uniform sampler2D blurStep1;
+#endif
+#if BLUR_LEVEL>1
+uniform sampler2D blurStep2;
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+float coc=TEXTUREFUNC(circleOfConfusionSampler,vUV,0.0).r;
+#if BLUR_LEVEL==0
+vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);
+vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);
+gl_FragColor=mix(original,blurred0,coc);
+#endif
+#if BLUR_LEVEL==1
+if(coc<0.5){
+vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);
+vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);
+gl_FragColor=mix(original,blurred1,coc/0.5);
+}else{
+vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);
+vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);
+gl_FragColor=mix(blurred1,blurred0,(coc-0.5)/0.5);
+}
+#endif
+#if BLUR_LEVEL==2
+if(coc<0.33){
+vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);
+vec4 blurred2=TEXTUREFUNC(blurStep2,vUV,0.0);
+gl_FragColor=mix(original,blurred2,coc/0.33);
+}else if(coc<0.66){
+vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);
+vec4 blurred2=TEXTUREFUNC(blurStep2,vUV,0.0);
+gl_FragColor=mix(blurred2,blurred1,(coc-0.33)/0.33);
+}else{
+vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);
+vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);
+gl_FragColor=mix(blurred1,blurred0,(coc-0.66)/0.34);
+}
+#endif
+}
+`;
+e.ShadersStore[r] = l;

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

@@ -0,0 +1,15 @@
+import { ShaderStore as r } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+const e = "extractHighlightsPixelShader", o = `#include<helperFunctions>
+varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform float threshold;
+uniform float exposure;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{
+gl_FragColor=texture2D(textureSampler,vUV);
+float luma=dot(LuminanceEncodeApprox,gl_FragColor.rgb*exposure);
+gl_FragColor.rgb=step(threshold,luma)*gl_FragColor.rgb;
+}`;
+r.ShadersStore[e] = o;

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

@@ -0,0 +1,211 @@
+import { ShaderStore as a } from "../Engines/shaderStore.esm.js";
+const e = "fxaaPixelShader", o = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+#define TEXTUREFUNC(s,c,l) texture2DLodEXT(s,c,l)
+#else
+#define TEXTUREFUNC(s,c,b) texture2D(s,c,b)
+#endif
+uniform sampler2D textureSampler;
+uniform vec2 texelSize;
+varying vec2 vUV;
+varying vec2 sampleCoordS;
+varying vec2 sampleCoordE;
+varying vec2 sampleCoordN;
+varying vec2 sampleCoordW;
+varying vec2 sampleCoordNW;
+varying vec2 sampleCoordSE;
+varying vec2 sampleCoordNE;
+varying vec2 sampleCoordSW;
+const float fxaaQualitySubpix=1.0;
+const float fxaaQualityEdgeThreshold=0.166;
+const float fxaaQualityEdgeThresholdMin=0.0833;
+const vec3 kLumaCoefficients=vec3(0.2126,0.7152,0.0722);
+#define FxaaLuma(rgba) dot(rgba.rgb,kLumaCoefficients)
+void main(){
+vec2 posM;
+posM.x=vUV.x;
+posM.y=vUV.y;
+vec4 rgbyM=TEXTUREFUNC(textureSampler,vUV,0.0);
+float lumaM=FxaaLuma(rgbyM);
+float lumaS=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordS,0.0));
+float lumaE=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordE,0.0));
+float lumaN=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordN,0.0));
+float lumaW=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordW,0.0));
+float maxSM=max(lumaS,lumaM);
+float minSM=min(lumaS,lumaM);
+float maxESM=max(lumaE,maxSM);
+float minESM=min(lumaE,minSM);
+float maxWN=max(lumaN,lumaW);
+float minWN=min(lumaN,lumaW);
+float rangeMax=max(maxWN,maxESM);
+float rangeMin=min(minWN,minESM);
+float rangeMaxScaled=rangeMax*fxaaQualityEdgeThreshold;
+float range=rangeMax-rangeMin;
+float rangeMaxClamped=max(fxaaQualityEdgeThresholdMin,rangeMaxScaled);
+#ifndef MALI
+if(range<rangeMaxClamped) 
+{
+gl_FragColor=rgbyM;
+return;
+}
+#endif
+float lumaNW=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordNW,0.0));
+float lumaSE=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordSE,0.0));
+float lumaNE=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordNE,0.0));
+float lumaSW=FxaaLuma(TEXTUREFUNC(textureSampler,sampleCoordSW,0.0));
+float lumaNS=lumaN+lumaS;
+float lumaWE=lumaW+lumaE;
+float subpixRcpRange=1.0/range;
+float subpixNSWE=lumaNS+lumaWE;
+float edgeHorz1=(-2.0*lumaM)+lumaNS;
+float edgeVert1=(-2.0*lumaM)+lumaWE;
+float lumaNESE=lumaNE+lumaSE;
+float lumaNWNE=lumaNW+lumaNE;
+float edgeHorz2=(-2.0*lumaE)+lumaNESE;
+float edgeVert2=(-2.0*lumaN)+lumaNWNE;
+float lumaNWSW=lumaNW+lumaSW;
+float lumaSWSE=lumaSW+lumaSE;
+float edgeHorz4=(abs(edgeHorz1)*2.0)+abs(edgeHorz2);
+float edgeVert4=(abs(edgeVert1)*2.0)+abs(edgeVert2);
+float edgeHorz3=(-2.0*lumaW)+lumaNWSW;
+float edgeVert3=(-2.0*lumaS)+lumaSWSE;
+float edgeHorz=abs(edgeHorz3)+edgeHorz4;
+float edgeVert=abs(edgeVert3)+edgeVert4;
+float subpixNWSWNESE=lumaNWSW+lumaNESE;
+float lengthSign=texelSize.x;
+bool horzSpan=edgeHorz>=edgeVert;
+float subpixA=subpixNSWE*2.0+subpixNWSWNESE;
+if (!horzSpan)
+{
+lumaN=lumaW;
+}
+if (!horzSpan) 
+{
+lumaS=lumaE;
+}
+if (horzSpan) 
+{
+lengthSign=texelSize.y;
+}
+float subpixB=(subpixA*(1.0/12.0))-lumaM;
+float gradientN=lumaN-lumaM;
+float gradientS=lumaS-lumaM;
+float lumaNN=lumaN+lumaM;
+float lumaSS=lumaS+lumaM;
+bool pairN=abs(gradientN)>=abs(gradientS);
+float gradient=max(abs(gradientN),abs(gradientS));
+if (pairN)
+{
+lengthSign=-lengthSign;
+}
+float subpixC=clamp(abs(subpixB)*subpixRcpRange,0.0,1.0);
+vec2 posB;
+posB.x=posM.x;
+posB.y=posM.y;
+vec2 offNP;
+offNP.x=(!horzSpan) ? 0.0 : texelSize.x;
+offNP.y=(horzSpan) ? 0.0 : texelSize.y;
+if (!horzSpan) 
+{
+posB.x+=lengthSign*0.5;
+}
+if (horzSpan)
+{
+posB.y+=lengthSign*0.5;
+}
+vec2 posN;
+posN.x=posB.x-offNP.x*1.5;
+posN.y=posB.y-offNP.y*1.5;
+vec2 posP;
+posP.x=posB.x+offNP.x*1.5;
+posP.y=posB.y+offNP.y*1.5;
+float subpixD=((-2.0)*subpixC)+3.0;
+float lumaEndN=FxaaLuma(TEXTUREFUNC(textureSampler,posN,0.0));
+float subpixE=subpixC*subpixC;
+float lumaEndP=FxaaLuma(TEXTUREFUNC(textureSampler,posP,0.0));
+if (!pairN) 
+{
+lumaNN=lumaSS;
+}
+float gradientScaled=gradient*1.0/4.0;
+float lumaMM=lumaM-lumaNN*0.5;
+float subpixF=subpixD*subpixE;
+bool lumaMLTZero=lumaMM<0.0;
+lumaEndN-=lumaNN*0.5;
+lumaEndP-=lumaNN*0.5;
+bool doneN=abs(lumaEndN)>=gradientScaled;
+bool doneP=abs(lumaEndP)>=gradientScaled;
+if (!doneN) 
+{
+posN.x-=offNP.x*3.0;
+}
+if (!doneN) 
+{
+posN.y-=offNP.y*3.0;
+}
+bool doneNP=(!doneN) || (!doneP);
+if (!doneP) 
+{
+posP.x+=offNP.x*3.0;
+}
+if (!doneP)
+{
+posP.y+=offNP.y*3.0;
+}
+if (doneNP)
+{
+if (!doneN) lumaEndN=FxaaLuma(TEXTUREFUNC(textureSampler,posN.xy,0.0));
+if (!doneP) lumaEndP=FxaaLuma(TEXTUREFUNC(textureSampler,posP.xy,0.0));
+if (!doneN) lumaEndN=lumaEndN-lumaNN*0.5;
+if (!doneP) lumaEndP=lumaEndP-lumaNN*0.5;
+doneN=abs(lumaEndN)>=gradientScaled;
+doneP=abs(lumaEndP)>=gradientScaled;
+if (!doneN) posN.x-=offNP.x*12.0;
+if (!doneN) posN.y-=offNP.y*12.0;
+doneNP=(!doneN) || (!doneP);
+if (!doneP) posP.x+=offNP.x*12.0;
+if (!doneP) posP.y+=offNP.y*12.0;
+}
+float dstN=posM.x-posN.x;
+float dstP=posP.x-posM.x;
+if (!horzSpan)
+{
+dstN=posM.y-posN.y;
+}
+if (!horzSpan) 
+{
+dstP=posP.y-posM.y;
+}
+bool goodSpanN=(lumaEndN<0.0) != lumaMLTZero;
+float spanLength=(dstP+dstN);
+bool goodSpanP=(lumaEndP<0.0) != lumaMLTZero;
+float spanLengthRcp=1.0/spanLength;
+bool directionN=dstN<dstP;
+float dst=min(dstN,dstP);
+bool goodSpan=directionN ? goodSpanN : goodSpanP;
+float subpixG=subpixF*subpixF;
+float pixelOffset=(dst*(-spanLengthRcp))+0.5;
+float subpixH=subpixG*fxaaQualitySubpix;
+float pixelOffsetGood=goodSpan ? pixelOffset : 0.0;
+float pixelOffsetSubpix=max(pixelOffsetGood,subpixH);
+if (!horzSpan)
+{
+posM.x+=pixelOffsetSubpix*lengthSign;
+}
+if (horzSpan)
+{
+posM.y+=pixelOffsetSubpix*lengthSign;
+}
+#ifdef MALI
+if(range<rangeMaxClamped) 
+{
+gl_FragColor=rgbyM;
+}
+else
+{
+gl_FragColor=TEXTUREFUNC(textureSampler,posM,0.0);
+}
+#else
+gl_FragColor=TEXTUREFUNC(textureSampler,posM,0.0);
+#endif
+}`;
+a.ShadersStore[e] = o;

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

@@ -0,0 +1,29 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "fxaaVertexShader", v = `attribute vec2 position;
+uniform vec2 texelSize;
+varying vec2 vUV;
+varying vec2 sampleCoordS;
+varying vec2 sampleCoordE;
+varying vec2 sampleCoordN;
+varying vec2 sampleCoordW;
+varying vec2 sampleCoordNW;
+varying vec2 sampleCoordSE;
+varying vec2 sampleCoordNE;
+varying vec2 sampleCoordSW;
+const vec2 madd=vec2(0.5,0.5);
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vUV=(position*madd+madd);
+sampleCoordS=vUV+vec2( 0.0,1.0)*texelSize;
+sampleCoordE=vUV+vec2( 1.0,0.0)*texelSize;
+sampleCoordN=vUV+vec2( 0.0,-1.0)*texelSize;
+sampleCoordW=vUV+vec2(-1.0,0.0)*texelSize;
+sampleCoordNW=vUV+vec2(-1.0,-1.0)*texelSize;
+sampleCoordSE=vUV+vec2( 1.0,1.0)*texelSize;
+sampleCoordNE=vUV+vec2( 1.0,-1.0)*texelSize;
+sampleCoordSW=vUV+vec2(-1.0,1.0)*texelSize;
+gl_Position=vec4(position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+e.ShadersStore[o] = v;

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

@@ -0,0 +1,147 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/clipPlaneFragmentDeclaration.esm.js";
+import "./ShadersInclude/mrtFragmentDeclaration.esm.js";
+import "./ShadersInclude/bumpFragmentMainFunctions.esm.js";
+import "./ShadersInclude/bumpFragmentFunctions.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/clipPlaneFragment.esm.js";
+import "./ShadersInclude/bumpFragment.esm.js";
+const i = "geometryPixelShader", f = `#extension GL_EXT_draw_buffers : require
+#if defined(BUMP) || !defined(NORMAL)
+#extension GL_OES_standard_derivatives : enable
+#endif
+precision highp float;
+#ifdef BUMP
+varying mat4 vWorldView;
+varying vec3 vNormalW;
+#else
+varying vec3 vNormalV;
+#endif
+varying vec4 vViewPos;
+#if defined(POSITION) || defined(BUMP)
+varying vec3 vPositionW;
+#endif
+#ifdef VELOCITY
+varying vec4 vCurrentPosition;
+varying vec4 vPreviousPosition;
+#endif
+#ifdef NEED_UV
+varying vec2 vUV;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;
+uniform vec2 vTangentSpaceParams;
+#endif
+#if defined(REFLECTIVITY)
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+uniform sampler2D reflectivitySampler;
+varying vec2 vReflectivityUV;
+#endif
+#ifdef ALBEDOTEXTURE
+varying vec2 vAlbedoUV;
+uniform sampler2D albedoSampler;
+#endif
+#ifdef REFLECTIVITYCOLOR
+uniform vec3 reflectivityColor;
+#endif
+#ifdef ALBEDOCOLOR
+uniform vec3 albedoColor;
+#endif
+#ifdef METALLIC
+uniform float metallic;
+#endif
+#if defined(ROUGHNESS) || defined(GLOSSINESS)
+uniform float glossiness;
+#endif
+#endif
+#if defined(ALPHATEST) && defined(NEED_UV)
+uniform sampler2D diffuseSampler;
+#endif
+#include<clipPlaneFragmentDeclaration>
+#include<mrtFragmentDeclaration>[RENDER_TARGET_COUNT]
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<helperFunctions>
+void main() {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (texture2D(diffuseSampler,vUV).a<0.4)
+discard;
+#endif
+vec3 normalOutput;
+#ifdef BUMP
+vec3 normalW=normalize(vNormalW);
+#include<bumpFragment>
+normalOutput=normalize(vec3(vWorldView*vec4(normalW,0.0)));
+#else
+normalOutput=normalize(vNormalV);
+#endif
+#ifdef PREPASS
+#ifdef PREPASS_DEPTH
+gl_FragData[DEPTH_INDEX]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);
+#endif
+#ifdef PREPASS_NORMAL
+gl_FragData[NORMAL_INDEX]=vec4(normalOutput,1.0);
+#endif
+#else
+gl_FragData[0]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);
+gl_FragData[1]=vec4(normalOutput,1.0);
+#endif
+#ifdef POSITION
+gl_FragData[POSITION_INDEX]=vec4(vPositionW,1.0);
+#endif
+#ifdef VELOCITY
+vec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;
+vec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;
+vec2 velocity=abs(a-b);
+velocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;
+gl_FragData[VELOCITY_INDEX]=vec4(velocity,0.0,1.0);
+#endif
+#ifdef REFLECTIVITY
+vec4 reflectivity=vec4(0.0,0.0,0.0,1.0);
+#ifdef METALLICWORKFLOW
+float metal=1.0;
+float roughness=1.0;
+#ifdef ORMTEXTURE
+metal*=texture2D(reflectivitySampler,vReflectivityUV).b;
+roughness*=texture2D(reflectivitySampler,vReflectivityUV).g;
+#endif
+#ifdef METALLIC
+metal*=metallic;
+#endif
+#ifdef ROUGHNESS
+roughness*=(1.0-glossiness); 
+#endif
+reflectivity.a-=roughness;
+vec3 color=vec3(1.0);
+#ifdef ALBEDOTEXTURE
+color=texture2D(albedoSampler,vAlbedoUV).rgb;
+#ifdef GAMMAALBEDO
+color=toLinearSpace(color);
+#endif
+#endif
+#ifdef ALBEDOCOLOR
+color*=albedoColor.xyz;
+#endif
+reflectivity.rgb=mix(vec3(0.04),color,metal);
+#else
+#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+reflectivity=texture2D(reflectivitySampler,vReflectivityUV);
+#ifdef GAMMAREFLECTIVITYTEXTURE
+reflectivity.rgb=toLinearSpace(reflectivity.rgb);
+#endif
+#else 
+#ifdef REFLECTIVITYCOLOR
+reflectivity.rgb=toLinearSpace(reflectivityColor.xyz);
+reflectivity.a=1.0;
+#endif
+#endif
+#ifdef GLOSSINESSS
+reflectivity.a*=glossiness; 
+#endif
+#endif
+gl_FragData[REFLECTIVITY_INDEX]=reflectivity;
+#endif
+}
+`;
+e.ShadersStore[i] = f;