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

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

@@ -0,0 +1,270 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockReflection", n = `#ifdef REFLECTION
+struct reflectionOutParams
+{
+vec4 environmentRadiance;
+vec3 environmentIrradiance;
+#ifdef REFLECTIONMAP_3D
+vec3 reflectionCoords;
+#else
+vec2 reflectionCoords;
+#endif
+#ifdef SS_TRANSLUCENCY
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+vec3 irradianceVector;
+#endif
+#endif
+#endif
+};
+#define pbr_inline
+void createReflectionCoords(
+in vec3 vPositionW,
+in vec3 normalW,
+#ifdef ANISOTROPIC
+in anisotropicOutParams anisotropicOut,
+#endif
+#ifdef REFLECTIONMAP_3D
+out vec3 reflectionCoords
+#else
+out vec2 reflectionCoords
+#endif
+)
+{
+#ifdef ANISOTROPIC
+vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),anisotropicOut.anisotropicNormal);
+#else
+vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+reflectionCoords=reflectionVector;
+#else
+reflectionCoords=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0-reflectionCoords.y;
+#endif
+}
+#define pbr_inline
+#define inline
+void sampleReflectionTexture(
+in float alphaG,
+in vec3 vReflectionMicrosurfaceInfos,
+in vec2 vReflectionInfos,
+in vec3 vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+in float NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+in float roughness,
+#endif
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSampler,
+const vec3 reflectionCoords,
+#else
+in sampler2D reflectionSampler,
+const vec2 reflectionCoords,
+#endif
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSamplerLow,
+in samplerCube reflectionSamplerHigh,
+#else
+in sampler2D reflectionSamplerLow,
+in sampler2D reflectionSamplerHigh,
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+in vec2 vReflectionFilteringInfo,
+#endif
+out vec4 environmentRadiance
+)
+{
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG,NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+float reflectionLOD=getLinearLodFromRoughness(vReflectionMicrosurfaceInfos.x,roughness);
+#else
+float reflectionLOD=getLodFromAlphaG(vReflectionMicrosurfaceInfos.x,alphaG);
+#endif
+#ifdef LODBASEDMICROSFURACE
+reflectionLOD=reflectionLOD*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;
+#ifdef LODINREFLECTIONALPHA
+float automaticReflectionLOD=UNPACK_LOD(sampleReflection(reflectionSampler,reflectionCoords).a);
+float requestedReflectionLOD=max(automaticReflectionLOD,reflectionLOD);
+#else
+float requestedReflectionLOD=reflectionLOD;
+#endif
+#ifdef REALTIME_FILTERING
+environmentRadiance=vec4(radiance(alphaG,reflectionSampler,reflectionCoords,vReflectionFilteringInfo),1.0);
+#else
+environmentRadiance=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);
+#endif
+#else
+float lodReflectionNormalized=saturate(reflectionLOD/log2(vReflectionMicrosurfaceInfos.x));
+float lodReflectionNormalizedDoubled=lodReflectionNormalized*2.0;
+vec4 environmentMid=sampleReflection(reflectionSampler,reflectionCoords);
+if (lodReflectionNormalizedDoubled<1.0){
+environmentRadiance=mix(
+sampleReflection(reflectionSamplerHigh,reflectionCoords),
+environmentMid,
+lodReflectionNormalizedDoubled
+);
+} else {
+environmentRadiance=mix(
+environmentMid,
+sampleReflection(reflectionSamplerLow,reflectionCoords),
+lodReflectionNormalizedDoubled-1.0
+);
+}
+#endif
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb=fromRGBD(environmentRadiance);
+#endif
+#ifdef GAMMAREFLECTION
+environmentRadiance.rgb=toLinearSpace(environmentRadiance.rgb);
+#endif
+environmentRadiance.rgb*=vReflectionInfos.x;
+environmentRadiance.rgb*=vReflectionColor.rgb;
+}
+#define pbr_inline
+#define inline
+void reflectionBlock(
+in vec3 vPositionW,
+in vec3 normalW,
+in float alphaG,
+in vec3 vReflectionMicrosurfaceInfos,
+in vec2 vReflectionInfos,
+in vec3 vReflectionColor,
+#ifdef ANISOTROPIC
+in anisotropicOutParams anisotropicOut,
+#endif
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+in float NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+in float roughness,
+#endif
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSampler,
+#else
+in sampler2D reflectionSampler,
+#endif
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+in vec3 vEnvironmentIrradiance,
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+in mat4 reflectionMatrix,
+#endif
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+in samplerCube irradianceSampler,
+#else
+in sampler2D irradianceSampler,
+#endif
+#endif
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSamplerLow,
+in samplerCube reflectionSamplerHigh,
+#else
+in sampler2D reflectionSamplerLow,
+in sampler2D reflectionSamplerHigh,
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+in vec2 vReflectionFilteringInfo,
+#endif
+out reflectionOutParams outParams
+)
+{
+vec4 environmentRadiance=vec4(0.,0.,0.,0.);
+#ifdef REFLECTIONMAP_3D
+vec3 reflectionCoords=vec3(0.);
+#else
+vec2 reflectionCoords=vec2(0.);
+#endif
+createReflectionCoords(
+vPositionW,
+normalW,
+#ifdef ANISOTROPIC
+anisotropicOut,
+#endif
+reflectionCoords
+);
+sampleReflectionTexture(
+alphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+roughness,
+#endif
+#ifdef REFLECTIONMAP_3D
+reflectionSampler,
+reflectionCoords,
+#else
+reflectionSampler,
+reflectionCoords,
+#endif
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+environmentRadiance
+);
+vec3 environmentIrradiance=vec3(0.,0.,0.);
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+environmentIrradiance=vEnvironmentIrradiance;
+#else
+#ifdef ANISOTROPIC
+vec3 irradianceVector=vec3(reflectionMatrix*vec4(anisotropicOut.anisotropicNormal,0)).xyz;
+#else
+vec3 irradianceVector=vec3(reflectionMatrix*vec4(normalW,0)).xyz;
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;
+#endif
+#if defined(REALTIME_FILTERING)
+environmentIrradiance=irradiance(reflectionSampler,irradianceVector,vReflectionFilteringInfo);
+#else
+environmentIrradiance=computeEnvironmentIrradiance(irradianceVector);
+#endif
+#ifdef SS_TRANSLUCENCY
+outParams.irradianceVector=irradianceVector;
+#endif
+#endif
+#elif defined(USEIRRADIANCEMAP)
+vec4 environmentIrradiance4=sampleReflection(irradianceSampler,reflectionCoords);
+environmentIrradiance=environmentIrradiance4.rgb;
+#ifdef RGBDREFLECTION
+environmentIrradiance.rgb=fromRGBD(environmentIrradiance4);
+#endif
+#ifdef GAMMAREFLECTION
+environmentIrradiance.rgb=toLinearSpace(environmentIrradiance.rgb);
+#endif
+#endif
+environmentIrradiance*=vReflectionColor.rgb;
+outParams.environmentRadiance=environmentRadiance;
+outParams.environmentIrradiance=environmentIrradiance;
+outParams.reflectionCoords=reflectionCoords;
+}
+#endif
+`;
+e.IncludesShadersStore[i] = n;

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

@@ -0,0 +1,131 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "pbrBlockReflectivity", l = `struct reflectivityOutParams
+{
+float microSurface;
+float roughness;
+vec3 surfaceReflectivityColor;
+#ifdef METALLICWORKFLOW
+vec3 surfaceAlbedo;
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+vec3 ambientOcclusionColor;
+#endif
+#if DEBUGMODE>0
+#ifdef METALLICWORKFLOW
+vec2 metallicRoughness;
+#ifdef REFLECTIVITY
+vec4 surfaceMetallicColorMap;
+#endif
+#ifndef FROSTBITE_REFLECTANCE
+vec3 metallicF0;
+#endif
+#else
+#ifdef REFLECTIVITY
+vec4 surfaceReflectivityColorMap;
+#endif
+#endif
+#endif
+};
+#define pbr_inline
+void reflectivityBlock(
+in vec4 vReflectivityColor,
+#ifdef METALLICWORKFLOW
+in vec3 surfaceAlbedo,
+in vec4 metallicReflectanceFactors,
+#endif
+#ifdef REFLECTIVITY
+in vec3 reflectivityInfos,
+in vec4 surfaceMetallicOrReflectivityColorMap,
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+in vec3 ambientOcclusionColorIn,
+#endif
+#ifdef MICROSURFACEMAP
+in vec4 microSurfaceTexel,
+#endif
+#ifdef DETAIL
+in vec4 detailColor,
+in vec4 vDetailInfos,
+#endif
+out reflectivityOutParams outParams
+)
+{
+float microSurface=vReflectivityColor.a;
+vec3 surfaceReflectivityColor=vReflectivityColor.rgb;
+#ifdef METALLICWORKFLOW
+vec2 metallicRoughness=surfaceReflectivityColor.rg;
+#ifdef REFLECTIVITY
+#if DEBUGMODE>0
+outParams.surfaceMetallicColorMap=surfaceMetallicOrReflectivityColorMap;
+#endif
+#ifdef AOSTOREINMETALMAPRED
+vec3 aoStoreInMetalMap=vec3(surfaceMetallicOrReflectivityColorMap.r,surfaceMetallicOrReflectivityColorMap.r,surfaceMetallicOrReflectivityColorMap.r);
+outParams.ambientOcclusionColor=mix(ambientOcclusionColorIn,aoStoreInMetalMap,reflectivityInfos.z);
+#endif
+#ifdef METALLNESSSTOREINMETALMAPBLUE
+metallicRoughness.r*=surfaceMetallicOrReflectivityColorMap.b;
+#else
+metallicRoughness.r*=surfaceMetallicOrReflectivityColorMap.r;
+#endif
+#ifdef ROUGHNESSSTOREINMETALMAPALPHA
+metallicRoughness.g*=surfaceMetallicOrReflectivityColorMap.a;
+#else
+#ifdef ROUGHNESSSTOREINMETALMAPGREEN
+metallicRoughness.g*=surfaceMetallicOrReflectivityColorMap.g;
+#endif
+#endif
+#endif
+#ifdef DETAIL
+float detailRoughness=mix(0.5,detailColor.b,vDetailInfos.w);
+float loLerp=mix(0.,metallicRoughness.g,detailRoughness*2.);
+float hiLerp=mix(metallicRoughness.g,1.,(detailRoughness-0.5)*2.);
+metallicRoughness.g=mix(loLerp,hiLerp,step(detailRoughness,0.5));
+#endif
+#ifdef MICROSURFACEMAP
+metallicRoughness.g*=microSurfaceTexel.r;
+#endif
+#if DEBUGMODE>0
+outParams.metallicRoughness=metallicRoughness;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS
+microSurface=1.0-metallicRoughness.g;
+vec3 baseColor=surfaceAlbedo;
+#ifdef FROSTBITE_REFLECTANCE
+outParams.surfaceAlbedo=baseColor.rgb*(1.0-metallicRoughness.r);
+surfaceReflectivityColor=mix(0.16*reflectance*reflectance,baseColor,metallicRoughness.r);
+#else
+vec3 metallicF0=metallicReflectanceFactors.rgb;
+#if DEBUGMODE>0
+outParams.metallicF0=metallicF0;
+#endif
+outParams.surfaceAlbedo=mix(baseColor.rgb*(1.0-metallicF0),vec3(0.,0.,0.),metallicRoughness.r);
+surfaceReflectivityColor=mix(metallicF0,baseColor,metallicRoughness.r);
+#endif
+#else
+#ifdef REFLECTIVITY
+surfaceReflectivityColor*=surfaceMetallicOrReflectivityColorMap.rgb;
+#if DEBUGMODE>0
+outParams.surfaceReflectivityColorMap=surfaceMetallicOrReflectivityColorMap;
+#endif
+#ifdef MICROSURFACEFROMREFLECTIVITYMAP
+microSurface*=surfaceMetallicOrReflectivityColorMap.a;
+microSurface*=reflectivityInfos.z;
+#else
+#ifdef MICROSURFACEAUTOMATIC
+microSurface*=computeDefaultMicroSurface(microSurface,surfaceReflectivityColor);
+#endif
+#ifdef MICROSURFACEMAP
+microSurface*=microSurfaceTexel.r;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_MICROSURFACE
+#endif
+#endif
+#endif
+microSurface=saturate(microSurface);
+float roughness=1.-microSurface;
+outParams.microSurface=microSurface;
+outParams.roughness=roughness;
+outParams.surfaceReflectivityColor=surfaceReflectivityColor;
+}
+`;
+e.IncludesShadersStore[i] = l;

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

@@ -0,0 +1,197 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const n = "pbrBlockSheen", i = `#ifdef SHEEN
+struct sheenOutParams
+{
+float sheenIntensity;
+vec3 sheenColor;
+float sheenRoughness;
+#ifdef SHEEN_LINKWITHALBEDO
+vec3 surfaceAlbedo;
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+float sheenAlbedoScaling;
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+vec3 finalSheenRadianceScaled;
+#endif
+#if DEBUGMODE>0
+#ifdef SHEEN_TEXTURE
+vec4 sheenMapData;
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+vec3 sheenEnvironmentReflectance;
+#endif
+#endif
+};
+#define pbr_inline
+#define inline
+void sheenBlock(
+in vec4 vSheenColor,
+#ifdef SHEEN_ROUGHNESS
+in float vSheenRoughness,
+#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+in vec4 sheenMapRoughnessData,
+#endif
+#endif
+in float roughness,
+#ifdef SHEEN_TEXTURE
+in vec4 sheenMapData,
+in float sheenMapLevel,
+#endif
+in float reflectance,
+#ifdef SHEEN_LINKWITHALBEDO
+in vec3 baseColor,
+in vec3 surfaceAlbedo,
+#endif
+#ifdef ENVIRONMENTBRDF
+in float NdotV,
+in vec3 environmentBrdf,
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+in vec2 AARoughnessFactors,
+in vec3 vReflectionMicrosurfaceInfos,
+in vec2 vReflectionInfos,
+in vec3 vReflectionColor,
+in vec4 vLightingIntensity,
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSampler,
+in vec3 reflectionCoords,
+#else
+in sampler2D reflectionSampler,
+in vec2 reflectionCoords,
+#endif
+in float NdotVUnclamped,
+#ifndef LODBASEDMICROSFURACE
+#ifdef REFLECTIONMAP_3D
+in samplerCube reflectionSamplerLow,
+in samplerCube reflectionSamplerHigh,
+#else
+in sampler2D reflectionSamplerLow,
+in sampler2D reflectionSamplerHigh,
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+in vec2 vReflectionFilteringInfo,
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+in float seo,
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+in float eho,
+#endif
+#endif
+out sheenOutParams outParams
+)
+{
+float sheenIntensity=vSheenColor.a;
+#ifdef SHEEN_TEXTURE
+#if DEBUGMODE>0
+outParams.sheenMapData=sheenMapData;
+#endif
+#endif
+#ifdef SHEEN_LINKWITHALBEDO
+float sheenFactor=pow5(1.0-sheenIntensity);
+vec3 sheenColor=baseColor.rgb*(1.0-sheenFactor);
+float sheenRoughness=sheenIntensity;
+outParams.surfaceAlbedo=surfaceAlbedo*sheenFactor;
+#ifdef SHEEN_TEXTURE
+sheenIntensity*=sheenMapData.a;
+#endif
+#else
+vec3 sheenColor=vSheenColor.rgb;
+#ifdef SHEEN_TEXTURE
+#ifdef SHEEN_GAMMATEXTURE
+sheenColor.rgb*=toLinearSpace(sheenMapData.rgb);
+#else
+sheenColor.rgb*=sheenMapData.rgb;
+#endif
+sheenColor.rgb*=sheenMapLevel;
+#endif
+#ifdef SHEEN_ROUGHNESS
+float sheenRoughness=vSheenRoughness;
+#ifdef SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE
+#if defined(SHEEN_TEXTURE)
+sheenRoughness*=sheenMapData.a;
+#endif
+#elif defined(SHEEN_TEXTURE_ROUGHNESS)
+#ifdef SHEEN_TEXTURE_ROUGHNESS_IDENTICAL
+sheenRoughness*=sheenMapData.a;
+#else
+sheenRoughness*=sheenMapRoughnessData.a;
+#endif
+#endif
+#else
+float sheenRoughness=roughness;
+#ifdef SHEEN_TEXTURE
+sheenIntensity*=sheenMapData.a;
+#endif
+#endif
+#if !defined(SHEEN_ALBEDOSCALING)
+sheenIntensity*=(1.-reflectance);
+#endif
+sheenColor*=sheenIntensity;
+#endif
+#ifdef ENVIRONMENTBRDF
+/*#ifdef SHEEN_SOFTER
+vec3 environmentSheenBrdf=vec3(0.,0.,getBRDFLookupCharlieSheen(NdotV,sheenRoughness));
+#else*/
+#ifdef SHEEN_ROUGHNESS
+vec3 environmentSheenBrdf=getBRDFLookup(NdotV,sheenRoughness);
+#else
+vec3 environmentSheenBrdf=environmentBrdf;
+#endif
+/*#endif*/
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+float sheenAlphaG=convertRoughnessToAverageSlope(sheenRoughness);
+#ifdef SPECULARAA
+sheenAlphaG+=AARoughnessFactors.y;
+#endif
+vec4 environmentSheenRadiance=vec4(0.,0.,0.,0.);
+sampleReflectionTexture(
+sheenAlphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+sheenRoughness,
+#endif
+reflectionSampler,
+reflectionCoords,
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+environmentSheenRadiance
+);
+vec3 sheenEnvironmentReflectance=getSheenReflectanceFromBRDFLookup(sheenColor,environmentSheenBrdf);
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+sheenEnvironmentReflectance*=seo;
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+sheenEnvironmentReflectance*=eho;
+#endif
+#if DEBUGMODE>0
+outParams.sheenEnvironmentReflectance=sheenEnvironmentReflectance;
+#endif
+outParams.finalSheenRadianceScaled=
+environmentSheenRadiance.rgb *
+sheenEnvironmentReflectance *
+vLightingIntensity.z;
+#endif
+#if defined(ENVIRONMENTBRDF) && defined(SHEEN_ALBEDOSCALING)
+outParams.sheenAlbedoScaling=1.0-sheenIntensity*max(max(sheenColor.r,sheenColor.g),sheenColor.b)*environmentSheenBrdf.b;
+#endif
+outParams.sheenIntensity=sheenIntensity;
+outParams.sheenColor=sheenColor;
+outParams.sheenRoughness=sheenRoughness;
+}
+#endif
+`;
+e.IncludesShadersStore[n] = i;