@vived/component-abb-6700 1.0.0

package/dist/default.fragment-DKnTR9nY.js

@@ -0,0 +1,548 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+import "./oitFragment-B8zuQigp.js";
+import "./defaultUboDeclaration-BwslQZX8.js";
+import "./logDepthDeclaration-gUfeSnXX.js";
+import "./helperFunctions-CPmRxd37.js";
+import "./lightFragment-BRDibDKG.js";
+import "./bumpFragment-KE1_PuMl.js";
+const o = "defaultFragmentDeclaration", f = `uniform vec4 vEyePosition;uniform vec4 vDiffuseColor;uniform vec4 vSpecularColor;uniform vec3 vEmissiveColor;uniform vec3 vAmbientColor;uniform float visibility;
+#ifdef DIFFUSE
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef AMBIENT
+uniform vec2 vAmbientInfos;
+#endif
+#ifdef OPACITY 
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;uniform vec2 vTangentSpaceParams;
+#endif
+#ifdef ALPHATEST
+uniform float alphaCutOff;
+#endif
+#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(REFRACTION) || defined(PREPASS)
+uniform mat4 view;
+#endif
+#ifdef REFRACTION
+uniform vec4 vRefractionInfos;
+#ifndef REFRACTIONMAP_3D
+uniform mat4 refractionMatrix;
+#endif
+#ifdef REFRACTIONFRESNEL
+uniform vec4 refractionLeftColor;uniform vec4 refractionRightColor;
+#endif
+#if defined(USE_LOCAL_REFRACTIONMAP_CUBIC) && defined(REFRACTIONMAP_3D)
+uniform vec3 vRefractionPosition;uniform vec3 vRefractionSize; 
+#endif
+#endif
+#if defined(SPECULAR) && defined(SPECULARTERM)
+uniform vec2 vSpecularInfos;
+#endif
+#ifdef DIFFUSEFRESNEL
+uniform vec4 diffuseLeftColor;uniform vec4 diffuseRightColor;
+#endif
+#ifdef OPACITYFRESNEL
+uniform vec4 opacityParts;
+#endif
+#ifdef EMISSIVEFRESNEL
+uniform vec4 emissiveLeftColor;uniform vec4 emissiveRightColor;
+#endif
+#if defined(REFLECTION) || (defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED))
+uniform vec2 vReflectionInfos;
+#if defined(REFLECTIONMAP_PLANAR) || defined(REFLECTIONMAP_CUBIC) || defined(REFLECTIONMAP_PROJECTION) || defined(REFLECTIONMAP_EQUIRECTANGULAR) || defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_SKYBOX)
+uniform mat4 reflectionMatrix;
+#endif
+#ifndef REFLECTIONMAP_SKYBOX
+#if defined(USE_LOCAL_REFLECTIONMAP_CUBIC) && defined(REFLECTIONMAP_CUBIC)
+uniform vec3 vReflectionPosition;uniform vec3 vReflectionSize; 
+#endif
+#endif
+#ifdef REFLECTIONFRESNEL
+uniform vec4 reflectionLeftColor;uniform vec4 reflectionRightColor;
+#endif
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+#endif
+#include<decalFragmentDeclaration>
+#if TEXTURE_REPETITION_MODE>0
+uniform vec4 vTextureRepetitionHexTilingParams;
+#endif
+#define ADDITIONAL_FRAGMENT_DECLARATION
+`;
+e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = f);
+const r = "lightsFragmentFunctions", l = `struct lightingInfo
+{vec3 diffuse;
+#ifdef SPECULARTERM
+vec3 specular;
+#endif
+#ifdef NDOTL
+float ndl;
+#endif
+};lightingInfo computeLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec3 diffuseColor,vec3 specularColor,float range,float glossiness) {lightingInfo result;vec3 lightVectorW;float attenuation=1.0;if (lightData.w==0.)
+{vec3 direction=lightData.xyz-vPositionW;attenuation=max(0.,1.0-length(direction)/range);lightVectorW=normalize(direction);}
+else
+{lightVectorW=normalize(-lightData.xyz);}
+float ndl=max(0.,dot(vNormal,lightVectorW));
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=ndl*diffuseColor*attenuation;
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightVectorW);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;
+#endif
+return result;}
+float getAttenuation(float cosAngle,float exponent) {return max(0.,pow(cosAngle,exponent));}
+float getIESAttenuation(float cosAngle,sampler2D iesLightSampler) {float angle=acos(cosAngle)/PI;return texture2D(iesLightSampler,vec2(angle,0.)).r;}
+lightingInfo basicSpotLighting(vec3 viewDirectionW,vec3 lightVectorW,vec3 vNormal,float attenuation,vec3 diffuseColor,vec3 specularColor,float glossiness) {lightingInfo result; 
+float ndl=max(0.,dot(vNormal,lightVectorW));
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=ndl*diffuseColor*attenuation;
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightVectorW);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;
+#endif
+return result;}
+lightingInfo computeIESSpotLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec4 lightDirection,vec3 diffuseColor,vec3 specularColor,float range,float glossiness,sampler2D iesLightSampler) { 
+vec3 direction=lightData.xyz-vPositionW;vec3 lightVectorW=normalize(direction);float attenuation=max(0.,1.0-length(direction)/range);float dotProduct=dot(lightDirection.xyz,-lightVectorW);float cosAngle=max(0.,dotProduct);if (cosAngle>=lightDirection.w)
+{ 
+attenuation*=getIESAttenuation(dotProduct,iesLightSampler);return basicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}
+lightingInfo result;result.diffuse=vec3(0.);
+#ifdef SPECULARTERM
+result.specular=vec3(0.);
+#endif
+#ifdef NDOTL
+result.ndl=0.;
+#endif
+return result;}
+lightingInfo computeSpotLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec4 lightDirection,vec3 diffuseColor,vec3 specularColor,float range,float glossiness) {vec3 direction=lightData.xyz-vPositionW;vec3 lightVectorW=normalize(direction);float attenuation=max(0.,1.0-length(direction)/range);float cosAngle=max(0.,dot(lightDirection.xyz,-lightVectorW));if (cosAngle>=lightDirection.w)
+{ 
+attenuation*=getAttenuation(cosAngle,lightData.w);return basicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}
+lightingInfo result;result.diffuse=vec3(0.);
+#ifdef SPECULARTERM
+result.specular=vec3(0.);
+#endif
+#ifdef NDOTL
+result.ndl=0.;
+#endif
+return result;}
+lightingInfo computeHemisphericLighting(vec3 viewDirectionW,vec3 vNormal,vec4 lightData,vec3 diffuseColor,vec3 specularColor,vec3 groundColor,float glossiness) {lightingInfo result;float ndl=dot(vNormal,lightData.xyz)*0.5+0.5;
+#ifdef NDOTL
+result.ndl=ndl;
+#endif
+result.diffuse=mix(groundColor,diffuseColor,ndl);
+#ifdef SPECULARTERM
+vec3 angleW=normalize(viewDirectionW+lightData.xyz);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor;
+#endif
+return result;}
+#define inline
+vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler,mat4 textureProjectionMatrix,vec3 posW){vec4 strq=textureProjectionMatrix*vec4(posW,1.0);strq/=strq.w;vec3 textureColor=texture2D(projectionLightSampler,strq.xy).rgb;return textureColor;}
+#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+#include<ltcHelperFunctions>
+uniform sampler2D areaLightsLTC1Sampler;uniform sampler2D areaLightsLTC2Sampler;
+#define inline
+lightingInfo computeAreaLighting(sampler2D ltc1,sampler2D ltc2,vec3 viewDirectionW,vec3 vNormal,vec3 vPosition,vec3 lightPosition,vec3 halfWidth,vec3 halfHeight,vec3 diffuseColor,vec3 specularColor,float roughness) 
+{lightingInfo result;areaLightData data=computeAreaLightSpecularDiffuseFresnel(ltc1,ltc2,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);
+#ifdef SPECULARTERM
+vec3 fresnel=( specularColor*data.Fresnel.x+( vec3( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;
+#endif
+result.diffuse+=diffuseColor*data.Diffuse;return result;}
+lightingInfo computeAreaLightingWithTexture(sampler2D ltc1,sampler2D ltc2,sampler2D emissionTexture,vec3 viewDirectionW,vec3 vNormal,vec3 vPosition,vec3 lightPosition,vec3 halfWidth,vec3 halfHeight,vec3 diffuseColor,vec3 specularColor,float roughness) 
+{lightingInfo result;areaLightData data=computeAreaLightSpecularDiffuseFresnelWithEmission(ltc1,ltc2,emissionTexture,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);
+#ifdef SPECULARTERM
+vec3 fresnel=( specularColor*data.Fresnel.x+( vec3( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;
+#endif
+result.diffuse+=diffuseColor*data.Diffuse;return result;}
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+#include<clusteredLightingFunctions>
+#define inline
+lightingInfo computeClusteredLighting(
+sampler2D lightDataTexture,
+sampler2D tileMaskTexture,
+vec3 viewDirectionW,
+vec3 vNormal,
+vec4 lightData,
+ivec2 sliceRange,
+float glossiness
+) {lightingInfo result;ivec2 tilePosition=ivec2(gl_FragCoord.xy*lightData.xy);int maskHeight=int(lightData.z);tilePosition.y=min(tilePosition.y,maskHeight-1);ivec2 batchRange=sliceRange/CLUSTLIGHT_BATCH;int batchOffset=batchRange.x*CLUSTLIGHT_BATCH;tilePosition.y+=maskHeight*batchRange.x;for (int i=batchRange.x; i<=batchRange.y; i+=1) {uint mask=uint(texelFetch(tileMaskTexture,tilePosition,0).r);tilePosition.y+=maskHeight;int maskOffset=max(sliceRange.x-batchOffset,0);int maskWidth=min(sliceRange.y-batchOffset+1,CLUSTLIGHT_BATCH);mask=extractBits(mask,maskOffset,maskWidth);while (mask != 0u) {uint bit=mask & -mask;mask ^= bit;int position=onlyBitPosition(bit);ClusteredLight light=getClusteredLight(lightDataTexture,batchOffset+maskOffset+position);lightingInfo info;if (light.vLightDirection.w<0.0) {info=computeLighting(viewDirectionW,vNormal,light.vLightData,light.vLightDiffuse.rgb,light.vLightSpecular.rgb,light.vLightDiffuse.a,glossiness);} else {info=computeSpotLighting(viewDirectionW,vNormal,light.vLightData,light.vLightDirection,light.vLightDiffuse.rgb,light.vLightSpecular.rgb,light.vLightDiffuse.a,glossiness);}
+result.diffuse+=info.diffuse;
+#ifdef SPECULARTERM
+result.specular+=info.specular;
+#endif
+}
+batchOffset+=CLUSTLIGHT_BATCH;}
+return result;}
+#endif
+`;
+e.IncludesShadersStore[r] || (e.IncludesShadersStore[r] = l);
+const t = "fresnelFunction", a = `#ifdef FRESNEL
+float computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float power)
+{float fresnelTerm=pow(bias+abs(dot(viewDirection,worldNormal)),power);return clamp(fresnelTerm,0.,1.);}
+#endif
+`;
+e.IncludesShadersStore[t] || (e.IncludesShadersStore[t] = a);
+const i = "defaultPixelShader", n = `#define CUSTOM_FRAGMENT_EXTENSION
+#include<__decl__defaultFragment>
+#if defined(BUMP) || !defined(NORMAL)
+#extension GL_OES_standard_derivatives : enable
+#endif
+#include<prePassDeclaration>[SCENE_MRT_COUNT]
+#include<oitDeclaration>
+#define CUSTOM_FRAGMENT_BEGIN
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vec4 vColor;
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+varying float vViewDepth;
+#endif
+#include<mainUVVaryingDeclaration>[1..7]
+#include<helperFunctions>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse,_SAMPLERNAME_,diffuse)
+#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_,DECAL,_VARYINGNAME_,Decal,_SAMPLERNAME_,decal)
+#ifdef REFRACTION
+#ifdef REFRACTIONMAP_3D
+uniform samplerCube refractionCubeSampler;
+#else
+uniform sampler2D refraction2DSampler;
+#endif
+#endif
+#if defined(SPECULARTERM)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular,_SAMPLERNAME_,specular)
+#endif
+#include<fresnelFunction>
+#ifdef REFLECTION
+#ifdef REFLECTIONMAP_3D
+uniform samplerCube reflectionCubeSampler;
+#else
+uniform sampler2D reflection2DSampler;
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+varying vec3 vPositionUVW;
+#else
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vec3 vDirectionW;
+#endif
+#endif
+#include<reflectionFunction>
+#endif
+#include<imageProcessingDeclaration>
+#include<imageProcessingFunctions>
+#include<textureRepetitionFunctions>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);vec4 baseColor=vec4(1.,1.,1.,1.);vec3 diffuseColor=vDiffuseColor.rgb;float alpha=vDiffuseColor.a;
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=normalize(cross(dFdx(vPositionW),dFdy(vPositionW)))*vEyePosition.w;
+#endif
+#include<bumpFragment>
+#ifdef TWOSIDEDLIGHTING
+normalW=gl_FrontFacing ? normalW : -normalW;
+#endif
+#ifdef DIFFUSE
+baseColor=TEXRD(diffuseSampler,vDiffuseUV+uvOffset);
+#if defined(ALPHATEST) && !defined(ALPHATEST_AFTERALLALPHACOMPUTATIONS)
+if (baseColor.a<alphaCutOff)
+discard;
+#endif
+#ifdef ALPHAFROMDIFFUSE
+alpha*=baseColor.a;
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_ALPHA
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#if defined(DECAL) && !defined(DECAL_AFTER_DETAIL)
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#include<decalFragment>(surfaceAlbedo,baseColor,GAMMADECAL,_GAMMADECAL_NOTUSED_)
+#endif
+#include<depthPrePass>
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+baseColor.rgb*=vColor.rgb;
+#endif
+#ifdef DETAIL
+baseColor.rgb=baseColor.rgb*2.0*mix(0.5,detailColor.r,vDetailInfos.y);
+#endif
+#if defined(DECAL) && defined(DECAL_AFTER_DETAIL)
+vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
+#include<decalFragment>(surfaceAlbedo,baseColor,GAMMADECAL,_GAMMADECAL_NOTUSED_)
+#endif
+#define CUSTOM_FRAGMENT_UPDATE_DIFFUSE
+vec3 baseAmbientColor=vec3(1.,1.,1.);
+#ifdef AMBIENT
+baseAmbientColor=TEXRD(ambientSampler,vAmbientUV+uvOffset).rgb*vAmbientInfos.y;
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_LIGHTS
+float glossiness=vSpecularColor.a;vec3 specularColor=vSpecularColor.rgb;
+#ifdef SPECULARTERM
+#ifdef SPECULAR
+vec4 specularMapColor=TEXRD(specularSampler,vSpecularUV+uvOffset);specularColor=specularMapColor.rgb;
+#ifdef GLOSSINESS
+glossiness=glossiness*specularMapColor.a;
+#endif
+#endif
+#endif
+vec3 diffuseBase=vec3(0.,0.,0.);lightingInfo info;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+float shadow=1.;float aggShadow=0.;float numLights=0.;
+#ifdef LIGHTMAP
+vec4 lightmapColor=TEXRD(lightmapSampler,vLightmapUV+uvOffset);
+#ifdef RGBDLIGHTMAP
+lightmapColor.rgb=fromRGBD(lightmapColor);
+#endif
+lightmapColor.rgb*=vLightmapInfos.y;
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+aggShadow=aggShadow/numLights;vec4 refractionColor=vec4(0.,0.,0.,1.);
+#ifdef REFRACTION
+vec3 refractionVector=normalize(refract(-viewDirectionW,normalW,vRefractionInfos.y));
+#ifdef REFRACTIONMAP_3D
+#ifdef USE_LOCAL_REFRACTIONMAP_CUBIC
+refractionVector=parallaxCorrectNormal(vPositionW,refractionVector,vRefractionSize,vRefractionPosition);
+#endif
+refractionVector.y=refractionVector.y*vRefractionInfos.w;vec4 refractionLookup=textureCube(refractionCubeSampler,refractionVector);if (dot(refractionVector,viewDirectionW)<1.0) {refractionColor=refractionLookup;}
+#else
+vec3 vRefractionUVW=vec3(refractionMatrix*(view*vec4(vPositionW+refractionVector*vRefractionInfos.z,1.0)));vec2 refractionCoords=vRefractionUVW.xy/vRefractionUVW.z;refractionCoords.y=1.0-refractionCoords.y;refractionColor=texture2D(refraction2DSampler,refractionCoords);
+#endif
+#ifdef RGBDREFRACTION
+refractionColor.rgb=fromRGBD(refractionColor);
+#endif
+#ifdef IS_REFRACTION_LINEAR
+refractionColor.rgb=toGammaSpace(refractionColor.rgb);
+#endif
+refractionColor.rgb*=vRefractionInfos.x;
+#endif
+vec4 reflectionColor=vec4(0.,0.,0.,1.);
+#ifdef REFLECTION
+vec3 vReflectionUVW=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+vReflectionUVW.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+#ifdef ROUGHNESS
+float bias=vReflectionInfos.y;
+#ifdef SPECULARTERM
+#ifdef SPECULAR
+#ifdef GLOSSINESS
+bias*=(1.0-specularMapColor.a);
+#endif
+#endif
+#endif
+reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW,bias);
+#else
+reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW);
+#endif
+#else
+vec2 coords=vReflectionUVW.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+coords/=vReflectionUVW.z;
+#endif
+coords.y=1.0-coords.y;reflectionColor=texture2D(reflection2DSampler,coords);
+#endif
+#ifdef RGBDREFLECTION
+reflectionColor.rgb=fromRGBD(reflectionColor);
+#endif
+#ifdef IS_REFLECTION_LINEAR
+reflectionColor.rgb=toGammaSpace(reflectionColor.rgb);
+#endif
+reflectionColor.rgb*=vReflectionInfos.x;
+#ifdef REFLECTIONFRESNEL
+float reflectionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,reflectionRightColor.a,reflectionLeftColor.a);
+#ifdef REFLECTIONFRESNELFROMSPECULAR
+#ifdef SPECULARTERM
+reflectionColor.rgb*=specularColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#else
+reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#endif
+#else
+reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
+#endif
+#endif
+#endif
+#ifdef REFRACTIONFRESNEL
+float refractionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,refractionRightColor.a,refractionLeftColor.a);refractionColor.rgb*=refractionLeftColor.rgb*(1.0-refractionFresnelTerm)+refractionFresnelTerm*refractionRightColor.rgb;
+#endif
+#ifdef OPACITY
+vec4 opacityMap=TEXRD(opacitySampler,vOpacityUV+uvOffset);
+#ifdef OPACITYRGB
+opacityMap.rgb=opacityMap.rgb*vec3(0.3,0.59,0.11);alpha*=(opacityMap.x+opacityMap.y+opacityMap.z)* vOpacityInfos.y;
+#else
+alpha*=opacityMap.a*vOpacityInfos.y;
+#endif
+#endif
+#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+alpha*=vColor.a;
+#endif
+#ifdef OPACITYFRESNEL
+float opacityFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,opacityParts.z,opacityParts.w);alpha+=opacityParts.x*(1.0-opacityFresnelTerm)+opacityFresnelTerm*opacityParts.y;
+#endif
+#ifdef ALPHATEST
+#ifdef ALPHATEST_AFTERALLALPHACOMPUTATIONS
+if (alpha<alphaCutOff)
+discard;
+#endif
+#ifndef ALPHABLEND
+alpha=1.0;
+#endif
+#endif
+vec3 emissiveColor=vEmissiveColor;
+#ifdef EMISSIVE
+emissiveColor+=TEXRD(emissiveSampler,vEmissiveUV+uvOffset).rgb*vEmissiveInfos.y;
+#endif
+#ifdef EMISSIVEFRESNEL
+float emissiveFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,emissiveRightColor.a,emissiveLeftColor.a);emissiveColor*=emissiveLeftColor.rgb*(1.0-emissiveFresnelTerm)+emissiveFresnelTerm*emissiveRightColor.rgb;
+#endif
+#ifdef DIFFUSEFRESNEL
+float diffuseFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,diffuseRightColor.a,diffuseLeftColor.a);diffuseBase*=diffuseLeftColor.rgb*(1.0-diffuseFresnelTerm)+diffuseFresnelTerm*diffuseRightColor.rgb;
+#endif
+#ifdef EMISSIVEASILLUMINATION
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#else
+#ifdef LINKEMISSIVEWITHDIFFUSE
+vec3 finalDiffuse=clamp((diffuseBase+emissiveColor)*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#else
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+emissiveColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
+#endif
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#ifdef SPECULAROVERALPHA
+alpha=clamp(alpha+dot(finalSpecular,vec3(0.3,0.59,0.11)),0.,1.);
+#endif
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+#ifdef REFLECTIONOVERALPHA
+alpha=clamp(alpha+dot(reflectionColor.rgb,vec3(0.3,0.59,0.11)),0.,1.);
+#endif
+#ifdef EMISSIVEASILLUMINATION
+vec4 color=vec4(clamp(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+emissiveColor+refractionColor.rgb,0.0,1.0),alpha);
+#else
+vec4 color=vec4(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+refractionColor.rgb,alpha);
+#endif
+#ifdef LIGHTMAP
+#ifndef LIGHTMAPEXCLUDED
+#ifdef USELIGHTMAPASSHADOWMAP
+color.rgb*=lightmapColor.rgb;
+#else
+color.rgb+=lightmapColor.rgb;
+#endif
+#endif
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_FOG
+color.rgb=max(color.rgb,0.);
+#include<logDepthFragment>
+#include<fogFragment>
+#ifdef IMAGEPROCESSINGPOSTPROCESS
+color.rgb=toLinearSpace(color.rgb);
+#else
+#ifdef IMAGEPROCESSING
+color.rgb=toLinearSpace(color.rgb);color=applyImageProcessing(color);
+#endif
+#endif
+color.a*=visibility;
+#ifdef PREMULTIPLYALPHA
+color.rgb*=color.a;
+#endif
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef PREPASS
+#if SCENE_MRT_COUNT>0
+float writeGeometryInfo=color.a>0.4 ? 1.0 : 0.0;
+#ifdef PREPASS_COLOR
+gl_FragData[PREPASS_COLOR_INDEX]=color; 
+#endif
+#ifdef PREPASS_POSITION
+gl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+gl_FragData[PREPASS_LOCAL_POSITION_INDEX]=vec4(vPosition,writeGeometryInfo);
+#endif
+#if defined(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);
+#elif defined(PREPASS_VELOCITY_LINEAR)
+vec2 velocity=vec2(0.5)*((vPreviousPosition.xy/vPreviousPosition.w)-(vCurrentPosition.xy/vCurrentPosition.w));gl_FragData[PREPASS_VELOCITY_LINEAR_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_IRRADIANCE
+gl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(0.0,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_DEPTH
+gl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); 
+#endif
+#ifdef PREPASS_SCREENSPACE_DEPTH
+gl_FragData[PREPASS_SCREENSPACE_DEPTH_INDEX]=vec4(gl_FragCoord.z,0.0,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+gl_FragData[PREPASS_NORMALIZED_VIEW_DEPTH_INDEX]=vec4(vNormViewDepth,0.0,0.0,writeGeometryInfo);
+#endif
+#ifdef PREPASS_NORMAL
+#ifdef PREPASS_NORMAL_WORLDSPACE
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalW,writeGeometryInfo);
+#else
+gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo);
+#endif
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+gl_FragData[PREPASS_WORLD_NORMAL_INDEX]=vec4(normalW*0.5+0.5,writeGeometryInfo);
+#endif
+#ifdef PREPASS_ALBEDO
+gl_FragData[PREPASS_ALBEDO_INDEX]=vec4(baseColor.rgb,writeGeometryInfo);
+#endif
+#ifdef PREPASS_ALBEDO_SQRT
+gl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqrt(baseColor.rgb),writeGeometryInfo);
+#endif
+#ifdef PREPASS_REFLECTIVITY
+#if defined(SPECULAR)
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularMapColor))*writeGeometryInfo; 
+#else
+gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularColor),1.0)*writeGeometryInfo;
+#endif
+#endif
+#endif
+#endif
+#if !defined(PREPASS) || defined(WEBGL2)
+gl_FragColor=color;
+#endif
+#include<oitFragment>
+#if ORDER_INDEPENDENT_TRANSPARENCY
+if (fragDepth==nearestDepth) {frontColor.rgb+=color.rgb*color.a*alphaMultiplier;frontColor.a=1.0-alphaMultiplier*(1.0-color.a);} else {backColor+=color;}
+#endif
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+e.ShadersStore[i] || (e.ShadersStore[i] = n);
+const m = { name: i, shader: n };
+export {
+  m as defaultPixelShader
+};