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

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

@@ -1,130 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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;