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

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

@@ -0,0 +1,17 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "morphTargetsVertexDeclaration", i = `#ifdef MORPHTARGETS
+#ifndef MORPHTARGETS_TEXTURE
+attribute vec3 position{X};
+#ifdef MORPHTARGETS_NORMAL
+attribute vec3 normal{X};
+#endif
+#ifdef MORPHTARGETS_TANGENT
+attribute vec3 tangent{X};
+#endif
+#ifdef MORPHTARGETS_UV
+attribute vec2 uv_{X};
+#endif
+#endif
+#endif
+`;
+e.IncludesShadersStore[t] = i;

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

@@ -0,0 +1,8 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "morphTargetsVertexGlobal", o = `#ifdef MORPHTARGETS
+#ifdef MORPHTARGETS_TEXTURE
+float vertexID;
+#endif
+#endif
+`;
+e.IncludesShadersStore[r] = o;

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

@@ -0,0 +1,19 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "morphTargetsVertexGlobalDeclaration", t = `#ifdef MORPHTARGETS
+uniform float morphTargetInfluences[NUM_MORPH_INFLUENCERS];
+#ifdef MORPHTARGETS_TEXTURE 
+precision mediump sampler2DArray; 
+uniform float morphTargetTextureIndices[NUM_MORPH_INFLUENCERS];
+uniform vec3 morphTargetTextureInfo;
+uniform sampler2DArray morphTargets;
+vec3 readVector3FromRawSampler(int targetIndex,float vertexIndex)
+{ 
+float y=floor(vertexIndex/morphTargetTextureInfo.y);
+float x=vertexIndex-y*morphTargetTextureInfo.y;
+vec3 textureUV=vec3((x+0.5)/morphTargetTextureInfo.y,(y+0.5)/morphTargetTextureInfo.z,morphTargetTextureIndices[targetIndex]);
+return texture(morphTargets,textureUV).xyz;
+}
+#endif
+#endif
+`;
+e.IncludesShadersStore[r] = t;

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

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "mrtFragmentDeclaration", t = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+layout(location=0) out vec4 glFragData[{X}];
+#endif
+`;
+e.IncludesShadersStore[a] = t;

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

@@ -0,0 +1,13 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const e = "oitDeclaration", r = `#ifdef ORDER_INDEPENDENT_TRANSPARENCY
+#extension GL_EXT_draw_buffers : require
+layout(location=0) out vec2 depth; 
+layout(location=1) out vec4 frontColor;
+layout(location=2) out vec4 backColor;
+#define MAX_DEPTH 99999.0
+highp vec4 gl_FragColor;
+uniform sampler2D oitDepthSampler;
+uniform sampler2D oitFrontColorSampler;
+#endif
+`;
+o.IncludesShadersStore[e] = r;

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

@@ -0,0 +1,40 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "oitFragment", r = `#ifdef ORDER_INDEPENDENT_TRANSPARENCY
+float fragDepth=gl_FragCoord.z; 
+#ifdef ORDER_INDEPENDENT_TRANSPARENCY_16BITS
+uint halfFloat=packHalf2x16(vec2(fragDepth));
+vec2 full=unpackHalf2x16(halfFloat);
+fragDepth=full.x;
+#endif
+ivec2 fragCoord=ivec2(gl_FragCoord.xy);
+vec2 lastDepth=texelFetch(oitDepthSampler,fragCoord,0).rg;
+vec4 lastFrontColor=texelFetch(oitFrontColorSampler,fragCoord,0);
+depth.rg=vec2(-MAX_DEPTH);
+frontColor=lastFrontColor;
+backColor=vec4(0.0);
+#ifdef USE_REVERSE_DEPTHBUFFER
+float furthestDepth=-lastDepth.x;
+float nearestDepth=lastDepth.y;
+#else
+float nearestDepth=-lastDepth.x;
+float furthestDepth=lastDepth.y;
+#endif
+float alphaMultiplier=1.0-lastFrontColor.a;
+#ifdef USE_REVERSE_DEPTHBUFFER
+if (fragDepth>nearestDepth || fragDepth<furthestDepth) {
+#else
+if (fragDepth<nearestDepth || fragDepth>furthestDepth) {
+#endif
+return;
+}
+#ifdef USE_REVERSE_DEPTHBUFFER
+if (fragDepth<nearestDepth && fragDepth>furthestDepth) {
+#else
+if (fragDepth>nearestDepth && fragDepth<furthestDepth) {
+#endif
+depth.rg=vec2(-fragDepth,fragDepth);
+return;
+}
+#endif
+`;
+e.IncludesShadersStore[t] = r;

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

@@ -0,0 +1,15 @@
+import { ShaderStore as t } from "../../Engines/shaderStore.esm.js";
+const e = "packingFunctions", c = `vec4 pack(float depth)
+{
+const vec4 bit_shift=vec4(255.0*255.0*255.0,255.0*255.0,255.0,1.0);
+const vec4 bit_mask=vec4(0.0,1.0/255.0,1.0/255.0,1.0/255.0);
+vec4 res=fract(depth*bit_shift);
+res-=res.xxyz*bit_mask;
+return res;
+}
+float unpack(vec4 color)
+{
+const vec4 bit_shift=vec4(1.0/(255.0*255.0*255.0),1.0/(255.0*255.0),1.0/255.0,1.0);
+return dot(color,bit_shift);
+}`;
+t.IncludesShadersStore[e] = c;

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

@@ -0,0 +1,268 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const t = "pbrBRDFFunctions", a = `#define FRESNEL_MAXIMUM_ON_ROUGH 0.25
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+vec3 getEnergyConservationFactor(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {
+return 1.0+specularEnvironmentR0*(1.0/environmentBrdf.y-1.0);
+}
+#endif
+#ifdef ENVIRONMENTBRDF
+vec3 getBRDFLookup(float NdotV,float perceptualRoughness) {
+vec2 UV=vec2(NdotV,perceptualRoughness);
+vec4 brdfLookup=texture2D(environmentBrdfSampler,UV);
+#ifdef ENVIRONMENTBRDF_RGBD
+brdfLookup.rgb=fromRGBD(brdfLookup.rgba);
+#endif
+return brdfLookup.rgb;
+}
+vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 specularEnvironmentR90,const vec3 environmentBrdf) {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+vec3 reflectance=(specularEnvironmentR90-specularEnvironmentR0)*environmentBrdf.x+specularEnvironmentR0*environmentBrdf.y;
+#else
+vec3 reflectance=specularEnvironmentR0*environmentBrdf.x+specularEnvironmentR90*environmentBrdf.y;
+#endif
+return reflectance;
+}
+vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+vec3 reflectance=mix(environmentBrdf.xxx,environmentBrdf.yyy,specularEnvironmentR0);
+#else
+vec3 reflectance=specularEnvironmentR0*environmentBrdf.x+environmentBrdf.y;
+#endif
+return reflectance;
+}
+#endif
+/* NOT USED
+#if defined(SHEEN) && defined(SHEEN_SOFTER)
+float getBRDFLookupCharlieSheen(float NdotV,float perceptualRoughness)
+{
+float c=1.0-NdotV;
+float c3=c*c*c;
+return 0.65584461*c3+1.0/(4.16526551+exp(-7.97291361*perceptualRoughness+6.33516894));
+}
+#endif
+*/
+#if !defined(ENVIRONMENTBRDF) || defined(REFLECTIONMAP_SKYBOX) || defined(ALPHAFRESNEL)
+vec3 getReflectanceFromAnalyticalBRDFLookup_Jones(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)
+{
+float weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);
+return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));
+}
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF)
+/**
+* The sheen BRDF not containing F can be easily stored in the blue channel of the BRDF texture.
+* The blue channel contains DCharlie*VAshikhmin*NdotL as a lokkup table
+*/
+vec3 getSheenReflectanceFromBRDFLookup(const vec3 reflectance0,const vec3 environmentBrdf) {
+vec3 sheenEnvironmentReflectance=reflectance0*environmentBrdf.b;
+return sheenEnvironmentReflectance;
+}
+#endif
+vec3 fresnelSchlickGGX(float VdotH,vec3 reflectance0,vec3 reflectance90)
+{
+return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);
+}
+float fresnelSchlickGGX(float VdotH,float reflectance0,float reflectance90)
+{
+return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);
+}
+#ifdef CLEARCOAT
+vec3 getR0RemappedForClearCoat(vec3 f0) {
+#ifdef CLEARCOAT_DEFAULTIOR
+#ifdef MOBILE
+return saturate(f0*(f0*0.526868+0.529324)-0.0482256);
+#else
+return saturate(f0*(f0*(0.941892-0.263008*f0)+0.346479)-0.0285998);
+#endif
+#else
+vec3 s=sqrt(f0);
+vec3 t=(vClearCoatRefractionParams.z+vClearCoatRefractionParams.w*s)/(vClearCoatRefractionParams.w+vClearCoatRefractionParams.z*s);
+return square(t);
+#endif
+}
+#endif
+#ifdef IRIDESCENCE
+const mat3 XYZ_TO_REC709=mat3(
+3.2404542,-0.9692660, 0.0556434,
+-1.5371385, 1.8760108,-0.2040259,
+-0.4985314, 0.0415560, 1.0572252
+);
+vec3 getIORTfromAirToSurfaceR0(vec3 f0) {
+vec3 sqrtF0=sqrt(f0);
+return (1.+sqrtF0)/(1.-sqrtF0);
+}
+vec3 getR0fromIORs(vec3 iorT,float iorI) {
+return square((iorT-vec3(iorI))/(iorT+vec3(iorI)));
+}
+float getR0fromIORs(float iorT,float iorI) {
+return square((iorT-iorI)/(iorT+iorI));
+}
+vec3 evalSensitivity(float opd,vec3 shift) {
+float phase=2.0*PI*opd*1.0e-9;
+const vec3 val=vec3(5.4856e-13,4.4201e-13,5.2481e-13);
+const vec3 pos=vec3(1.6810e+06,1.7953e+06,2.2084e+06);
+const vec3 var=vec3(4.3278e+09,9.3046e+09,6.6121e+09);
+vec3 xyz=val*sqrt(2.0*PI*var)*cos(pos*phase+shift)*exp(-square(phase)*var);
+xyz.x+=9.7470e-14*sqrt(2.0*PI*4.5282e+09)*cos(2.2399e+06*phase+shift[0])*exp(-4.5282e+09*square(phase));
+xyz/=1.0685e-7;
+vec3 srgb=XYZ_TO_REC709*xyz;
+return srgb;
+}
+vec3 evalIridescence(float outsideIOR,float eta2,float cosTheta1,float thinFilmThickness,vec3 baseF0) {
+vec3 I=vec3(1.0);
+float iridescenceIOR=mix(outsideIOR,eta2,smoothstep(0.0,0.03,thinFilmThickness));
+float sinTheta2Sq=square(outsideIOR/iridescenceIOR)*(1.0-square(cosTheta1));
+float cosTheta2Sq=1.0-sinTheta2Sq;
+if (cosTheta2Sq<0.0) {
+return I;
+}
+float cosTheta2=sqrt(cosTheta2Sq);
+float R0=getR0fromIORs(iridescenceIOR,outsideIOR);
+float R12=fresnelSchlickGGX(cosTheta1,R0,1.);
+float R21=R12;
+float T121=1.0-R12;
+float phi12=0.0;
+if (iridescenceIOR<outsideIOR) phi12=PI;
+float phi21=PI-phi12;
+vec3 baseIOR=getIORTfromAirToSurfaceR0(clamp(baseF0,0.0,0.9999)); 
+vec3 R1=getR0fromIORs(baseIOR,iridescenceIOR);
+vec3 R23=fresnelSchlickGGX(cosTheta2,R1,vec3(1.));
+vec3 phi23=vec3(0.0);
+if (baseIOR[0]<iridescenceIOR) phi23[0]=PI;
+if (baseIOR[1]<iridescenceIOR) phi23[1]=PI;
+if (baseIOR[2]<iridescenceIOR) phi23[2]=PI;
+float opd=2.0*iridescenceIOR*thinFilmThickness*cosTheta2;
+vec3 phi=vec3(phi21)+phi23;
+vec3 R123=clamp(R12*R23,1e-5,0.9999);
+vec3 r123=sqrt(R123);
+vec3 Rs=square(T121)*R23/(vec3(1.0)-R123);
+vec3 C0=R12+Rs;
+I=C0;
+vec3 Cm=Rs-T121;
+for (int m=1; m<=2; ++m)
+{
+Cm*=r123;
+vec3 Sm=2.0*evalSensitivity(float(m)*opd,float(m)*phi);
+I+=Cm*Sm;
+}
+return max(I,vec3(0.0));
+}
+#endif
+float normalDistributionFunction_TrowbridgeReitzGGX(float NdotH,float alphaG)
+{
+float a2=square(alphaG);
+float d=NdotH*NdotH*(a2-1.0)+1.0;
+return a2/(PI*d*d);
+}
+#ifdef SHEEN
+float normalDistributionFunction_CharlieSheen(float NdotH,float alphaG)
+{
+float invR=1./alphaG;
+float cos2h=NdotH*NdotH;
+float sin2h=1.-cos2h;
+return (2.+invR)*pow(sin2h,invR*.5)/(2.*PI);
+}
+#endif
+#ifdef ANISOTROPIC
+float normalDistributionFunction_BurleyGGX_Anisotropic(float NdotH,float TdotH,float BdotH,const vec2 alphaTB) {
+float a2=alphaTB.x*alphaTB.y;
+vec3 v=vec3(alphaTB.y*TdotH,alphaTB.x *BdotH,a2*NdotH);
+float v2=dot(v,v);
+float w2=a2/v2;
+return a2*w2*w2*RECIPROCAL_PI;
+}
+#endif
+#ifdef BRDF_V_HEIGHT_CORRELATED
+float smithVisibility_GGXCorrelated(float NdotL,float NdotV,float alphaG) {
+#ifdef MOBILE
+float GGXV=NdotL*(NdotV*(1.0-alphaG)+alphaG);
+float GGXL=NdotV*(NdotL*(1.0-alphaG)+alphaG);
+return 0.5/(GGXV+GGXL);
+#else
+float a2=alphaG*alphaG;
+float GGXV=NdotL*sqrt(NdotV*(NdotV-a2*NdotV)+a2);
+float GGXL=NdotV*sqrt(NdotL*(NdotL-a2*NdotL)+a2);
+return 0.5/(GGXV+GGXL);
+#endif
+}
+#else
+float smithVisibilityG1_TrowbridgeReitzGGXFast(float dot,float alphaG)
+{
+#ifdef MOBILE
+return 1.0/(dot+alphaG+(1.0-alphaG)*dot ));
+#else
+float alphaSquared=alphaG*alphaG;
+return 1.0/(dot+sqrt(alphaSquared+(1.0-alphaSquared)*dot*dot));
+#endif
+}
+float smithVisibility_TrowbridgeReitzGGXFast(float NdotL,float NdotV,float alphaG)
+{
+float visibility=smithVisibilityG1_TrowbridgeReitzGGXFast(NdotL,alphaG)*smithVisibilityG1_TrowbridgeReitzGGXFast(NdotV,alphaG);
+return visibility;
+}
+#endif
+#ifdef ANISOTROPIC
+float smithVisibility_GGXCorrelated_Anisotropic(float NdotL,float NdotV,float TdotV,float BdotV,float TdotL,float BdotL,const vec2 alphaTB) {
+float lambdaV=NdotL*length(vec3(alphaTB.x*TdotV,alphaTB.y*BdotV,NdotV));
+float lambdaL=NdotV*length(vec3(alphaTB.x*TdotL,alphaTB.y*BdotL,NdotL));
+float v=0.5/(lambdaV+lambdaL);
+return v;
+}
+#endif
+#ifdef CLEARCOAT
+float visibility_Kelemen(float VdotH) {
+return 0.25/(VdotH*VdotH); 
+}
+#endif
+#ifdef SHEEN
+float visibility_Ashikhmin(float NdotL,float NdotV)
+{
+return 1./(4.*(NdotL+NdotV-NdotL*NdotV));
+}
+/* NOT USED
+#ifdef SHEEN_SOFTER
+float l(float x,float alphaG)
+{
+float oneMinusAlphaSq=(1.0-alphaG)*(1.0-alphaG);
+float a=mix(21.5473,25.3245,oneMinusAlphaSq);
+float b=mix(3.82987,3.32435,oneMinusAlphaSq);
+float c=mix(0.19823,0.16801,oneMinusAlphaSq);
+float d=mix(-1.97760,-1.27393,oneMinusAlphaSq);
+float e=mix(-4.32054,-4.85967,oneMinusAlphaSq);
+return a/(1.0+b*pow(x,c))+d*x+e;
+}
+float lambdaSheen(float cosTheta,float alphaG)
+{
+return abs(cosTheta)<0.5 ? exp(l(cosTheta,alphaG)) : exp(2.0*l(0.5,alphaG)-l(1.0-cosTheta,alphaG));
+}
+float visibility_CharlieSheen(float NdotL,float NdotV,float alphaG)
+{
+float G=1.0/(1.0+lambdaSheen(NdotV,alphaG)+lambdaSheen(NdotL,alphaG));
+return G/(4.0*NdotV*NdotL);
+}
+#endif
+*/
+#endif
+float diffuseBRDF_Burley(float NdotL,float NdotV,float VdotH,float roughness) {
+float diffuseFresnelNV=pow5(saturateEps(1.0-NdotL));
+float diffuseFresnelNL=pow5(saturateEps(1.0-NdotV));
+float diffuseFresnel90=0.5+2.0*VdotH*VdotH*roughness;
+float fresnel =
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNL) *
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNV);
+return fresnel/PI;
+}
+#ifdef SS_TRANSLUCENCY
+vec3 transmittanceBRDF_Burley(const vec3 tintColor,const vec3 diffusionDistance,float thickness) {
+vec3 S=1./maxEps(diffusionDistance);
+vec3 temp=exp((-0.333333333*thickness)*S);
+return tintColor.rgb*0.25*(temp*temp*temp+3.0*temp);
+}
+float computeWrappedDiffuseNdotL(float NdotL,float w) {
+float t=1.0+w;
+float invt2=1.0/square(t);
+return saturate((NdotL+w)*invt2);
+}
+#endif
+`;
+e.IncludesShadersStore[t] = a;

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

@@ -0,0 +1,83 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+import "./decalFragment.esm.js";
+const d = "pbrBlockAlbedoOpacity", a = `struct albedoOpacityOutParams
+{
+vec3 surfaceAlbedo;
+float alpha;
+};
+#define pbr_inline
+void albedoOpacityBlock(
+in vec4 vAlbedoColor,
+#ifdef ALBEDO
+in vec4 albedoTexture,
+in vec2 albedoInfos,
+#endif
+#ifdef OPACITY
+in vec4 opacityMap,
+in vec2 vOpacityInfos,
+#endif
+#ifdef DETAIL
+in vec4 detailColor,
+in vec4 vDetailInfos,
+#endif
+#ifdef DECAL
+in vec4 decalColor,
+in vec4 vDecalInfos,
+#endif
+out albedoOpacityOutParams outParams
+)
+{
+vec3 surfaceAlbedo=vAlbedoColor.rgb;
+float alpha=vAlbedoColor.a;
+#ifdef ALBEDO
+#if defined(ALPHAFROMALBEDO) || defined(ALPHATEST)
+alpha*=albedoTexture.a;
+#endif
+#ifdef GAMMAALBEDO
+surfaceAlbedo*=toLinearSpace(albedoTexture.rgb);
+#else
+surfaceAlbedo*=albedoTexture.rgb;
+#endif
+surfaceAlbedo*=albedoInfos.y;
+#endif
+#ifndef DECAL_AFTER_DETAIL
+#include<decalFragment>
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+surfaceAlbedo*=vColor.rgb;
+#endif
+#ifdef DETAIL
+float detailAlbedo=2.0*mix(0.5,detailColor.r,vDetailInfos.y);
+surfaceAlbedo.rgb=surfaceAlbedo.rgb*detailAlbedo*detailAlbedo; 
+#endif
+#ifdef DECAL_AFTER_DETAIL
+#include<decalFragment>
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_ALBEDO
+#ifdef OPACITY
+#ifdef OPACITYRGB
+alpha=getLuminance(opacityMap.rgb);
+#else
+alpha*=opacityMap.a;
+#endif
+alpha*=vOpacityInfos.y;
+#endif
+#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+alpha*=vColor.a;
+#endif
+#if !defined(SS_LINKREFRACTIONTOTRANSPARENCY) && !defined(ALPHAFRESNEL)
+#ifdef ALPHATEST 
+#if DEBUGMODE != 88
+if (alpha<ALPHATESTVALUE)
+discard;
+#endif
+#ifndef ALPHABLEND
+alpha=1.0;
+#endif
+#endif
+#endif
+outParams.surfaceAlbedo=surfaceAlbedo;
+outParams.alpha=alpha;
+}
+`;
+e.IncludesShadersStore[d] = a;

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

@@ -0,0 +1,37 @@
+import { ShaderStore as a } from "../../Engines/shaderStore.esm.js";
+const e = "pbrBlockAlphaFresnel", o = `#ifdef ALPHAFRESNEL
+#if defined(ALPHATEST) || defined(ALPHABLEND)
+struct alphaFresnelOutParams
+{
+float alpha;
+};
+#define pbr_inline
+void alphaFresnelBlock(
+in vec3 normalW,
+in vec3 viewDirectionW,
+in float alpha,
+in float microSurface,
+out alphaFresnelOutParams outParams
+)
+{
+float opacityPerceptual=alpha;
+#ifdef LINEARALPHAFRESNEL
+float opacity0=opacityPerceptual;
+#else
+float opacity0=opacityPerceptual*opacityPerceptual;
+#endif
+float opacity90=fresnelGrazingReflectance(opacity0);
+vec3 normalForward=faceforward(normalW,-viewDirectionW,normalW);
+outParams.alpha=getReflectanceFromAnalyticalBRDFLookup_Jones(saturate(dot(viewDirectionW,normalForward)),vec3(opacity0),vec3(opacity90),sqrt(microSurface)).x;
+#ifdef ALPHATEST
+if (outParams.alpha<ALPHATESTVALUE)
+discard;
+#ifndef ALPHABLEND
+outParams.alpha=1.0;
+#endif
+#endif
+}
+#endif
+#endif
+`;
+a.IncludesShadersStore[e] = o;

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

@@ -0,0 +1,32 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockAmbientOcclusion", n = `struct ambientOcclusionOutParams
+{
+vec3 ambientOcclusionColor;
+#if DEBUGMODE>0 && defined(AMBIENT)
+vec3 ambientOcclusionColorMap;
+#endif
+};
+#define pbr_inline
+void ambientOcclusionBlock(
+#ifdef AMBIENT
+in vec3 ambientOcclusionColorMap_,
+in vec4 vAmbientInfos,
+#endif
+out ambientOcclusionOutParams outParams
+)
+{
+vec3 ambientOcclusionColor=vec3(1.,1.,1.);
+#ifdef AMBIENT
+vec3 ambientOcclusionColorMap=ambientOcclusionColorMap_*vAmbientInfos.y;
+#ifdef AMBIENTINGRAYSCALE
+ambientOcclusionColorMap=vec3(ambientOcclusionColorMap.r,ambientOcclusionColorMap.r,ambientOcclusionColorMap.r);
+#endif
+ambientOcclusionColor=mix(ambientOcclusionColor,ambientOcclusionColorMap,vAmbientInfos.z);
+#if DEBUGMODE>0
+outParams.ambientOcclusionColorMap=ambientOcclusionColorMap;
+#endif
+#endif
+outParams.ambientOcclusionColor=ambientOcclusionColor;
+}
+`;
+o.IncludesShadersStore[i] = n;

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

@@ -0,0 +1,50 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockAnisotropic", a = `#ifdef ANISOTROPIC
+struct anisotropicOutParams
+{
+float anisotropy;
+vec3 anisotropicTangent;
+vec3 anisotropicBitangent;
+vec3 anisotropicNormal;
+#if DEBUGMODE>0 && defined(ANISOTROPIC_TEXTURE)
+vec3 anisotropyMapData;
+#endif
+};
+#define pbr_inline
+void anisotropicBlock(
+in vec3 vAnisotropy,
+in float roughness,
+#ifdef ANISOTROPIC_TEXTURE
+in vec3 anisotropyMapData,
+#endif
+in mat3 TBN,
+in vec3 normalW,
+in vec3 viewDirectionW,
+out anisotropicOutParams outParams
+)
+{
+float anisotropy=vAnisotropy.b;
+vec3 anisotropyDirection=vec3(vAnisotropy.xy,0.);
+#ifdef ANISOTROPIC_TEXTURE
+anisotropy*=anisotropyMapData.b;
+#if DEBUGMODE>0
+outParams.anisotropyMapData=anisotropyMapData;
+#endif
+anisotropyMapData.rg=anisotropyMapData.rg*2.0-1.0;
+#ifdef ANISOTROPIC_LEGACY
+anisotropyDirection.rg*=anisotropyMapData.rg;
+#else
+anisotropyDirection.xy=mat2(anisotropyDirection.x,anisotropyDirection.y,-anisotropyDirection.y,anisotropyDirection.x)*normalize(anisotropyMapData.rg);
+#endif
+#endif
+mat3 anisoTBN=mat3(normalize(TBN[0]),normalize(TBN[1]),normalize(TBN[2]));
+vec3 anisotropicTangent=normalize(anisoTBN*anisotropyDirection);
+vec3 anisotropicBitangent=normalize(cross(anisoTBN[2],anisotropicTangent));
+outParams.anisotropy=anisotropy;
+outParams.anisotropicTangent=anisotropicTangent;
+outParams.anisotropicBitangent=anisotropicBitangent;
+outParams.anisotropicNormal=getAnisotropicBentNormals(anisotropicTangent,anisotropicBitangent,normalW,viewDirectionW,anisotropy,roughness);
+}
+#endif
+`;
+o.IncludesShadersStore[i] = a;