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

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

@@ -0,0 +1,236 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/pbrVertexDeclaration.esm.js";
+import "./ShadersInclude/pbrUboDeclaration.esm.js";
+import "./ShadersInclude/uvAttributeDeclaration.esm.js";
+import "./ShadersInclude/mainUVVaryingDeclaration.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/samplerVertexDeclaration.esm.js";
+import "./ShadersInclude/harmonicsFunctions.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/logDepthVertex.esm.js";
+const i = "pbrVertexShader", E = `precision highp float;
+#include<__decl__pbrVertex>
+#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]
+#include<mainUVVaryingDeclaration>[1..7]
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<helperFunctions>
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<instancesDeclaration>
+#include<prePassVertexDeclaration>
+#include<samplerVertexDeclaration>(_DEFINENAME_,ALBEDO,_VARYINGNAME_,Albedo)
+#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)
+#include<samplerVertexDeclaration>(_DEFINENAME_,REFLECTIVITY,_VARYINGNAME_,Reflectivity)
+#include<samplerVertexDeclaration>(_DEFINENAME_,MICROSURFACEMAP,_VARYINGNAME_,MicroSurfaceSampler)
+#include<samplerVertexDeclaration>(_DEFINENAME_,METALLIC_REFLECTANCE,_VARYINGNAME_,MetallicReflectance)
+#include<samplerVertexDeclaration>(_DEFINENAME_,REFLECTANCE,_VARYINGNAME_,Reflectance)
+#include<samplerVertexDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal)
+#ifdef CLEARCOAT
+#include<samplerVertexDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE,_VARYINGNAME_,ClearCoat)
+#include<samplerVertexDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE_ROUGHNESS,_VARYINGNAME_,ClearCoatRoughness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,CLEARCOAT_BUMP,_VARYINGNAME_,ClearCoatBump)
+#include<samplerVertexDeclaration>(_DEFINENAME_,CLEARCOAT_TINT_TEXTURE,_VARYINGNAME_,ClearCoatTint)
+#endif
+#ifdef IRIDESCENCE
+#include<samplerVertexDeclaration>(_DEFINENAME_,IRIDESCENCE_TEXTURE,_VARYINGNAME_,Iridescence)
+#include<samplerVertexDeclaration>(_DEFINENAME_,IRIDESCENCE_THICKNESS_TEXTURE,_VARYINGNAME_,IridescenceThickness)
+#endif
+#ifdef SHEEN
+#include<samplerVertexDeclaration>(_DEFINENAME_,SHEEN_TEXTURE,_VARYINGNAME_,Sheen)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SHEEN_TEXTURE_ROUGHNESS,_VARYINGNAME_,SheenRoughness)
+#endif
+#ifdef ANISOTROPIC
+#include<samplerVertexDeclaration>(_DEFINENAME_,ANISOTROPIC_TEXTURE,_VARYINGNAME_,Anisotropy)
+#endif
+#ifdef SUBSURFACE
+#include<samplerVertexDeclaration>(_DEFINENAME_,SS_THICKNESSANDMASK_TEXTURE,_VARYINGNAME_,Thickness)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SS_REFRACTIONINTENSITY_TEXTURE,_VARYINGNAME_,RefractionIntensity)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SS_TRANSLUCENCYINTENSITY_TEXTURE,_VARYINGNAME_,TranslucencyIntensity)
+#endif
+varying vec3 vPositionW;
+#if DEBUGMODE>0
+varying vec4 vClipSpacePosition;
+#endif
+#ifdef NORMAL
+varying vec3 vNormalW;
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+varying vec3 vEnvironmentIrradiance;
+#include<harmonicsFunctions>
+#endif
+#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);
+vPositionW=vec3(worldPos);
+#include<prePassVertex>
+#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
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+vec3 reflectionVector=vec3(reflectionMatrix*vec4(vNormalW,0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+vEnvironmentIrradiance=computeEnvironmentIrradiance(reflectionVector);
+#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
+#if DEBUGMODE>0
+vClipSpacePosition=gl_Position;
+#endif
+#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_,ALBEDO,_VARYINGNAME_,Albedo,_MATRIXNAME_,albedo,_INFONAME_,AlbedoInfos.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)
+#include<samplerVertexImplementation>(_DEFINENAME_,REFLECTIVITY,_VARYINGNAME_,Reflectivity,_MATRIXNAME_,reflectivity,_INFONAME_,ReflectivityInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,MICROSURFACEMAP,_VARYINGNAME_,MicroSurfaceSampler,_MATRIXNAME_,microSurfaceSampler,_INFONAME_,MicroSurfaceSamplerInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,METALLIC_REFLECTANCE,_VARYINGNAME_,MetallicReflectance,_MATRIXNAME_,metallicReflectance,_INFONAME_,MetallicReflectanceInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,REFLECTANCE,_VARYINGNAME_,Reflectance,_MATRIXNAME_,reflectance,_INFONAME_,ReflectanceInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_MATRIXNAME_,bump,_INFONAME_,BumpInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_MATRIXNAME_,decal,_INFONAME_,DecalInfos.x)
+#ifdef CLEARCOAT
+#include<samplerVertexImplementation>(_DEFINENAME_,CLEARCOAT_TEXTURE,_VARYINGNAME_,ClearCoat,_MATRIXNAME_,clearCoat,_INFONAME_,ClearCoatInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,CLEARCOAT_TEXTURE_ROUGHNESS,_VARYINGNAME_,ClearCoatRoughness,_MATRIXNAME_,clearCoatRoughness,_INFONAME_,ClearCoatInfos.z)
+#include<samplerVertexImplementation>(_DEFINENAME_,CLEARCOAT_BUMP,_VARYINGNAME_,ClearCoatBump,_MATRIXNAME_,clearCoatBump,_INFONAME_,ClearCoatBumpInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,CLEARCOAT_TINT_TEXTURE,_VARYINGNAME_,ClearCoatTint,_MATRIXNAME_,clearCoatTint,_INFONAME_,ClearCoatTintInfos.x)
+#endif
+#ifdef IRIDESCENCE
+#include<samplerVertexImplementation>(_DEFINENAME_,IRIDESCENCE_TEXTURE,_VARYINGNAME_,Iridescence,_MATRIXNAME_,iridescence,_INFONAME_,IridescenceInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,IRIDESCENCE_THICKNESS_TEXTURE,_VARYINGNAME_,IridescenceThickness,_MATRIXNAME_,iridescenceThickness,_INFONAME_,IridescenceInfos.z)
+#endif
+#ifdef SHEEN
+#include<samplerVertexImplementation>(_DEFINENAME_,SHEEN_TEXTURE,_VARYINGNAME_,Sheen,_MATRIXNAME_,sheen,_INFONAME_,SheenInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SHEEN_TEXTURE_ROUGHNESS,_VARYINGNAME_,SheenRoughness,_MATRIXNAME_,sheen,_INFONAME_,SheenInfos.z)
+#endif
+#ifdef ANISOTROPIC
+#include<samplerVertexImplementation>(_DEFINENAME_,ANISOTROPIC_TEXTURE,_VARYINGNAME_,Anisotropy,_MATRIXNAME_,anisotropy,_INFONAME_,AnisotropyInfos.x)
+#endif
+#ifdef SUBSURFACE
+#include<samplerVertexImplementation>(_DEFINENAME_,SS_THICKNESSANDMASK_TEXTURE,_VARYINGNAME_,Thickness,_MATRIXNAME_,thickness,_INFONAME_,ThicknessInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SS_REFRACTIONINTENSITY_TEXTURE,_VARYINGNAME_,RefractionIntensity,_MATRIXNAME_,refractionIntensity,_INFONAME_,RefractionIntensityInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,SS_TRANSLUCENCYINTENSITY_TEXTURE,_VARYINGNAME_,TranslucencyIntensity,_MATRIXNAME_,translucencyIntensity,_INFONAME_,TranslucencyIntensityInfos.x)
+#endif
+#include<bumpVertex>
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+#include<vertexColorMixing>
+#if defined(POINTSIZE) && !defined(WEBGPU)
+gl_PointSize=pointSize;
+#endif
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+e.ShadersStore[i] = E;

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

@@ -0,0 +1,13 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "postprocessVertexShader", i = `attribute vec2 position;
+uniform vec2 scale;
+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)*scale;
+gl_Position=vec4(position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;
+e.ShadersStore[o] = i;

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

@@ -0,0 +1,11 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+const r = "rgbdDecodePixelShader", o = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+#include<helperFunctions>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{
+gl_FragColor=vec4(fromRGBD(texture2D(textureSampler,vUV)),1.0);
+}`;
+e.ShadersStore[r] = o;

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

@@ -0,0 +1,11 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+const r = "rgbdEncodePixelShader", o = `varying vec2 vUV;
+uniform sampler2D textureSampler;
+#include<helperFunctions>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{
+gl_FragColor=toRGBD(texture2D(textureSampler,vUV).rgb);
+}`;
+e.ShadersStore[r] = o;

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

@@ -0,0 +1,136 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "screenSpaceReflectionPixelShader", r = `uniform sampler2D textureSampler;
+#ifdef SSR_SUPPORTED
+uniform sampler2D reflectivitySampler;
+uniform sampler2D normalSampler;
+uniform sampler2D positionSampler;
+#endif
+uniform mat4 view;
+uniform mat4 projection;
+uniform float stepSize;
+uniform float strength;
+uniform float threshold;
+uniform float roughnessFactor;
+uniform float reflectionSpecularFalloffExponent;
+varying vec2 vUV;
+#ifdef SSR_SUPPORTED
+struct ReflectionInfo {
+vec3 color;
+vec4 coords;
+};
+/**
+* According to specular,see https:
+*/
+vec3 fresnelSchlick(float cosTheta,vec3 F0)
+{
+return F0+(1.0-F0)*pow(1.0-cosTheta,5.0);
+}
+/**
+* Once the pixel's coordinates has been found,let's adjust (smooth) a little bit
+* by sampling multiple reflection pixels.
+*/
+ReflectionInfo smoothReflectionInfo(vec3 dir,vec3 hitCoord)
+{
+ReflectionInfo info;
+info.color=vec3(0.0);
+vec4 projectedCoord;
+float sampledDepth;
+for(int i=0; i<SMOOTH_STEPS; i++)
+{
+projectedCoord=projection*vec4(hitCoord,1.0);
+projectedCoord.xy/=projectedCoord.w;
+projectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);
+sampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;
+float depth=sampledDepth-hitCoord.z;
+dir*=0.5;
+if(depth>0.0)
+hitCoord-=dir;
+else
+hitCoord+=dir;
+info.color+=texture2D(textureSampler,projectedCoord.xy).rgb;
+}
+projectedCoord=projection*vec4(hitCoord,1.0);
+projectedCoord.xy/=projectedCoord.w;
+projectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);
+info.coords=vec4(projectedCoord.xy,sampledDepth,1.0);
+info.color+=texture2D(textureSampler,projectedCoord.xy).rgb;
+info.color/=float(SMOOTH_STEPS+1);
+return info;
+}
+/**
+* Tests the given world position (hitCoord) according to the given reflection vector (dir)
+* until it finds a collision (means that depth is enough close to say "it's the pixel to sample!").
+*/
+ReflectionInfo getReflectionInfo(vec3 dir,vec3 hitCoord)
+{
+ReflectionInfo info;
+vec4 projectedCoord;
+float sampledDepth;
+dir*=stepSize;
+for(int i=0; i<REFLECTION_SAMPLES; i++)
+{
+hitCoord+=dir;
+projectedCoord=projection*vec4(hitCoord,1.0);
+projectedCoord.xy/=projectedCoord.w;
+projectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);
+sampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;
+float depth=sampledDepth-hitCoord.z;
+#ifdef RIGHT_HANDED_SCENE
+depth*=-1.0;
+#endif
+if(((depth-dir.z)<threshold) && depth<=0.0)
+{
+#ifdef ENABLE_SMOOTH_REFLECTIONS
+return smoothReflectionInfo(dir,hitCoord);
+#else
+info.color=texture2D(textureSampler,projectedCoord.xy).rgb;
+info.coords=vec4(projectedCoord.xy,sampledDepth,0.0);
+return info;
+#endif
+}
+}
+info.color=texture2D(textureSampler,projectedCoord.xy).rgb;
+info.coords=vec4(projectedCoord.xy,sampledDepth,0.0);
+return info;
+}
+vec3 hash(vec3 a)
+{
+a=fract(a*0.8);
+a+=dot(a,a.yxz+19.19);
+return fract((a.xxy+a.yxx)*a.zyx);
+}
+#endif
+void main()
+{
+#ifdef SSR_SUPPORTED
+vec4 albedoFull=texture2D(textureSampler,vUV);
+vec3 albedo=albedoFull.rgb;
+float spec=texture2D(reflectivitySampler,vUV).r;
+if (spec==0.0) {
+gl_FragColor=albedoFull;
+return;
+}
+vec3 normal=(texture2D(normalSampler,vUV)).xyz;
+vec3 position=(view*texture2D(positionSampler,vUV)).xyz;
+vec3 reflected=normalize(reflect(normalize(position),normalize(normal)));
+float roughness=1.0-texture2D(reflectivitySampler,vUV).a;
+vec3 jitt=mix(vec3(0.0),hash(position),roughness)*roughnessFactor;
+ReflectionInfo info=getReflectionInfo(jitt+reflected,position);
+vec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-info.coords.xy));
+float screenEdgefactor=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);
+vec3 F0=vec3(0.04);
+F0 =mix(F0,albedo,spec);
+vec3 fresnel=fresnelSchlick(max(dot(normalize(normal),normalize(position)),0.0),F0);
+#ifdef RIGHT_HANDED_SCENE
+reflected.z*=-1.0;
+#endif
+float reflectionMultiplier=clamp(pow(spec*strength,reflectionSpecularFalloffExponent)*screenEdgefactor*reflected.z,0.0,0.9);
+float albedoMultiplier=1.0-reflectionMultiplier;
+vec3 SSR=info.color*fresnel;
+gl_FragColor=vec4((albedo*albedoMultiplier)+(SSR*reflectionMultiplier),albedoFull.a);
+#else
+gl_FragColor=texture2D(textureSampler,vUV);
+#endif
+}
+`;
+e.ShadersStore[o] = r;

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

@@ -0,0 +1,215 @@
+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 t = "screenSpaceReflection2PixelShader", i = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)
+#define TEXTURECUBEFUNC(s,c,lod) textureLod(s,c,lod)
+#else
+#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)
+#define TEXTURECUBEFUNC(s,c,bias) textureCube(s,c,bias)
+#endif
+uniform sampler2D textureSampler;
+varying vec2 vUV;
+#ifdef SSR_SUPPORTED
+uniform sampler2D reflectivitySampler;
+uniform sampler2D normalSampler;
+uniform sampler2D depthSampler;
+#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER
+uniform sampler2D backDepthSampler;
+uniform float backSizeFactor;
+#endif
+#ifdef SSR_USE_ENVIRONMENT_CUBE
+uniform samplerCube envCubeSampler;
+#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC
+uniform vec3 vReflectionPosition;
+uniform vec3 vReflectionSize;
+#endif
+#endif
+uniform mat4 view;
+uniform mat4 invView;
+uniform mat4 projection;
+uniform mat4 invProjectionMatrix;
+uniform mat4 projectionPixel;
+uniform float nearPlaneZ;
+uniform float stepSize;
+uniform float maxSteps;
+uniform float strength;
+uniform float thickness;
+uniform float roughnessFactor;
+uniform float reflectionSpecularFalloffExponent;
+uniform float maxDistance;
+uniform float selfCollisionNumSkip;
+uniform float reflectivityThreshold;
+#include<helperFunctions>
+#include<pbrBRDFFunctions>
+#include<screenSpaceRayTrace>
+vec3 hash(vec3 a)
+{
+a=fract(a*0.8);
+a+=dot(a,a.yxz+19.19);
+return fract((a.xxy+a.yxx)*a.zyx);
+}
+float computeAttenuationForIntersection(ivec2 hitPixel,vec2 hitUV,vec3 vsRayOrigin,vec3 vsHitPoint,vec3 reflectionVector,float maxRayDistance,float numIterations) {
+float attenuation=1.0;
+#ifdef SSR_ATTENUATE_SCREEN_BORDERS
+vec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-hitUV.xy));
+attenuation*=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);
+#endif
+#ifdef SSR_ATTENUATE_INTERSECTION_DISTANCE
+attenuation*=1.0-clamp(distance(vsRayOrigin,vsHitPoint)/maxRayDistance,0.0,1.0);
+#endif
+#ifdef SSR_ATTENUATE_INTERSECTION_NUMITERATIONS
+attenuation*=1.0-(numIterations/maxSteps);
+#endif
+#ifdef SSR_ATTENUATE_BACKFACE_REFLECTION
+vec3 reflectionNormal=texelFetch(normalSampler,hitPixel,0).xyz;
+float directionBasedAttenuation=smoothstep(-0.17,0.0,dot(reflectionNormal,-reflectionVector));
+attenuation*=directionBasedAttenuation;
+#endif
+return attenuation;
+}
+#endif
+void main()
+{
+#ifdef SSR_SUPPORTED
+vec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);
+vec3 color=colorFull.rgb;
+vec4 reflectivity=TEXTUREFUNC(reflectivitySampler,vUV,0.0);
+#ifndef SSR_DISABLE_REFLECTIVITY_TEST
+if (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {
+#ifdef SSR_USE_BLUR
+gl_FragColor=vec4(0.);
+#else
+gl_FragColor=colorFull;
+#endif
+return;
+}
+#endif
+#ifdef SSR_INPUT_IS_GAMMA_SPACE
+color=toLinearSpace(color);
+#endif
+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 csReflectedVector=reflect(csViewDirection,csNormal);
+#ifdef SSR_USE_ENVIRONMENT_CUBE
+vec3 wReflectedVector=vec3(invView*vec4(csReflectedVector,0.0));
+#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC
+vec4 worldPos=invView*vec4(csPosition,1.0);
+wReflectedVector=parallaxCorrectNormal(worldPos.xyz,normalize(wReflectedVector),vReflectionSize,vReflectionPosition);
+#endif
+#ifdef SSR_INVERTCUBICMAP
+wReflectedVector.y*=-1.0;
+#endif
+#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE
+wReflectedVector.z*=-1.0;
+#endif
+vec3 envColor=TEXTURECUBEFUNC(envCubeSampler,wReflectedVector,0.0).xyz;
+#ifdef SSR_ENVIRONMENT_CUBE_IS_GAMMASPACE
+envColor=toLinearSpace(envColor);
+#endif
+#else
+vec3 envColor=color;
+#endif
+float reflectionAttenuation=1.0;
+bool rayHasHit=false;
+vec2 startPixel;
+vec2 hitPixel;
+vec3 hitPoint;
+float numIterations;
+#ifdef SSRAYTRACE_DEBUG
+vec3 debugColor;
+#endif
+#ifdef SSR_ATTENUATE_FACING_CAMERA
+reflectionAttenuation*=1.0-smoothstep(0.25,0.5,dot(-csViewDirection,csReflectedVector));
+#endif
+if (reflectionAttenuation>0.0) {
+#ifdef SSR_USE_BLUR
+vec3 jitt=vec3(0.);
+#else
+float roughness=1.0-reflectivity.a;
+vec3 jitt=mix(vec3(0.0),hash(csPosition)-vec3(0.5),roughness)*roughnessFactor; 
+#endif
+vec2 uv2=vUV*texSize;
+float c=(uv2.x+uv2.y)*0.25;
+float jitter=mod(c,1.0); 
+rayHasHit=traceScreenSpaceRay1(
+csPosition,
+normalize(csReflectedVector+jitt),
+projectionPixel,
+depthSampler,
+texSize,
+#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER
+backDepthSampler,
+backSizeFactor,
+#endif
+thickness,
+nearPlaneZ,
+stepSize,
+jitter,
+maxSteps,
+maxDistance,
+selfCollisionNumSkip,
+startPixel,
+hitPixel,
+hitPoint,
+numIterations
+#ifdef SSRAYTRACE_DEBUG
+,debugColor
+#endif
+);
+}
+#ifdef SSRAYTRACE_DEBUG
+gl_FragColor=vec4(debugColor,1.);
+return;
+#endif
+vec3 F0=reflectivity.rgb;
+vec3 fresnel=fresnelSchlickGGX(max(dot(csNormal,-csViewDirection),0.0),F0,vec3(1.));
+vec3 SSR=envColor;
+if (rayHasHit) {
+vec3 reflectedColor=texelFetch(textureSampler,ivec2(hitPixel),0).rgb;
+#ifdef SSR_INPUT_IS_GAMMA_SPACE
+reflectedColor=toLinearSpace(reflectedColor);
+#endif
+reflectionAttenuation*=computeAttenuationForIntersection(ivec2(hitPixel),hitPixel/texSize,csPosition,hitPoint,csReflectedVector,maxDistance,numIterations);
+SSR=reflectedColor*reflectionAttenuation+(1.0-reflectionAttenuation)*envColor;
+}
+#ifndef SSR_BLEND_WITH_FRESNEL
+SSR*=fresnel;
+#endif
+#ifdef SSR_USE_BLUR
+float blur_radius=0.0;
+float roughness=1.0-reflectivity.a*(1.0-roughnessFactor);
+if (roughness>0.001) {
+float cone_angle=min(roughness,0.999)*3.14159265*0.5;
+float cone_len=distance(startPixel,hitPixel);
+float op_len=2.0*tan(cone_angle)*cone_len; 
+float a=op_len;
+float h=cone_len;
+float a2=a*a;
+float fh2=4.0f*h*h;
+blur_radius=(a*(sqrt(a2+fh2)-a))/(4.0f*h);
+}
+gl_FragColor=vec4(SSR,blur_radius/255.0); 
+#else
+#ifdef SSR_BLEND_WITH_FRESNEL
+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*colorMultiplier)+(SSR*reflectionMultiplier);
+#ifdef SSR_OUTPUT_IS_GAMMA_SPACE
+finalColor=toGammaSpace(finalColor);
+#endif
+gl_FragColor=vec4(finalColor,colorFull.a);
+#endif
+#else
+gl_FragColor=TEXTUREFUNC(textureSampler,vUV,0.0);
+#endif
+}
+`;
+e.ShadersStore[t] = i;

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

@@ -0,0 +1,52 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+const o = "screenSpaceReflection2BlurPixelShader", a = `#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 vec2 texelOffsetScale;
+const float weights[8]=float[8] (0.071303,0.131514,0.189879,0.321392,0.452906, 0.584419,0.715932,0.847445);
+void processSample(vec2 uv,float i,vec2 stepSize,inout vec4 accumulator,inout float denominator)
+{
+vec2 offsetUV=stepSize*i+uv;
+float coefficient=weights[int(2.0-abs(i))];
+accumulator+=TEXTUREFUNC(textureSampler,offsetUV,0.0)*coefficient;
+denominator+=coefficient;
+}
+void main()
+{
+vec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);
+if (dot(colorFull,vec4(1.0))==0.0) {
+gl_FragColor=colorFull;
+return;
+}
+float blurRadius=colorFull.a*255.0; 
+vec2 stepSize=texelOffsetScale.xy*blurRadius;
+vec4 accumulator=TEXTUREFUNC(textureSampler,vUV,0.0)*0.214607;
+float denominator=0.214607;
+processSample(vUV,1.0,stepSize,accumulator,denominator);
+processSample(vUV,1.0*0.2,stepSize,accumulator,denominator);
+processSample(vUV,1.0*0.4,stepSize,accumulator,denominator);
+processSample(vUV,1.0*0.6,stepSize,accumulator,denominator);
+processSample(vUV,1.0*0.8,stepSize,accumulator,denominator);
+processSample(vUV,1.0*1.2,stepSize,accumulator,denominator);
+processSample(vUV,1.0*1.4,stepSize,accumulator,denominator);
+processSample(vUV,1.0*1.6,stepSize,accumulator,denominator);
+processSample(vUV,1.0*1.8,stepSize,accumulator,denominator);
+processSample(vUV,1.0*2.0,stepSize,accumulator,denominator);
+processSample(vUV,-1.0,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*0.2,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*0.4,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*0.6,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*0.8,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*1.2,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*1.4,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*1.6,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*1.8,stepSize,accumulator,denominator);
+processSample(vUV,-1.0*2.0,stepSize,accumulator,denominator);
+gl_FragColor=vec4(accumulator.rgb/denominator,colorFull.a);
+}
+`;
+e.ShadersStore[o] = a;