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

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrDirectLightingFunctions.esm.js

@@ -0,0 +1,130 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "pbrDirectLightingFunctions", o = `#define CLEARCOATREFLECTANCE90 1.0
+struct lightingInfo
+{
+vec3 diffuse;
+#ifdef SPECULARTERM
+vec3 specular;
+#endif
+#ifdef CLEARCOAT
+vec4 clearCoat;
+#endif
+#ifdef SHEEN
+vec3 sheen;
+#endif
+};
+float adjustRoughnessFromLightProperties(float roughness,float lightRadius,float lightDistance) {
+#if defined(USEPHYSICALLIGHTFALLOFF) || defined(USEGLTFLIGHTFALLOFF)
+float lightRoughness=lightRadius/lightDistance;
+float totalRoughness=saturate(lightRoughness+roughness);
+return totalRoughness;
+#else
+return roughness;
+#endif
+}
+vec3 computeHemisphericDiffuseLighting(preLightingInfo info,vec3 lightColor,vec3 groundColor) {
+return mix(groundColor,lightColor,info.NdotL);
+}
+vec3 computeDiffuseLighting(preLightingInfo info,vec3 lightColor) {
+float diffuseTerm=diffuseBRDF_Burley(info.NdotL,info.NdotV,info.VdotH,info.roughness);
+return diffuseTerm*info.attenuation*info.NdotL*lightColor;
+}
+#define inline
+vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler,mat4 textureProjectionMatrix){
+vec4 strq=textureProjectionMatrix*vec4(vPositionW,1.0);
+strq/=strq.w;
+vec3 textureColor=texture2D(projectionLightSampler,strq.xy).rgb;
+return toLinearSpace(textureColor);
+}
+#ifdef SS_TRANSLUCENCY
+vec3 computeDiffuseAndTransmittedLighting(preLightingInfo info,vec3 lightColor,vec3 transmittance) {
+float NdotL=absEps(info.NdotLUnclamped);
+float wrapNdotL=computeWrappedDiffuseNdotL(NdotL,0.02);
+float trAdapt=step(0.,info.NdotLUnclamped);
+vec3 transmittanceNdotL=mix(transmittance*wrapNdotL,vec3(wrapNdotL),trAdapt);
+float diffuseTerm=diffuseBRDF_Burley(NdotL,info.NdotV,info.VdotH,info.roughness);
+return diffuseTerm*transmittanceNdotL*info.attenuation*lightColor;
+}
+#endif
+#ifdef SPECULARTERM
+vec3 computeSpecularLighting(preLightingInfo info,vec3 N,vec3 reflectance0,vec3 reflectance90,float geometricRoughnessFactor,vec3 lightColor) {
+float NdotH=saturateEps(dot(N,info.H));
+float roughness=max(info.roughness,geometricRoughnessFactor);
+float alphaG=convertRoughnessToAverageSlope(roughness);
+vec3 fresnel=fresnelSchlickGGX(info.VdotH,reflectance0,reflectance90);
+#ifdef IRIDESCENCE
+fresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+float distribution=normalDistributionFunction_TrowbridgeReitzGGX(NdotH,alphaG);
+#ifdef BRDF_V_HEIGHT_CORRELATED
+float smithVisibility=smithVisibility_GGXCorrelated(info.NdotL,info.NdotV,alphaG);
+#else
+float smithVisibility=smithVisibility_TrowbridgeReitzGGXFast(info.NdotL,info.NdotV,alphaG);
+#endif
+vec3 specTerm=fresnel*distribution*smithVisibility;
+return specTerm*info.attenuation*info.NdotL*lightColor;
+}
+#endif
+#ifdef ANISOTROPIC
+vec3 computeAnisotropicSpecularLighting(preLightingInfo info,vec3 V,vec3 N,vec3 T,vec3 B,float anisotropy,vec3 reflectance0,vec3 reflectance90,float geometricRoughnessFactor,vec3 lightColor) {
+float NdotH=saturateEps(dot(N,info.H));
+float TdotH=dot(T,info.H);
+float BdotH=dot(B,info.H);
+float TdotV=dot(T,V);
+float BdotV=dot(B,V);
+float TdotL=dot(T,info.L);
+float BdotL=dot(B,info.L);
+float alphaG=convertRoughnessToAverageSlope(info.roughness);
+vec2 alphaTB=getAnisotropicRoughness(alphaG,anisotropy);
+alphaTB=max(alphaTB,square(geometricRoughnessFactor));
+vec3 fresnel=fresnelSchlickGGX(info.VdotH,reflectance0,reflectance90);
+#ifdef IRIDESCENCE
+fresnel=mix(fresnel,reflectance0,info.iridescenceIntensity);
+#endif
+float distribution=normalDistributionFunction_BurleyGGX_Anisotropic(NdotH,TdotH,BdotH,alphaTB);
+float smithVisibility=smithVisibility_GGXCorrelated_Anisotropic(info.NdotL,info.NdotV,TdotV,BdotV,TdotL,BdotL,alphaTB);
+vec3 specTerm=fresnel*distribution*smithVisibility;
+return specTerm*info.attenuation*info.NdotL*lightColor;
+}
+#endif
+#ifdef CLEARCOAT
+vec4 computeClearCoatLighting(preLightingInfo info,vec3 Ncc,float geometricRoughnessFactor,float clearCoatIntensity,vec3 lightColor) {
+float NccdotL=saturateEps(dot(Ncc,info.L));
+float NccdotH=saturateEps(dot(Ncc,info.H));
+float clearCoatRoughness=max(info.roughness,geometricRoughnessFactor);
+float alphaG=convertRoughnessToAverageSlope(clearCoatRoughness);
+float fresnel=fresnelSchlickGGX(info.VdotH,vClearCoatRefractionParams.x,CLEARCOATREFLECTANCE90);
+fresnel*=clearCoatIntensity;
+float distribution=normalDistributionFunction_TrowbridgeReitzGGX(NccdotH,alphaG);
+float kelemenVisibility=visibility_Kelemen(info.VdotH);
+float clearCoatTerm=fresnel*distribution*kelemenVisibility;
+return vec4(
+clearCoatTerm*info.attenuation*NccdotL*lightColor,
+1.0-fresnel
+);
+}
+vec3 computeClearCoatLightingAbsorption(float NdotVRefract,vec3 L,vec3 Ncc,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {
+vec3 LRefract=-refract(L,Ncc,vClearCoatRefractionParams.y);
+float NdotLRefract=saturateEps(dot(Ncc,LRefract));
+vec3 absorption=computeClearCoatAbsorption(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness,clearCoatIntensity);
+return absorption;
+}
+#endif
+#ifdef SHEEN
+vec3 computeSheenLighting(preLightingInfo info,vec3 N,vec3 reflectance0,vec3 reflectance90,float geometricRoughnessFactor,vec3 lightColor) {
+float NdotH=saturateEps(dot(N,info.H));
+float roughness=max(info.roughness,geometricRoughnessFactor);
+float alphaG=convertRoughnessToAverageSlope(roughness);
+float fresnel=1.;
+float distribution=normalDistributionFunction_CharlieSheen(NdotH,alphaG);
+/*#ifdef SHEEN_SOFTER
+float visibility=visibility_CharlieSheen(info.NdotL,info.NdotV,alphaG);
+#else */
+float visibility=visibility_Ashikhmin(info.NdotL,info.NdotV);
+/* #endif */
+float sheenTerm=fresnel*distribution*visibility;
+return sheenTerm*info.attenuation*info.NdotL*lightColor;
+}
+#endif
+`;
+e.IncludesShadersStore[t] = o;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrDirectLightingSetupFunctions.esm.js

@@ -0,0 +1,53 @@
+import { ShaderStore as t } from "../../Engines/shaderStore.esm.js";
+const e = "pbrDirectLightingSetupFunctions", r = `struct preLightingInfo
+{
+vec3 lightOffset;
+float lightDistanceSquared;
+float lightDistance;
+float attenuation;
+vec3 L;
+vec3 H;
+float NdotV;
+float NdotLUnclamped;
+float NdotL;
+float VdotH;
+float roughness;
+#ifdef IRIDESCENCE
+float iridescenceIntensity;
+#endif
+};
+preLightingInfo computePointAndSpotPreLightingInfo(vec4 lightData,vec3 V,vec3 N) {
+preLightingInfo result;
+result.lightOffset=lightData.xyz-vPositionW;
+result.lightDistanceSquared=dot(result.lightOffset,result.lightOffset);
+result.lightDistance=sqrt(result.lightDistanceSquared);
+result.L=normalize(result.lightOffset);
+result.H=normalize(V+result.L);
+result.VdotH=saturate(dot(V,result.H));
+result.NdotLUnclamped=dot(N,result.L);
+result.NdotL=saturateEps(result.NdotLUnclamped);
+return result;
+}
+preLightingInfo computeDirectionalPreLightingInfo(vec4 lightData,vec3 V,vec3 N) {
+preLightingInfo result;
+result.lightDistance=length(-lightData.xyz);
+result.L=normalize(-lightData.xyz);
+result.H=normalize(V+result.L);
+result.VdotH=saturate(dot(V,result.H));
+result.NdotLUnclamped=dot(N,result.L);
+result.NdotL=saturateEps(result.NdotLUnclamped);
+return result;
+}
+preLightingInfo computeHemisphericPreLightingInfo(vec4 lightData,vec3 V,vec3 N) {
+preLightingInfo result;
+result.NdotL=dot(N,lightData.xyz)*0.5+0.5;
+result.NdotL=saturateEps(result.NdotL);
+result.NdotLUnclamped=result.NdotL;
+#ifdef SPECULARTERM
+result.L=normalize(lightData.xyz);
+result.H=normalize(V+result.L);
+result.VdotH=saturate(dot(V,result.H));
+#endif
+return result;
+}`;
+t.IncludesShadersStore[e] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrFragmentDeclaration.esm.js

@@ -0,0 +1,179 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./decalFragmentDeclaration.esm.js";
+const i = "pbrFragmentDeclaration", f = `uniform vec4 vEyePosition;
+uniform vec3 vReflectionColor;
+uniform vec4 vAlbedoColor;
+uniform vec4 vLightingIntensity;
+uniform vec4 vReflectivityColor;
+uniform vec4 vMetallicReflectanceFactors;
+uniform vec3 vEmissiveColor;
+uniform float visibility;
+uniform vec3 vAmbientColor;
+#ifdef ALBEDO
+uniform vec2 vAlbedoInfos;
+#endif
+#ifdef AMBIENT
+uniform vec4 vAmbientInfos;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;
+uniform vec2 vTangentSpaceParams;
+#endif
+#ifdef OPACITY
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+#endif
+#ifdef REFLECTIVITY
+uniform vec3 vReflectivityInfos;
+#endif
+#ifdef MICROSURFACEMAP
+uniform vec2 vMicroSurfaceSamplerInfos;
+#endif
+#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(SS_REFRACTION) || defined(PREPASS)
+uniform mat4 view;
+#endif
+#ifdef REFLECTION
+uniform vec2 vReflectionInfos;
+#ifdef REALTIME_FILTERING
+uniform vec2 vReflectionFilteringInfo;
+#endif
+uniform mat4 reflectionMatrix;
+uniform vec3 vReflectionMicrosurfaceInfos;
+#if defined(USE_LOCAL_REFLECTIONMAP_CUBIC) && defined(REFLECTIONMAP_CUBIC)
+uniform vec3 vReflectionPosition;
+uniform vec3 vReflectionSize; 
+#endif
+#endif
+#if defined(SS_REFRACTION) && defined(SS_USE_LOCAL_REFRACTIONMAP_CUBIC)
+uniform vec3 vRefractionPosition;
+uniform vec3 vRefractionSize; 
+#endif
+#ifdef CLEARCOAT
+uniform vec2 vClearCoatParams;
+uniform vec4 vClearCoatRefractionParams;
+#if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+uniform vec4 vClearCoatInfos;
+#endif
+#ifdef CLEARCOAT_TEXTURE
+uniform mat4 clearCoatMatrix;
+#endif
+#ifdef CLEARCOAT_TEXTURE_ROUGHNESS
+uniform mat4 clearCoatRoughnessMatrix;
+#endif
+#ifdef CLEARCOAT_BUMP
+uniform vec2 vClearCoatBumpInfos;
+uniform vec2 vClearCoatTangentSpaceParams;
+uniform mat4 clearCoatBumpMatrix;
+#endif
+#ifdef CLEARCOAT_TINT
+uniform vec4 vClearCoatTintParams;
+uniform float clearCoatColorAtDistance;
+#ifdef CLEARCOAT_TINT_TEXTURE
+uniform vec2 vClearCoatTintInfos;
+uniform mat4 clearCoatTintMatrix;
+#endif
+#endif
+#endif
+#ifdef IRIDESCENCE
+uniform vec4 vIridescenceParams;
+#if defined(IRIDESCENCE_TEXTURE) || defined(IRIDESCENCE_THICKNESS_TEXTURE)
+uniform vec4 vIridescenceInfos;
+#endif
+#ifdef IRIDESCENCE_TEXTURE
+uniform mat4 iridescenceMatrix;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+uniform mat4 iridescenceThicknessMatrix;
+#endif
+#endif
+#ifdef ANISOTROPIC
+uniform vec3 vAnisotropy;
+#ifdef ANISOTROPIC_TEXTURE
+uniform vec2 vAnisotropyInfos;
+uniform mat4 anisotropyMatrix;
+#endif
+#endif
+#ifdef SHEEN
+uniform vec4 vSheenColor;
+#ifdef SHEEN_ROUGHNESS
+uniform float vSheenRoughness;
+#endif
+#if defined(SHEEN_TEXTURE) || defined(SHEEN_TEXTURE_ROUGHNESS)
+uniform vec4 vSheenInfos;
+#endif
+#ifdef SHEEN_TEXTURE
+uniform mat4 sheenMatrix;
+#endif
+#ifdef SHEEN_TEXTURE_ROUGHNESS
+uniform mat4 sheenRoughnessMatrix;
+#endif
+#endif
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+uniform vec4 vRefractionMicrosurfaceInfos;
+uniform vec4 vRefractionInfos;
+uniform mat4 refractionMatrix;
+#ifdef REALTIME_FILTERING
+uniform vec2 vRefractionFilteringInfo;
+#endif
+#endif
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+uniform vec2 vThicknessInfos;
+uniform mat4 thicknessMatrix;
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+uniform vec2 vRefractionIntensityInfos;
+uniform mat4 refractionIntensityMatrix;
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+uniform vec2 vTranslucencyIntensityInfos;
+uniform mat4 translucencyIntensityMatrix;
+#endif
+uniform vec2 vThicknessParam;
+uniform vec3 vDiffusionDistance;
+uniform vec4 vTintColor;
+uniform vec3 vSubSurfaceIntensity;
+#endif
+#ifdef PREPASS
+#ifdef SS_SCATTERING
+uniform float scatteringDiffusionProfile;
+#endif
+#endif
+#if DEBUGMODE>0
+uniform vec2 vDebugMode;
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+#endif
+#include<decalFragmentDeclaration>
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+uniform vec3 vSphericalL00;
+uniform vec3 vSphericalL1_1;
+uniform vec3 vSphericalL10;
+uniform vec3 vSphericalL11;
+uniform vec3 vSphericalL2_2;
+uniform vec3 vSphericalL2_1;
+uniform vec3 vSphericalL20;
+uniform vec3 vSphericalL21;
+uniform vec3 vSphericalL22;
+#else
+uniform vec3 vSphericalX;
+uniform vec3 vSphericalY;
+uniform vec3 vSphericalZ;
+uniform vec3 vSphericalXX_ZZ;
+uniform vec3 vSphericalYY_ZZ;
+uniform vec3 vSphericalZZ;
+uniform vec3 vSphericalXY;
+uniform vec3 vSphericalYZ;
+uniform vec3 vSphericalZX;
+#endif
+#endif
+#define ADDITIONAL_FRAGMENT_DECLARATION
+`;
+e.IncludesShadersStore[i] = f;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrFragmentExtraDeclaration.esm.js

@@ -0,0 +1,18 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./mainUVVaryingDeclaration.esm.js";
+const i = "pbrFragmentExtraDeclaration", n = `varying vec3 vPositionW;
+#if DEBUGMODE>0
+varying vec4 vClipSpacePosition;
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#ifdef NORMAL
+varying vec3 vNormalW;
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+varying vec3 vEnvironmentIrradiance;
+#endif
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+`;
+e.IncludesShadersStore[i] = n;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrFragmentSamplersDeclaration.esm.js

@@ -0,0 +1,101 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./samplerFragmentDeclaration.esm.js";
+import "./samplerFragmentAlternateDeclaration.esm.js";
+const E = "pbrFragmentSamplersDeclaration", r = `#include<samplerFragmentDeclaration>(_DEFINENAME_,ALBEDO,_VARYINGNAME_,Albedo,_SAMPLERNAME_,albedo)
+#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_,REFLECTIVITY,_VARYINGNAME_,Reflectivity,_SAMPLERNAME_,reflectivity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,MICROSURFACEMAP,_VARYINGNAME_,MicroSurfaceSampler,_SAMPLERNAME_,microSurface)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,METALLIC_REFLECTANCE,_VARYINGNAME_,MetallicReflectance,_SAMPLERNAME_,metallicReflectance)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,REFLECTANCE,_VARYINGNAME_,Reflectance,_SAMPLERNAME_,reflectance)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_SAMPLERNAME_,decal)
+#ifdef CLEARCOAT
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE,_VARYINGNAME_,ClearCoat,_SAMPLERNAME_,clearCoat)
+#include<samplerFragmentAlternateDeclaration>(_DEFINENAME_,CLEARCOAT_TEXTURE_ROUGHNESS,_VARYINGNAME_,ClearCoatRoughness)
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL)
+uniform sampler2D clearCoatRoughnessSampler;
+#endif
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_BUMP,_VARYINGNAME_,ClearCoatBump,_SAMPLERNAME_,clearCoatBump)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,CLEARCOAT_TINT_TEXTURE,_VARYINGNAME_,ClearCoatTint,_SAMPLERNAME_,clearCoatTint)
+#endif
+#ifdef IRIDESCENCE
+#include<samplerFragmentDeclaration>(_DEFINENAME_,IRIDESCENCE_TEXTURE,_VARYINGNAME_,Iridescence,_SAMPLERNAME_,iridescence)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,IRIDESCENCE_THICKNESS_TEXTURE,_VARYINGNAME_,IridescenceThickness,_SAMPLERNAME_,iridescenceThickness)
+#endif
+#ifdef SHEEN
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SHEEN_TEXTURE,_VARYINGNAME_,Sheen,_SAMPLERNAME_,sheen)
+#include<samplerFragmentAlternateDeclaration>(_DEFINENAME_,SHEEN_TEXTURE_ROUGHNESS,_VARYINGNAME_,SheenRoughness)
+#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL)
+uniform sampler2D sheenRoughnessSampler;
+#endif
+#endif
+#ifdef ANISOTROPIC
+#include<samplerFragmentDeclaration>(_DEFINENAME_,ANISOTROPIC_TEXTURE,_VARYINGNAME_,Anisotropy,_SAMPLERNAME_,anisotropy)
+#endif
+#ifdef REFLECTION
+#ifdef REFLECTIONMAP_3D
+#define sampleReflection(s,c) textureCube(s,c)
+uniform samplerCube reflectionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleReflectionLod(s,c,l) textureCubeLodEXT(s,c,l)
+#else
+uniform samplerCube reflectionSamplerLow;
+uniform samplerCube reflectionSamplerHigh;
+#endif
+#ifdef USEIRRADIANCEMAP
+uniform samplerCube irradianceSampler;
+#endif
+#else
+#define sampleReflection(s,c) texture2D(s,c)
+uniform sampler2D reflectionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleReflectionLod(s,c,l) texture2DLodEXT(s,c,l)
+#else
+uniform sampler2D reflectionSamplerLow;
+uniform sampler2D reflectionSamplerHigh;
+#endif
+#ifdef USEIRRADIANCEMAP
+uniform sampler2D irradianceSampler;
+#endif
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+varying vec3 vPositionUVW;
+#else
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vec3 vDirectionW;
+#endif
+#endif
+#endif
+#ifdef ENVIRONMENTBRDF
+uniform sampler2D environmentBrdfSampler;
+#endif
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+#ifdef SS_REFRACTIONMAP_3D
+#define sampleRefraction(s,c) textureCube(s,c)
+uniform samplerCube refractionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleRefractionLod(s,c,l) textureCubeLodEXT(s,c,l)
+#else
+uniform samplerCube refractionSamplerLow;
+uniform samplerCube refractionSamplerHigh;
+#endif
+#else
+#define sampleRefraction(s,c) texture2D(s,c)
+uniform sampler2D refractionSampler;
+#ifdef LODBASEDMICROSFURACE
+#define sampleRefractionLod(s,c,l) texture2DLodEXT(s,c,l)
+#else
+uniform sampler2D refractionSamplerLow;
+uniform sampler2D refractionSamplerHigh;
+#endif
+#endif
+#endif
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_THICKNESSANDMASK_TEXTURE,_VARYINGNAME_,Thickness,_SAMPLERNAME_,thickness)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_REFRACTIONINTENSITY_TEXTURE,_VARYINGNAME_,RefractionIntensity,_SAMPLERNAME_,refractionIntensity)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SS_TRANSLUCENCYINTENSITY_TEXTURE,_VARYINGNAME_,TranslucencyIntensity,_SAMPLERNAME_,translucencyIntensity)
+#endif
+`;
+e.IncludesShadersStore[E] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrHelperFunctions.esm.js

@@ -0,0 +1,83 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "pbrHelperFunctions", a = `#define RECIPROCAL_PI2 0.15915494
+#define RECIPROCAL_PI 0.31830988618
+#define MINIMUMVARIANCE 0.0005
+float convertRoughnessToAverageSlope(float roughness)
+{
+return square(roughness)+MINIMUMVARIANCE;
+}
+float fresnelGrazingReflectance(float reflectance0) {
+float reflectance90=saturate(reflectance0*25.0);
+return reflectance90;
+}
+vec2 getAARoughnessFactors(vec3 normalVector) {
+#ifdef SPECULARAA
+vec3 nDfdx=dFdx(normalVector.xyz);
+vec3 nDfdy=dFdy(normalVector.xyz);
+float slopeSquare=max(dot(nDfdx,nDfdx),dot(nDfdy,nDfdy));
+float geometricRoughnessFactor=pow(saturate(slopeSquare),0.333);
+float geometricAlphaGFactor=sqrt(slopeSquare);
+geometricAlphaGFactor*=0.75;
+return vec2(geometricRoughnessFactor,geometricAlphaGFactor);
+#else
+return vec2(0.);
+#endif
+}
+#ifdef ANISOTROPIC
+#ifdef ANISOTROPIC_LEGACY
+vec2 getAnisotropicRoughness(float alphaG,float anisotropy) {
+float alphaT=max(alphaG*(1.0+anisotropy),MINIMUMVARIANCE);
+float alphaB=max(alphaG*(1.0-anisotropy),MINIMUMVARIANCE);
+return vec2(alphaT,alphaB);
+}
+vec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {
+vec3 anisotropicFrameDirection=anisotropy>=0.0 ? B : T;
+vec3 anisotropicFrameTangent=cross(normalize(anisotropicFrameDirection),V);
+vec3 anisotropicFrameNormal=cross(anisotropicFrameTangent,anisotropicFrameDirection);
+vec3 anisotropicNormal=normalize(mix(N,anisotropicFrameNormal,abs(anisotropy)));
+return anisotropicNormal;
+}
+#else
+vec2 getAnisotropicRoughness(float alphaG,float anisotropy) {
+float alphaT=max(mix(alphaG,1.0,anisotropy*anisotropy),MINIMUMVARIANCE);
+float alphaB=max(alphaG,MINIMUMVARIANCE);
+return vec2(alphaT,alphaB);
+}
+vec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {
+vec3 bentNormal=cross(B,V);
+bentNormal=normalize(cross(bentNormal,B));
+float a=square(square(1.0-anisotropy*(1.0-roughness)));
+bentNormal=normalize(mix(bentNormal,N,a));
+return bentNormal;
+}
+#endif
+#endif
+#if defined(CLEARCOAT) || defined(SS_REFRACTION)
+vec3 cocaLambert(vec3 alpha,float distance) {
+return exp(-alpha*distance);
+}
+vec3 cocaLambert(float NdotVRefract,float NdotLRefract,vec3 alpha,float thickness) {
+return cocaLambert(alpha,(thickness*((NdotLRefract+NdotVRefract)/(NdotLRefract*NdotVRefract))));
+}
+vec3 computeColorAtDistanceInMedia(vec3 color,float distance) {
+return -log(color)/distance;
+}
+vec3 computeClearCoatAbsorption(float NdotVRefract,float NdotLRefract,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {
+vec3 clearCoatAbsorption=mix(vec3(1.0),
+cocaLambert(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness),
+clearCoatIntensity);
+return clearCoatAbsorption;
+}
+#endif
+#ifdef MICROSURFACEAUTOMATIC
+float computeDefaultMicroSurface(float microSurface,vec3 reflectivityColor)
+{
+const float kReflectivityNoAlphaWorkflow_SmoothnessMax=0.95;
+float reflectivityLuminance=getLuminance(reflectivityColor);
+float reflectivityLuma=sqrt(reflectivityLuminance);
+microSurface=reflectivityLuma*kReflectivityNoAlphaWorkflow_SmoothnessMax;
+return microSurface;
+}
+#endif
+`;
+e.IncludesShadersStore[o] = a;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrIBLFunctions.esm.js

@@ -0,0 +1,35 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "pbrIBLFunctions", a = `#if defined(REFLECTION) || defined(SS_REFRACTION)
+float getLodFromAlphaG(float cubeMapDimensionPixels,float microsurfaceAverageSlope) {
+float microsurfaceAverageSlopeTexels=cubeMapDimensionPixels*microsurfaceAverageSlope;
+float lod=log2(microsurfaceAverageSlopeTexels);
+return lod;
+}
+float getLinearLodFromRoughness(float cubeMapDimensionPixels,float roughness) {
+float lod=log2(cubeMapDimensionPixels)*roughness;
+return lod;
+}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(RADIANCEOCCLUSION)
+float environmentRadianceOcclusion(float ambientOcclusion,float NdotVUnclamped) {
+float temp=NdotVUnclamped+ambientOcclusion;
+return saturate(square(temp)-1.0+ambientOcclusion);
+}
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(HORIZONOCCLUSION)
+float environmentHorizonOcclusion(vec3 view,vec3 normal,vec3 geometricNormal) {
+vec3 reflection=reflect(view,normal);
+float temp=saturate(1.0+1.1*dot(reflection,geometricNormal));
+return square(temp);
+}
+#endif
+#if defined(LODINREFLECTIONALPHA) || defined(SS_LODINREFRACTIONALPHA)
+#define UNPACK_LOD(x) (1.0-x)*255.0
+float getLodFromAlphaG(float cubeMapDimensionPixels,float alphaG,float NdotV) {
+float microsurfaceAverageSlope=alphaG;
+microsurfaceAverageSlope*=sqrt(abs(NdotV));
+return getLodFromAlphaG(cubeMapDimensionPixels,microsurfaceAverageSlope);
+}
+#endif
+`;
+e.IncludesShadersStore[o] = a;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrUboDeclaration.esm.js

@@ -0,0 +1,65 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./sceneUboDeclaration.esm.js";
+import "./meshUboDeclaration.esm.js";
+const c = "pbrUboDeclaration", v = `layout(std140,column_major) uniform;
+uniform Material {
+vec2 vAlbedoInfos;
+vec4 vAmbientInfos;
+vec2 vOpacityInfos;
+vec2 vEmissiveInfos;
+vec2 vLightmapInfos;
+vec3 vReflectivityInfos;
+vec2 vMicroSurfaceSamplerInfos;
+vec2 vReflectionInfos;
+vec2 vReflectionFilteringInfo;
+vec3 vReflectionPosition;
+vec3 vReflectionSize;
+vec3 vBumpInfos;
+mat4 albedoMatrix;
+mat4 ambientMatrix;
+mat4 opacityMatrix;
+mat4 emissiveMatrix;
+mat4 lightmapMatrix;
+mat4 reflectivityMatrix;
+mat4 microSurfaceSamplerMatrix;
+mat4 bumpMatrix;
+vec2 vTangentSpaceParams;
+mat4 reflectionMatrix;
+vec3 vReflectionColor;
+vec4 vAlbedoColor;
+vec4 vLightingIntensity;
+vec3 vReflectionMicrosurfaceInfos;
+float pointSize;
+vec4 vReflectivityColor;
+vec3 vEmissiveColor;
+vec3 vAmbientColor;
+vec2 vDebugMode;
+vec4 vMetallicReflectanceFactors;
+vec2 vMetallicReflectanceInfos;
+mat4 metallicReflectanceMatrix;
+vec2 vReflectanceInfos;
+mat4 reflectanceMatrix;
+vec3 vSphericalL00;
+vec3 vSphericalL1_1;
+vec3 vSphericalL10;
+vec3 vSphericalL11;
+vec3 vSphericalL2_2;
+vec3 vSphericalL2_1;
+vec3 vSphericalL20;
+vec3 vSphericalL21;
+vec3 vSphericalL22;
+vec3 vSphericalX;
+vec3 vSphericalY;
+vec3 vSphericalZ;
+vec3 vSphericalXX_ZZ;
+vec3 vSphericalYY_ZZ;
+vec3 vSphericalZZ;
+vec3 vSphericalXY;
+vec3 vSphericalYZ;
+vec3 vSphericalZX;
+#define ADDITIONAL_UBO_DECLARATION
+};
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;
+e.IncludesShadersStore[c] = v;