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

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

@@ -0,0 +1,11 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/boundingBoxRendererFragmentDeclaration.esm.js";
+import "./ShadersInclude/boundingBoxRendererUboDeclaration.esm.js";
+const o = "boundingBoxRendererPixelShader", r = `#include<__decl__boundingBoxRendererFragment>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+gl_FragColor=color;
+#define CUSTOM_FRAGMENT_MAIN_END
+}`;
+e.ShadersStore[o] = r;

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

@@ -0,0 +1,22 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/boundingBoxRendererVertexDeclaration.esm.js";
+import "./ShadersInclude/boundingBoxRendererUboDeclaration.esm.js";
+const o = "boundingBoxRendererVertexShader", i = `attribute vec3 position;
+#include<__decl__boundingBoxRendererVertex>
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vec4 worldPos=world*vec4(position,1.0);
+#ifdef MULTIVIEW
+if (gl_ViewID_OVR==0u) {
+gl_Position=viewProjection*worldPos;
+} else {
+gl_Position=viewProjectionR*worldPos;
+}
+#else
+gl_Position=viewProjection*worldPos;
+#endif
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;
+e.ShadersStore[o] = i;

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

@@ -0,0 +1,34 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const r = "chromaticAberrationPixelShader", t = `uniform sampler2D textureSampler; 
+uniform float chromatic_aberration;
+uniform float radialIntensity;
+uniform vec2 direction;
+uniform vec2 centerPosition;
+uniform float screen_width;
+uniform float screen_height;
+varying vec2 vUV;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+vec2 centered_screen_pos=vec2(vUV.x-centerPosition.x,vUV.y-centerPosition.y);
+vec2 directionOfEffect=direction;
+if(directionOfEffect.x==0. && directionOfEffect.y==0.){
+directionOfEffect=normalize(centered_screen_pos);
+}
+float radius2=centered_screen_pos.x*centered_screen_pos.x
++ centered_screen_pos.y*centered_screen_pos.y;
+float radius=sqrt(radius2);
+vec4 original=texture2D(textureSampler,vUV);
+vec3 ref_indices=vec3(-0.3,0.0,0.3);
+float ref_shiftX=chromatic_aberration*pow(radius,radialIntensity)*directionOfEffect.x/screen_width;
+float ref_shiftY=chromatic_aberration*pow(radius,radialIntensity)*directionOfEffect.y/screen_height;
+vec2 ref_coords_r=vec2(vUV.x+ref_indices.r*ref_shiftX,vUV.y+ref_indices.r*ref_shiftY*0.5);
+vec2 ref_coords_g=vec2(vUV.x+ref_indices.g*ref_shiftX,vUV.y+ref_indices.g*ref_shiftY*0.5);
+vec2 ref_coords_b=vec2(vUV.x+ref_indices.b*ref_shiftX,vUV.y+ref_indices.b*ref_shiftY*0.5);
+original.r=texture2D(textureSampler,ref_coords_r).r;
+original.g=texture2D(textureSampler,ref_coords_g).g;
+original.b=texture2D(textureSampler,ref_coords_b).b;
+original.a=clamp(texture2D(textureSampler,ref_coords_r).a+texture2D(textureSampler,ref_coords_g).a+texture2D(textureSampler,ref_coords_b).a,0.,1.);
+gl_FragColor=original;
+}`;
+e.ShadersStore[r] = t;

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

@@ -0,0 +1,19 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const c = "circleOfConfusionPixelShader", a = `uniform sampler2D depthSampler;
+varying vec2 vUV;
+uniform vec2 cameraMinMaxZ;
+uniform float focusDistance;
+uniform float cocPrecalculation;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+float depth=texture2D(depthSampler,vUV).r;
+#define CUSTOM_COC_DEPTH
+float pixelDistance=(cameraMinMaxZ.x+cameraMinMaxZ.y*depth)*1000.0; 
+#define CUSTOM_COC_PIXELDISTANCE
+float coc=abs(cocPrecalculation*((focusDistance-pixelDistance)/pixelDistance));
+coc=clamp(coc,0.0,1.0);
+gl_FragColor=vec4(coc,coc,coc,1.0);
+}
+`;
+e.ShadersStore[c] = a;

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

@@ -0,0 +1,387 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/defaultFragmentDeclaration.esm.js";
+import "./ShadersInclude/defaultUboDeclaration.esm.js";
+import "./ShadersInclude/prePassDeclaration.esm.js";
+import "./ShadersInclude/oitDeclaration.esm.js";
+import "./ShadersInclude/mainUVVaryingDeclaration.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/lightFragmentDeclaration.esm.js";
+import "./ShadersInclude/lightUboDeclaration.esm.js";
+import "./ShadersInclude/lightsFragmentFunctions.esm.js";
+import "./ShadersInclude/shadowsFragmentFunctions.esm.js";
+import "./ShadersInclude/samplerFragmentDeclaration.esm.js";
+import "./ShadersInclude/fresnelFunction.esm.js";
+import "./ShadersInclude/reflectionFunction.esm.js";
+import "./ShadersInclude/imageProcessingDeclaration.esm.js";
+import "./ShadersInclude/imageProcessingFunctions.esm.js";
+import "./ShadersInclude/bumpFragmentMainFunctions.esm.js";
+import "./ShadersInclude/bumpFragmentFunctions.esm.js";
+import "./ShadersInclude/clipPlaneFragmentDeclaration.esm.js";
+import "./ShadersInclude/logDepthDeclaration.esm.js";
+import "./ShadersInclude/fogFragmentDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneFragment.esm.js";
+import "./ShadersInclude/bumpFragment.esm.js";
+import "./ShadersInclude/decalFragment.esm.js";
+import "./ShadersInclude/depthPrePass.esm.js";
+import "./ShadersInclude/lightFragment.esm.js";
+import "./ShadersInclude/logDepthFragment.esm.js";
+import "./ShadersInclude/fogFragment.esm.js";
+import "./ShadersInclude/oitFragment.esm.js";
+const i = "defaultPixelShader", r = `#include<__decl__defaultFragment>
+#if defined(BUMP) || !defined(NORMAL)
+#extension GL_OES_standard_derivatives : enable
+#endif
+#include<prePassDeclaration>[SCENE_MRT_COUNT]
+#include<oitDeclaration>
+#define CUSTOM_FRAGMENT_BEGIN
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+#define RECIPROCAL_PI2 0.15915494
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#include<helperFunctions>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse,_SAMPLERNAME_,diffuse)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient,_SAMPLERNAME_,ambient)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity,_SAMPLERNAME_,opacity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive,_SAMPLERNAME_,emissive)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap,_SAMPLERNAME_,lightmap)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_SAMPLERNAME_,decal)
+#ifdef REFRACTION
+#ifdef REFRACTIONMAP_3D
+uniform samplerCube refractionCubeSampler;
+#else
+uniform sampler2D refraction2DSampler;
+#endif
+#endif
+#if defined(SPECULARTERM)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular,_SAMPLERNAME_,specular)
+#endif
+#include<fresnelFunction>
+#ifdef REFLECTION
+#ifdef REFLECTIONMAP_3D
+uniform samplerCube reflectionCubeSampler;
+#else
+uniform sampler2D reflection2DSampler;
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+varying vec3 vPositionUVW;
+#else
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vec3 vDirectionW;
+#endif
+#endif
+#include<reflectionFunction>
+#endif
+#include<imageProcessingDeclaration>
+#include<imageProcessingFunctions>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+float alpha=vDiffuseColor.a;
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=normalize(-cross(dFdx(vPositionW),dFdy(vPositionW)));
+#endif
+#include<bumpFragment>
+#ifdef TWOSIDEDLIGHTING
+normalW=gl_FrontFacing ? normalW : -normalW;
+#endif
+#ifdef DIFFUSE
+baseColor=texture2D(diffuseSampler,vDiffuseUV+uvOffset);
+#if defined(ALPHATEST) && !defined(ALPHATEST_AFTERALLALPHACOMPUTATIONS)
+if (baseColor.a<alphaCutOff)
+discard;
+#endif
+#ifdef ALPHAFROMDIFFUSE
+alpha*=baseColor.a;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_ALPHA
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#if defined(DECAL) && !defined(DECAL_AFTER_DETAIL)
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#include<decalFragment>(surfaceAlbedo,baseColor,GAMMADECAL,_GAMMADECAL_NOTUSED_)
+#endif
+#include<depthPrePass>
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+baseColor.rgb*=vColor.rgb;
+#endif
+#ifdef DETAIL
+baseColor.rgb=baseColor.rgb*2.0*mix(0.5,detailColor.r,vDetailInfos.y);
+#endif
+#if defined(DECAL) && defined(DECAL_AFTER_DETAIL)
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#include<decalFragment>(surfaceAlbedo,baseColor,GAMMADECAL,_GAMMADECAL_NOTUSED_)
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_DIFFUSE
+vec3 baseAmbientColor=vec3(1.,1.,1.);
+#ifdef AMBIENT
+baseAmbientColor=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb*vAmbientInfos.y;
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_LIGHTS
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularColor=vSpecularColor.rgb;
+#ifdef SPECULAR
+vec4 specularMapColor=texture2D(specularSampler,vSpecularUV+uvOffset);
+specularColor=specularMapColor.rgb;
+#ifdef GLOSSINESS
+glossiness=glossiness*specularMapColor.a;
+#endif
+#endif
+#else
+float glossiness=0.;
+#endif
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+float shadow=1.;
+#ifdef LIGHTMAP
+vec4 lightmapColor=texture2D(lightmapSampler,vLightmapUV+uvOffset);
+#ifdef RGBDLIGHTMAP
+lightmapColor.rgb=fromRGBD(lightmapColor);
+#endif
+lightmapColor.rgb*=vLightmapInfos.y;
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+vec4 refractionColor=vec4(0.,0.,0.,1.);
+#ifdef REFRACTION
+vec3 refractionVector=normalize(refract(-viewDirectionW,normalW,vRefractionInfos.y));
+#ifdef REFRACTIONMAP_3D
+#ifdef USE_LOCAL_REFRACTIONMAP_CUBIC
+refractionVector=parallaxCorrectNormal(vPositionW,refractionVector,vRefractionSize,vRefractionPosition);
+#endif
+refractionVector.y=refractionVector.y*vRefractionInfos.w;
+vec4 refractionLookup=textureCube(refractionCubeSampler,refractionVector);
+if (dot(refractionVector,viewDirectionW)<1.0) {
+refractionColor=refractionLookup;
+}
+#else
+vec3 vRefractionUVW=vec3(refractionMatrix*(view*vec4(vPositionW+refractionVector*vRefractionInfos.z,1.0)));
+vec2 refractionCoords=vRefractionUVW.xy/vRefractionUVW.z;
+refractionCoords.y=1.0-refractionCoords.y;
+refractionColor=texture2D(refraction2DSampler,refractionCoords);
+#endif
+#ifdef RGBDREFRACTION
+refractionColor.rgb=fromRGBD(refractionColor);
+#endif
+#ifdef IS_REFRACTION_LINEAR
+refractionColor.rgb=toGammaSpace(refractionColor.rgb);
+#endif
+refractionColor.rgb*=vRefractionInfos.x;
+#endif
+vec4 reflectionColor=vec4(0.,0.,0.,1.);
+#ifdef REFLECTION
+vec3 vReflectionUVW=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+vReflectionUVW.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+#ifdef ROUGHNESS
+float bias=vReflectionInfos.y;
+#ifdef SPECULARTERM
+#ifdef SPECULAR
+#ifdef GLOSSINESS
+bias*=(1.0-specularMapColor.a);
+#endif
+#endif
+#endif
+reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW,bias);
+#else
+reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW);
+#endif
+#else
+vec2 coords=vReflectionUVW.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+coords/=vReflectionUVW.z;
+#endif
+coords.y=1.0-coords.y;
+reflectionColor=texture2D(reflection2DSampler,coords);
+#endif
+#ifdef RGBDREFLECTION
+reflectionColor.rgb=fromRGBD(reflectionColor);
+#endif
+#ifdef IS_REFLECTION_LINEAR
+reflectionColor.rgb=toGammaSpace(reflectionColor.rgb);
+#endif
+reflectionColor.rgb*=vReflectionInfos.x;
+#ifdef REFLECTIONFRESNEL
+float reflectionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,reflectionRightColor.a,reflectionLeftColor.a);
+#ifdef REFLECTIONFRESNELFROMSPECULAR
+#ifdef SPECULARTERM
+reflectionColor.rgb*=specularColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#else
+reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#endif
+#else
+reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#endif
+#endif
+#endif
+#ifdef REFRACTIONFRESNEL
+float refractionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,refractionRightColor.a,refractionLeftColor.a);
+refractionColor.rgb*=refractionLeftColor.rgb*(1.0-refractionFresnelTerm)+refractionFresnelTerm*refractionRightColor.rgb;
+#endif
+#ifdef OPACITY
+vec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);
+#ifdef OPACITYRGB
+opacityMap.rgb=opacityMap.rgb*vec3(0.3,0.59,0.11);
+alpha*=(opacityMap.x+opacityMap.y+opacityMap.z)* vOpacityInfos.y;
+#else
+alpha*=opacityMap.a*vOpacityInfos.y;
+#endif
+#endif
+#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+alpha*=vColor.a;
+#endif
+#ifdef OPACITYFRESNEL
+float opacityFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,opacityParts.z,opacityParts.w);
+alpha+=opacityParts.x*(1.0-opacityFresnelTerm)+opacityFresnelTerm*opacityParts.y;
+#endif
+#ifdef ALPHATEST
+#ifdef ALPHATEST_AFTERALLALPHACOMPUTATIONS
+if (alpha<alphaCutOff)
+discard;
+#endif
+#ifndef ALPHABLEND
+alpha=1.0;
+#endif
+#endif
+vec3 emissiveColor=vEmissiveColor;
+#ifdef EMISSIVE
+emissiveColor+=texture2D(emissiveSampler,vEmissiveUV+uvOffset).rgb*vEmissiveInfos.y;
+#endif
+#ifdef EMISSIVEFRESNEL
+float emissiveFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,emissiveRightColor.a,emissiveLeftColor.a);
+emissiveColor*=emissiveLeftColor.rgb*(1.0-emissiveFresnelTerm)+emissiveFresnelTerm*emissiveRightColor.rgb;
+#endif
+#ifdef DIFFUSEFRESNEL
+float diffuseFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,diffuseRightColor.a,diffuseLeftColor.a);
+diffuseBase*=diffuseLeftColor.rgb*(1.0-diffuseFresnelTerm)+diffuseFresnelTerm*diffuseRightColor.rgb;
+#endif
+#ifdef EMISSIVEASILLUMINATION
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#else
+#ifdef LINKEMISSIVEWITHDIFFUSE
+vec3 finalDiffuse=clamp((diffuseBase+emissiveColor)*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#else
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+emissiveColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#endif
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#ifdef SPECULAROVERALPHA
+alpha=clamp(alpha+dot(finalSpecular,vec3(0.3,0.59,0.11)),0.,1.);
+#endif
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+#ifdef REFLECTIONOVERALPHA
+alpha=clamp(alpha+dot(reflectionColor.rgb,vec3(0.3,0.59,0.11)),0.,1.);
+#endif
+#ifdef EMISSIVEASILLUMINATION
+vec4 color=vec4(clamp(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+emissiveColor+refractionColor.rgb,0.0,1.0),alpha);
+#else
+vec4 color=vec4(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+refractionColor.rgb,alpha);
+#endif
+#ifdef LIGHTMAP
+#ifndef LIGHTMAPEXCLUDED
+#ifdef USELIGHTMAPASSHADOWMAP
+color.rgb*=lightmapColor.rgb;
+#else
+color.rgb+=lightmapColor.rgb;
+#endif
+#endif
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_FOG
+color.rgb=max(color.rgb,0.);
+#include<logDepthFragment>
+#include<fogFragment>
+#ifdef IMAGEPROCESSINGPOSTPROCESS
+color.rgb=toLinearSpace(color.rgb);
+#else
+#ifdef IMAGEPROCESSING
+color.rgb=toLinearSpace(color.rgb);
+color=applyImageProcessing(color);
+#endif
+#endif
+color.a*=visibility;
+#ifdef PREMULTIPLYALPHA
+color.rgb*=color.a;
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef PREPASS
+float writeGeometryInfo=color.a>0.4 ? 1.0 : 0.0;
+gl_FragData[0]=color; 
+#ifdef PREPASS_POSITION
+gl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);
+#endif
+#ifdef PREPASS_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[PREPASS_VELOCITY_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_IRRADIANCE
+gl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(0.0,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_DEPTH
+gl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_NORMAL
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo); 
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+gl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(0.0,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_REFLECTIVITY
+#if defined(SPECULARTERM)
+#if defined(SPECULAR)
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularMapColor))*writeGeometryInfo; 
+#else
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularColor),1.0)*writeGeometryInfo;
+#endif
+#else
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(0.0,0.0,0.0,1.0)*writeGeometryInfo;
+#endif
+#endif
+#endif
+#if !defined(PREPASS) || defined(WEBGL2)
+gl_FragColor=color;
+#endif
+#include<oitFragment>
+#if ORDER_INDEPENDENT_TRANSPARENCY
+if (fragDepth==nearestDepth) {
+frontColor.rgb+=color.rgb*color.a*alphaMultiplier;
+frontColor.a=1.0-alphaMultiplier*(1.0-color.a);
+} else {
+backColor+=color;
+}
+#endif
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+e.ShadersStore[i] = r;

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

@@ -0,0 +1,171 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/defaultVertexDeclaration.esm.js";
+import "./ShadersInclude/defaultUboDeclaration.esm.js";
+import "./ShadersInclude/uvAttributeDeclaration.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/bonesDeclaration.esm.js";
+import "./ShadersInclude/bakedVertexAnimationDeclaration.esm.js";
+import "./ShadersInclude/instancesDeclaration.esm.js";
+import "./ShadersInclude/prePassVertexDeclaration.esm.js";
+import "./ShadersInclude/mainUVVaryingDeclaration.esm.js";
+import "./ShadersInclude/samplerVertexDeclaration.esm.js";
+import "./ShadersInclude/bumpVertexDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneVertexDeclaration.esm.js";
+import "./ShadersInclude/fogVertexDeclaration.esm.js";
+import "./ShadersInclude/lightVxFragmentDeclaration.esm.js";
+import "./ShadersInclude/lightVxUboDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexGlobalDeclaration.esm.js";
+import "./ShadersInclude/morphTargetsVertexDeclaration.esm.js";
+import "./ShadersInclude/logDepthDeclaration.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/prePassVertex.esm.js";
+import "./ShadersInclude/uvVariableDeclaration.esm.js";
+import "./ShadersInclude/samplerVertexImplementation.esm.js";
+import "./ShadersInclude/bumpVertex.esm.js";
+import "./ShadersInclude/clipPlaneVertex.esm.js";
+import "./ShadersInclude/fogVertex.esm.js";
+import "./ShadersInclude/shadowsVertex.esm.js";
+import "./ShadersInclude/vertexColorMixing.esm.js";
+import "./ShadersInclude/pointCloudVertex.esm.js";
+import "./ShadersInclude/logDepthVertex.esm.js";
+const i = "defaultVertexShader", n = `#include<__decl__defaultVertex>
+#define CUSTOM_VERTEX_BEGIN
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef TANGENT
+attribute vec4 tangent;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#include<uvAttributeDeclaration>[2..7]
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<helperFunctions>
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<instancesDeclaration>
+#include<prePassVertexDeclaration>
+#include<mainUVVaryingDeclaration>[1..7]
+#include<samplerVertexDeclaration>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail)
+#include<samplerVertexDeclaration>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient)
+#include<samplerVertexDeclaration>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity)
+#include<samplerVertexDeclaration>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive)
+#include<samplerVertexDeclaration>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap)
+#if defined(SPECULARTERM)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular)
+#endif
+#include<samplerVertexDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal)
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+#include<bumpVertexDeclaration>
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightVxFragment>[0..maxSimultaneousLights]
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+varying vec3 vPositionUVW;
+#endif
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vec3 vDirectionW;
+#endif
+#include<logDepthDeclaration>
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vec3 positionUpdated=position;
+#ifdef NORMAL
+vec3 normalUpdated=normal;
+#endif
+#ifdef TANGENT
+vec4 tangentUpdated=tangent;
+#endif
+#ifdef UV1
+vec2 uvUpdated=uv;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+vPositionUVW=positionUpdated;
+#endif
+#define CUSTOM_VERTEX_UPDATE_POSITION
+#define CUSTOM_VERTEX_UPDATE_NORMAL
+#include<instancesVertex>
+#if defined(PREPASS) && defined(PREPASS_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=finalWorld*vec4(positionUpdated,1.0);
+#ifdef NORMAL
+mat3 normalWorld=mat3(finalWorld);
+#if defined(INSTANCES) && defined(THIN_INSTANCES)
+vNormalW=normalUpdated/vec3(dot(normalWorld[0],normalWorld[0]),dot(normalWorld[1],normalWorld[1]),dot(normalWorld[2],normalWorld[2]));
+vNormalW=normalize(normalWorld*vNormalW);
+#else
+#ifdef NONUNIFORMSCALING
+normalWorld=transposeMat3(inverseMat3(normalWorld));
+#endif
+vNormalW=normalize(normalWorld*normalUpdated);
+#endif
+#endif
+#define CUSTOM_VERTEX_UPDATE_WORLDPOS
+#ifdef MULTIVIEW
+if (gl_ViewID_OVR==0u) {
+gl_Position=viewProjection*worldPos;
+} else {
+gl_Position=viewProjectionR*worldPos;
+}
+#else
+gl_Position=viewProjection*worldPos;
+#endif
+vPositionW=vec3(worldPos);
+#include<prePassVertex>
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+vDirectionW=normalize(vec3(finalWorld*vec4(positionUpdated,0.0)));
+#endif
+#ifndef UV1
+vec2 uvUpdated=vec2(0.,0.);
+#endif
+#ifdef MAINUV1
+vMainUV1=uvUpdated;
+#endif
+#include<uvVariableDeclaration>[2..7]
+#include<samplerVertexImplementation>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse,_MATRIXNAME_,diffuse,_INFONAME_,DiffuseInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_MATRIXNAME_,detail,_INFONAME_,DetailInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient,_MATRIXNAME_,ambient,_INFONAME_,AmbientInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity,_MATRIXNAME_,opacity,_INFONAME_,OpacityInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive,_MATRIXNAME_,emissive,_INFONAME_,EmissiveInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap,_MATRIXNAME_,lightmap,_INFONAME_,LightmapInfos.x)
+#if defined(SPECULARTERM)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular,_MATRIXNAME_,specular,_INFONAME_,SpecularInfos.x)
+#endif
+#include<samplerVertexImplementation>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_MATRIXNAME_,bump,_INFONAME_,BumpInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_MATRIXNAME_,decal,_INFONAME_,DecalInfos.x)
+#include<bumpVertex>
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+#include<vertexColorMixing>
+#include<pointCloudVertex>
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;
+e.ShadersStore[i] = n;

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

@@ -0,0 +1,47 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/clipPlaneFragmentDeclaration.esm.js";
+import "./ShadersInclude/packingFunctions.esm.js";
+import "./ShadersInclude/clipPlaneFragment.esm.js";
+const i = "depthPixelShader", r = `#ifdef ALPHATEST
+varying vec2 vUV;
+uniform sampler2D diffuseSampler;
+#endif
+#include<clipPlaneFragmentDeclaration>
+varying float vDepthMetric;
+#ifdef PACKED
+#include<packingFunctions>
+#endif
+#ifdef STORE_CAMERASPACE_Z
+varying vec4 vViewPos;
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (texture2D(diffuseSampler,vUV).a<0.4)
+discard;
+#endif
+#ifdef STORE_CAMERASPACE_Z
+#ifdef PACKED
+gl_FragColor=pack(vViewPos.z);
+#else
+gl_FragColor=vec4(vViewPos.z,0.0,0.0,1.0);
+#endif
+#else
+#ifdef NONLINEARDEPTH
+#ifdef PACKED
+gl_FragColor=pack(gl_FragCoord.z);
+#else
+gl_FragColor=vec4(gl_FragCoord.z,0.0,0.0,0.0);
+#endif
+#else
+#ifdef PACKED
+gl_FragColor=pack(vDepthMetric);
+#else
+gl_FragColor=vec4(vDepthMetric,0.0,0.0,1.0);
+#endif
+#endif
+#endif
+}`;
+e.ShadersStore[i] = r;