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

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

@@ -0,0 +1,648 @@
+import { ShaderStore as e } from "../Engines/shaderStore.esm.js";
+import "./ShadersInclude/prePassDeclaration.esm.js";
+import "./ShadersInclude/oitDeclaration.esm.js";
+import "./ShadersInclude/pbrFragmentDeclaration.esm.js";
+import "./ShadersInclude/pbrUboDeclaration.esm.js";
+import "./ShadersInclude/pbrFragmentExtraDeclaration.esm.js";
+import "./ShadersInclude/lightFragmentDeclaration.esm.js";
+import "./ShadersInclude/lightUboDeclaration.esm.js";
+import "./ShadersInclude/pbrFragmentSamplersDeclaration.esm.js";
+import "./ShadersInclude/imageProcessingDeclaration.esm.js";
+import "./ShadersInclude/clipPlaneFragmentDeclaration.esm.js";
+import "./ShadersInclude/logDepthDeclaration.esm.js";
+import "./ShadersInclude/fogFragmentDeclaration.esm.js";
+import "./ShadersInclude/helperFunctions.esm.js";
+import "./ShadersInclude/subSurfaceScatteringFunctions.esm.js";
+import "./ShadersInclude/importanceSampling.esm.js";
+import "./ShadersInclude/pbrHelperFunctions.esm.js";
+import "./ShadersInclude/imageProcessingFunctions.esm.js";
+import "./ShadersInclude/shadowsFragmentFunctions.esm.js";
+import "./ShadersInclude/harmonicsFunctions.esm.js";
+import "./ShadersInclude/pbrDirectLightingSetupFunctions.esm.js";
+import "./ShadersInclude/pbrDirectLightingFalloffFunctions.esm.js";
+import "./ShadersInclude/pbrBRDFFunctions.esm.js";
+import "./ShadersInclude/hdrFilteringFunctions.esm.js";
+import "./ShadersInclude/pbrDirectLightingFunctions.esm.js";
+import "./ShadersInclude/pbrIBLFunctions.esm.js";
+import "./ShadersInclude/bumpFragmentMainFunctions.esm.js";
+import "./ShadersInclude/bumpFragmentFunctions.esm.js";
+import "./ShadersInclude/reflectionFunction.esm.js";
+import "./ShadersInclude/pbrBlockAlbedoOpacity.esm.js";
+import "./ShadersInclude/pbrBlockReflectivity.esm.js";
+import "./ShadersInclude/pbrBlockAmbientOcclusion.esm.js";
+import "./ShadersInclude/pbrBlockAlphaFresnel.esm.js";
+import "./ShadersInclude/pbrBlockAnisotropic.esm.js";
+import "./ShadersInclude/pbrBlockReflection.esm.js";
+import "./ShadersInclude/pbrBlockSheen.esm.js";
+import "./ShadersInclude/pbrBlockClearcoat.esm.js";
+import "./ShadersInclude/pbrBlockIridescence.esm.js";
+import "./ShadersInclude/pbrBlockSubSurface.esm.js";
+import "./ShadersInclude/clipPlaneFragment.esm.js";
+import "./ShadersInclude/pbrBlockNormalGeometric.esm.js";
+import "./ShadersInclude/bumpFragment.esm.js";
+import "./ShadersInclude/pbrBlockNormalFinal.esm.js";
+import "./ShadersInclude/depthPrePass.esm.js";
+import "./ShadersInclude/pbrBlockLightmapInit.esm.js";
+import "./ShadersInclude/pbrBlockGeometryInfo.esm.js";
+import "./ShadersInclude/pbrBlockReflectance0.esm.js";
+import "./ShadersInclude/pbrBlockReflectance.esm.js";
+import "./ShadersInclude/pbrBlockDirectLighting.esm.js";
+import "./ShadersInclude/lightFragment.esm.js";
+import "./ShadersInclude/pbrBlockFinalLitComponents.esm.js";
+import "./ShadersInclude/pbrBlockFinalUnlitComponents.esm.js";
+import "./ShadersInclude/pbrBlockFinalColorComposition.esm.js";
+import "./ShadersInclude/logDepthFragment.esm.js";
+import "./ShadersInclude/fogFragment.esm.js";
+import "./ShadersInclude/pbrBlockImageProcessing.esm.js";
+import "./ShadersInclude/oitFragment.esm.js";
+import "./ShadersInclude/pbrDebug.esm.js";
+const i = "pbrPixelShader", n = `#if defined(BUMP) || !defined(NORMAL) || defined(FORCENORMALFORWARD) || defined(SPECULARAA) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#extension GL_OES_standard_derivatives : enable
+#endif
+#ifdef LODBASEDMICROSFURACE
+#extension GL_EXT_shader_texture_lod : enable
+#endif
+#define CUSTOM_FRAGMENT_BEGIN
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+#include<prePassDeclaration>[SCENE_MRT_COUNT]
+precision highp float;
+#include<oitDeclaration>
+#ifndef FROMLINEARSPACE
+#define FROMLINEARSPACE
+#endif
+#include<__decl__pbrFragment>
+#include<pbrFragmentExtraDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<pbrFragmentSamplersDeclaration>
+#include<imageProcessingDeclaration>
+#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#include<helperFunctions>
+#include<subSurfaceScatteringFunctions>
+#include<importanceSampling>
+#include<pbrHelperFunctions>
+#include<imageProcessingFunctions>
+#include<shadowsFragmentFunctions>
+#include<harmonicsFunctions>
+#include<pbrDirectLightingSetupFunctions>
+#include<pbrDirectLightingFalloffFunctions>
+#include<pbrBRDFFunctions>
+#include<hdrFilteringFunctions>
+#include<pbrDirectLightingFunctions>
+#include<pbrIBLFunctions>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#ifdef REFLECTION
+#include<reflectionFunction>
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+#include<pbrBlockAlbedoOpacity>
+#include<pbrBlockReflectivity>
+#include<pbrBlockAmbientOcclusion>
+#include<pbrBlockAlphaFresnel>
+#include<pbrBlockAnisotropic>
+#include<pbrBlockReflection>
+#include<pbrBlockSheen>
+#include<pbrBlockClearcoat>
+#include<pbrBlockIridescence>
+#include<pbrBlockSubSurface>
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+#include<pbrBlockNormalGeometric>
+#include<bumpFragment>
+#include<pbrBlockNormalFinal>
+albedoOpacityOutParams albedoOpacityOut;
+#ifdef ALBEDO
+vec4 albedoTexture=texture2D(albedoSampler,vAlbedoUV+uvOffset);
+#endif
+#ifdef OPACITY
+vec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);
+#endif
+#ifdef DECAL
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#endif
+albedoOpacityBlock(
+vAlbedoColor,
+#ifdef ALBEDO
+albedoTexture,
+vAlbedoInfos,
+#endif
+#ifdef OPACITY
+opacityMap,
+vOpacityInfos,
+#endif
+#ifdef DETAIL
+detailColor,
+vDetailInfos,
+#endif
+#ifdef DECAL
+decalColor,
+vDecalInfos,
+#endif
+albedoOpacityOut
+);
+vec3 surfaceAlbedo=albedoOpacityOut.surfaceAlbedo;
+float alpha=albedoOpacityOut.alpha;
+#define CUSTOM_FRAGMENT_UPDATE_ALPHA
+#include<depthPrePass>
+#define CUSTOM_FRAGMENT_BEFORE_LIGHTS
+ambientOcclusionOutParams aoOut;
+#ifdef AMBIENT
+vec3 ambientOcclusionColorMap=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb;
+#endif
+ambientOcclusionBlock(
+#ifdef AMBIENT
+ambientOcclusionColorMap,
+vAmbientInfos,
+#endif
+aoOut
+);
+#include<pbrBlockLightmapInit>
+#ifdef UNLIT
+vec3 diffuseBase=vec3(1.,1.,1.);
+#else
+vec3 baseColor=surfaceAlbedo;
+reflectivityOutParams reflectivityOut;
+#if defined(REFLECTIVITY)
+vec4 surfaceMetallicOrReflectivityColorMap=texture2D(reflectivitySampler,vReflectivityUV+uvOffset);
+vec4 baseReflectivity=surfaceMetallicOrReflectivityColorMap;
+#ifndef METALLICWORKFLOW
+#ifdef REFLECTIVITY_GAMMA
+surfaceMetallicOrReflectivityColorMap=toLinearSpace(surfaceMetallicOrReflectivityColorMap);
+#endif
+surfaceMetallicOrReflectivityColorMap.rgb*=vReflectivityInfos.y;
+#endif
+#endif
+#if defined(MICROSURFACEMAP)
+vec4 microSurfaceTexel=texture2D(microSurfaceSampler,vMicroSurfaceSamplerUV+uvOffset)*vMicroSurfaceSamplerInfos.y;
+#endif
+#ifdef METALLICWORKFLOW
+vec4 metallicReflectanceFactors=vMetallicReflectanceFactors;
+#ifdef REFLECTANCE
+vec4 reflectanceFactorsMap=texture2D(reflectanceSampler,vReflectanceUV+uvOffset);
+#ifdef REFLECTANCE_GAMMA
+reflectanceFactorsMap=toLinearSpace(reflectanceFactorsMap);
+#endif
+metallicReflectanceFactors.rgb*=reflectanceFactorsMap.rgb;
+#endif
+#ifdef METALLIC_REFLECTANCE
+vec4 metallicReflectanceFactorsMap=texture2D(metallicReflectanceSampler,vMetallicReflectanceUV+uvOffset);
+#ifdef METALLIC_REFLECTANCE_GAMMA
+metallicReflectanceFactorsMap=toLinearSpace(metallicReflectanceFactorsMap);
+#endif
+#ifndef METALLIC_REFLECTANCE_USE_ALPHA_ONLY
+metallicReflectanceFactors.rgb*=metallicReflectanceFactorsMap.rgb;
+#endif
+metallicReflectanceFactors*=metallicReflectanceFactorsMap.a;
+#endif
+#endif
+reflectivityBlock(
+vReflectivityColor,
+#ifdef METALLICWORKFLOW
+surfaceAlbedo,
+metallicReflectanceFactors,
+#endif
+#ifdef REFLECTIVITY
+vReflectivityInfos,
+surfaceMetallicOrReflectivityColorMap,
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+aoOut.ambientOcclusionColor,
+#endif
+#ifdef MICROSURFACEMAP
+microSurfaceTexel,
+#endif
+#ifdef DETAIL
+detailColor,
+vDetailInfos,
+#endif
+reflectivityOut
+);
+float microSurface=reflectivityOut.microSurface;
+float roughness=reflectivityOut.roughness;
+#ifdef METALLICWORKFLOW
+surfaceAlbedo=reflectivityOut.surfaceAlbedo;
+#endif
+#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)
+aoOut.ambientOcclusionColor=reflectivityOut.ambientOcclusionColor;
+#endif
+#ifdef ALPHAFRESNEL
+#if defined(ALPHATEST) || defined(ALPHABLEND)
+alphaFresnelOutParams alphaFresnelOut;
+alphaFresnelBlock(
+normalW,
+viewDirectionW,
+alpha,
+microSurface,
+alphaFresnelOut
+);
+alpha=alphaFresnelOut.alpha;
+#endif
+#endif
+#include<pbrBlockGeometryInfo>
+#ifdef ANISOTROPIC
+anisotropicOutParams anisotropicOut;
+#ifdef ANISOTROPIC_TEXTURE
+vec3 anisotropyMapData=texture2D(anisotropySampler,vAnisotropyUV+uvOffset).rgb*vAnisotropyInfos.y;
+#endif
+anisotropicBlock(
+vAnisotropy,
+roughness,
+#ifdef ANISOTROPIC_TEXTURE
+anisotropyMapData,
+#endif
+TBN,
+normalW,
+viewDirectionW,
+anisotropicOut
+);
+#endif
+#ifdef REFLECTION
+reflectionOutParams reflectionOut;
+#ifndef USE_CUSTOM_REFLECTION
+reflectionBlock(
+vPositionW,
+normalW,
+alphaG,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+#ifdef ANISOTROPIC
+anisotropicOut,
+#endif
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+NdotVUnclamped,
+#endif
+#ifdef LINEARSPECULARREFLECTION
+roughness,
+#endif
+reflectionSampler,
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+vEnvironmentIrradiance,
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+reflectionMatrix,
+#endif
+#endif
+#ifdef USEIRRADIANCEMAP
+irradianceSampler,
+#endif
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+reflectionOut
+);
+#else
+#define CUSTOM_REFLECTION
+#endif
+#endif
+#include<pbrBlockReflectance0>
+#ifdef SHEEN
+sheenOutParams sheenOut;
+#ifdef SHEEN_TEXTURE
+vec4 sheenMapData=texture2D(sheenSampler,vSheenUV+uvOffset);
+#endif
+#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+vec4 sheenMapRoughnessData=texture2D(sheenRoughnessSampler,vSheenRoughnessUV+uvOffset)*vSheenInfos.w;
+#endif
+sheenBlock(
+vSheenColor,
+#ifdef SHEEN_ROUGHNESS
+vSheenRoughness,
+#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)
+sheenMapRoughnessData,
+#endif
+#endif
+roughness,
+#ifdef SHEEN_TEXTURE
+sheenMapData,
+vSheenInfos.y,
+#endif
+reflectance,
+#ifdef SHEEN_LINKWITHALBEDO
+baseColor,
+surfaceAlbedo,
+#endif
+#ifdef ENVIRONMENTBRDF
+NdotV,
+environmentBrdf,
+#endif
+#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)
+AARoughnessFactors,
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+vLightingIntensity,
+reflectionSampler,
+reflectionOut.reflectionCoords,
+NdotVUnclamped,
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)
+seo,
+#endif
+#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)
+eho,
+#endif
+#endif
+sheenOut
+);
+#ifdef SHEEN_LINKWITHALBEDO
+surfaceAlbedo=sheenOut.surfaceAlbedo;
+#endif
+#endif
+#ifdef CLEARCOAT
+#ifdef CLEARCOAT_TEXTURE
+vec2 clearCoatMapData=texture2D(clearCoatSampler,vClearCoatUV+uvOffset).rg*vClearCoatInfos.y;
+#endif
+#endif
+#ifdef IRIDESCENCE
+iridescenceOutParams iridescenceOut;
+#ifdef IRIDESCENCE_TEXTURE
+vec2 iridescenceMapData=texture2D(iridescenceSampler,vIridescenceUV+uvOffset).rg*vIridescenceInfos.y;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+vec2 iridescenceThicknessMapData=texture2D(iridescenceThicknessSampler,vIridescenceThicknessUV+uvOffset).rg*vIridescenceInfos.w;
+#endif
+iridescenceBlock(
+vIridescenceParams,
+NdotV,
+specularEnvironmentR0,
+#ifdef IRIDESCENCE_TEXTURE
+iridescenceMapData,
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+iridescenceThicknessMapData,
+#endif
+#ifdef CLEARCOAT
+NdotVUnclamped,
+#ifdef CLEARCOAT_TEXTURE
+clearCoatMapData,
+#endif
+#endif
+iridescenceOut
+);
+float iridescenceIntensity=iridescenceOut.iridescenceIntensity;
+specularEnvironmentR0=iridescenceOut.specularEnvironmentR0;
+#endif
+clearcoatOutParams clearcoatOut;
+#ifdef CLEARCOAT
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+vec4 clearCoatMapRoughnessData=texture2D(clearCoatRoughnessSampler,vClearCoatRoughnessUV+uvOffset)*vClearCoatInfos.w;
+#endif
+#if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)
+vec4 clearCoatTintMapData=texture2D(clearCoatTintSampler,vClearCoatTintUV+uvOffset);
+#endif
+#ifdef CLEARCOAT_BUMP
+vec4 clearCoatBumpMapData=texture2D(clearCoatBumpSampler,vClearCoatBumpUV+uvOffset);
+#endif
+clearcoatBlock(
+vPositionW,
+geometricNormalW,
+viewDirectionW,
+vClearCoatParams,
+#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)
+clearCoatMapRoughnessData,
+#endif
+specularEnvironmentR0,
+#ifdef CLEARCOAT_TEXTURE
+clearCoatMapData,
+#endif
+#ifdef CLEARCOAT_TINT
+vClearCoatTintParams,
+clearCoatColorAtDistance,
+vClearCoatRefractionParams,
+#ifdef CLEARCOAT_TINT_TEXTURE
+clearCoatTintMapData,
+#endif
+#endif
+#ifdef CLEARCOAT_BUMP
+vClearCoatBumpInfos,
+clearCoatBumpMapData,
+vClearCoatBumpUV,
+#if defined(TANGENT) && defined(NORMAL)
+vTBN,
+#else
+vClearCoatTangentSpaceParams,
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+normalMatrix,
+#endif
+#endif
+#if defined(FORCENORMALFORWARD) && defined(NORMAL)
+faceNormal,
+#endif
+#ifdef REFLECTION
+vReflectionMicrosurfaceInfos,
+vReflectionInfos,
+vReflectionColor,
+vLightingIntensity,
+reflectionSampler,
+#ifndef LODBASEDMICROSFURACE
+reflectionSamplerLow,
+reflectionSamplerHigh,
+#endif
+#ifdef REALTIME_FILTERING
+vReflectionFilteringInfo,
+#endif
+#endif
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef RADIANCEOCCLUSION
+ambientMonochrome,
+#endif
+#endif
+#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)
+(gl_FrontFacing ? 1. : -1.),
+#endif
+clearcoatOut
+);
+#else
+clearcoatOut.specularEnvironmentR0=specularEnvironmentR0;
+#endif
+#include<pbrBlockReflectance>
+subSurfaceOutParams subSurfaceOut;
+#ifdef SUBSURFACE
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+vec4 thicknessMap=texture2D(thicknessSampler,vThicknessUV+uvOffset);
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+vec4 refractionIntensityMap=texture2D(refractionIntensitySampler,vRefractionIntensityUV+uvOffset);
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+vec4 translucencyIntensityMap=texture2D(translucencyIntensitySampler,vTranslucencyIntensityUV+uvOffset);
+#endif
+subSurfaceBlock(
+vSubSurfaceIntensity,
+vThicknessParam,
+vTintColor,
+normalW,
+specularEnvironmentReflectance,
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+thicknessMap,
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+refractionIntensityMap,
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+translucencyIntensityMap,
+#endif
+#ifdef REFLECTION
+#ifdef SS_TRANSLUCENCY
+reflectionMatrix,
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)
+reflectionOut.irradianceVector,
+#endif
+#if defined(REALTIME_FILTERING)
+reflectionSampler,
+vReflectionFilteringInfo,
+#endif
+#endif
+#ifdef USEIRRADIANCEMAP
+irradianceSampler,
+#endif
+#endif
+#endif
+#if defined(SS_REFRACTION) || defined(SS_TRANSLUCENCY)
+surfaceAlbedo,
+#endif
+#ifdef SS_REFRACTION
+vPositionW,
+viewDirectionW,
+view,
+vRefractionInfos,
+refractionMatrix,
+vRefractionMicrosurfaceInfos,
+vLightingIntensity,
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+alpha,
+#endif
+#ifdef SS_LODINREFRACTIONALPHA
+NdotVUnclamped,
+#endif
+#ifdef SS_LINEARSPECULARREFRACTION
+roughness,
+#endif
+alphaG,
+refractionSampler,
+#ifndef LODBASEDMICROSFURACE
+refractionSamplerLow,
+refractionSamplerHigh,
+#endif
+#ifdef ANISOTROPIC
+anisotropicOut,
+#endif
+#ifdef REALTIME_FILTERING
+vRefractionFilteringInfo,
+#endif
+#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC
+vRefractionPosition,
+vRefractionSize,
+#endif
+#endif
+#ifdef SS_TRANSLUCENCY
+vDiffusionDistance,
+#endif
+subSurfaceOut
+);
+#ifdef SS_REFRACTION
+surfaceAlbedo=subSurfaceOut.surfaceAlbedo;
+#ifdef SS_LINKREFRACTIONTOTRANSPARENCY
+alpha=subSurfaceOut.alpha;
+#endif
+#endif
+#else
+subSurfaceOut.specularEnvironmentReflectance=specularEnvironmentReflectance;
+#endif
+#include<pbrBlockDirectLighting>
+#include<lightFragment>[0..maxSimultaneousLights]
+#include<pbrBlockFinalLitComponents>
+#endif 
+#include<pbrBlockFinalUnlitComponents>
+#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION
+#include<pbrBlockFinalColorComposition>
+#include<logDepthFragment>
+#include<fogFragment>(color,finalColor)
+#include<pbrBlockImageProcessing>
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef PREPASS
+float writeGeometryInfo=finalColor.a>0.4 ? 1.0 : 0.0;
+#ifdef PREPASS_POSITION
+gl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);
+#endif
+#ifdef PREPASS_VELOCITY
+vec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;
+vec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;
+vec2 velocity=abs(a-b);
+velocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;
+gl_FragData[PREPASS_VELOCITY_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+vec3 sqAlbedo=sqrt(surfaceAlbedo); 
+#endif
+#ifdef PREPASS_IRRADIANCE
+vec3 irradiance=finalDiffuse;
+#ifndef UNLIT
+#ifdef REFLECTION
+irradiance+=finalIrradiance;
+#endif
+#endif
+#ifdef SS_SCATTERING
+gl_FragData[0]=vec4(finalColor.rgb-irradiance,finalColor.a); 
+irradiance/=sqAlbedo;
+#else
+gl_FragData[0]=finalColor; 
+float scatteringDiffusionProfile=255.;
+#endif
+gl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(clamp(irradiance,vec3(0.),vec3(1.)),writeGeometryInfo*scatteringDiffusionProfile/255.); 
+#else
+gl_FragData[0]=vec4(finalColor.rgb,finalColor.a);
+#endif
+#ifdef PREPASS_DEPTH
+gl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_NORMAL
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo); 
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+gl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqAlbedo,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_REFLECTIVITY
+#ifndef UNLIT
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(specularEnvironmentR0,microSurface)*writeGeometryInfo;
+#else
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4( 0.0,0.0,0.0,1.0 )*writeGeometryInfo;
+#endif
+#endif
+#endif
+#if !defined(PREPASS) || defined(WEBGL2)
+gl_FragColor=finalColor;
+#endif
+#include<oitFragment>
+#if ORDER_INDEPENDENT_TRANSPARENCY
+if (fragDepth==nearestDepth) {
+frontColor.rgb+=finalColor.rgb*finalColor.a*alphaMultiplier;
+frontColor.a=1.0-alphaMultiplier*(1.0-finalColor.a);
+} else {
+backColor+=finalColor;
+}
+#endif
+#include<pbrDebug>
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+e.ShadersStore[i] = n;