bp-cloner
Version:
More info and explanations here - https://doc.babylonjs.com/communityExtensions/clonerSystem
508 lines (507 loc) • 20.5 kB
JavaScript
import { S as e } from "./index-7uRiSnMV.js";
import "./oitFragment-Czg7hF2C.js";
import "./defaultUboDeclaration-CKd_eAjq.js";
import "./mainUVVaryingDeclaration-BoDGYAwx.js";
const o = "defaultFragmentDeclaration", t = `uniform vec4 vEyePosition;uniform vec4 vDiffuseColor;uniform vec4 vSpecularColor;uniform vec3 vEmissiveColor;uniform vec3 vAmbientColor;uniform float visibility;
uniform vec2 vDiffuseInfos;
uniform vec2 vAmbientInfos;
uniform vec2 vOpacityInfos;
uniform vec2 vEmissiveInfos;
uniform vec2 vLightmapInfos;
uniform vec3 vBumpInfos;uniform vec2 vTangentSpaceParams;
uniform float alphaCutOff;
uniform mat4 view;
uniform vec4 vRefractionInfos;
uniform mat4 refractionMatrix;
uniform vec4 refractionLeftColor;uniform vec4 refractionRightColor;
uniform vec3 vRefractionPosition;uniform vec3 vRefractionSize;
uniform vec2 vSpecularInfos;
uniform vec4 diffuseLeftColor;uniform vec4 diffuseRightColor;
uniform vec4 opacityParts;
uniform vec4 emissiveLeftColor;uniform vec4 emissiveRightColor;
uniform vec2 vReflectionInfos;
uniform mat4 reflectionMatrix;
uniform vec3 vReflectionPosition;uniform vec3 vReflectionSize;
uniform vec4 reflectionLeftColor;uniform vec4 reflectionRightColor;
uniform vec4 vDetailInfos;
`;
e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = t);
const r = "lightsFragmentFunctions", l = `struct lightingInfo
{vec3 diffuse;
vec3 specular;
float ndl;
};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));
result.ndl=ndl;
result.diffuse=ndl*diffuseColor*attenuation;
vec3 angleW=normalize(viewDirectionW+lightVectorW);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;
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));
result.ndl=ndl;
result.diffuse=ndl*diffuseColor*attenuation;
vec3 angleW=normalize(viewDirectionW+lightVectorW);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;
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.);
result.specular=vec3(0.);
result.ndl=0.;
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.);
result.specular=vec3(0.);
result.ndl=0.;
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;
result.ndl=ndl;
result.diffuse=mix(groundColor,diffuseColor,ndl);
vec3 angleW=normalize(viewDirectionW+lightData.xyz);float specComp=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor;
return result;}
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;}
uniform sampler2D areaLightsLTC1Sampler;uniform sampler2D areaLightsLTC2Sampler;
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);
vec3 fresnel=( specularColor*data.Fresnel.x+( vec3( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;
result.diffuse+=diffuseColor*data.Diffuse;return result;}
`;
e.IncludesShadersStore[r] || (e.IncludesShadersStore[r] = l);
const f = "fresnelFunction", a = `
float computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float power)
{float fresnelTerm=pow(bias+abs(dot(viewDirection,worldNormal)),power);return clamp(fresnelTerm,0.,1.);}
`;
e.IncludesShadersStore[f] || (e.IncludesShadersStore[f] = a);
const i = "defaultPixelShader", n = `
varying vec3 vPositionW;
varying vec3 vNormalW;
varying vec4 vColor;
uniform samplerCube refractionCubeSampler;
uniform sampler2D refraction2DSampler;
uniform samplerCube reflectionCubeSampler;
uniform sampler2D reflection2DSampler;
varying vec3 vPositionUVW;
varying vec3 vDirectionW;
void main(void) {
vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);vec4 baseColor=vec4(1.,1.,1.,1.);vec3 diffuseColor=vDiffuseColor.rgb;float alpha=vDiffuseColor.a;
vec3 normalW=normalize(vNormalW);
vec3 normalW=normalize(-cross(dFdx(vPositionW),dFdy(vPositionW)));
normalW=gl_FrontFacing ? normalW : -normalW;
baseColor=texture2D(diffuseSampler,vDiffuseUV+uvOffset);
if (baseColor.a<alphaCutOff)
discard;
alpha*=baseColor.a;
baseColor.rgb*=vDiffuseInfos.y;
vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
baseColor.rgb*=vColor.rgb;
baseColor.rgb=baseColor.rgb*2.0*mix(0.5,detailColor.r,vDetailInfos.y);
vec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);
vec3 baseAmbientColor=vec3(1.,1.,1.);
baseAmbientColor=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb*vAmbientInfos.y;
float glossiness=vSpecularColor.a;vec3 specularColor=vSpecularColor.rgb;
vec4 specularMapColor=texture2D(specularSampler,vSpecularUV+uvOffset);specularColor=specularMapColor.rgb;
glossiness=glossiness*specularMapColor.a;
vec3 diffuseBase=vec3(0.,0.,0.);lightingInfo info;
vec3 specularBase=vec3(0.,0.,0.);
float shadow=1.;float aggShadow=0.;float numLights=0.;
vec4 lightmapColor=texture2D(lightmapSampler,vLightmapUV+uvOffset);
lightmapColor.rgb=fromRGBD(lightmapColor);
lightmapColor.rgb*=vLightmapInfos.y;
aggShadow=aggShadow/numLights;vec4 refractionColor=vec4(0.,0.,0.,1.);
vec3 refractionVector=normalize(refract(-viewDirectionW,normalW,vRefractionInfos.y));
refractionVector=parallaxCorrectNormal(vPositionW,refractionVector,vRefractionSize,vRefractionPosition);
refractionVector.y=refractionVector.y*vRefractionInfos.w;vec4 refractionLookup=textureCube(refractionCubeSampler,refractionVector);if (dot(refractionVector,viewDirectionW)<1.0) {refractionColor=refractionLookup;}
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);
refractionColor.rgb=fromRGBD(refractionColor);
refractionColor.rgb=toGammaSpace(refractionColor.rgb);
refractionColor.rgb*=vRefractionInfos.x;
vec4 reflectionColor=vec4(0.,0.,0.,1.);
vec3 vReflectionUVW=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
vReflectionUVW.z*=-1.0;
float bias=vReflectionInfos.y;
bias*=(1.0-specularMapColor.a);
reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW,bias);
reflectionColor=textureCube(reflectionCubeSampler,vReflectionUVW);
vec2 coords=vReflectionUVW.xy;
coords/=vReflectionUVW.z;
coords.y=1.0-coords.y;reflectionColor=texture2D(reflection2DSampler,coords);
reflectionColor.rgb=fromRGBD(reflectionColor);
reflectionColor.rgb=toGammaSpace(reflectionColor.rgb);
reflectionColor.rgb*=vReflectionInfos.x;
float reflectionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,reflectionRightColor.a,reflectionLeftColor.a);
reflectionColor.rgb*=specularColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
reflectionColor.rgb*=reflectionLeftColor.rgb*(1.0-reflectionFresnelTerm)+reflectionFresnelTerm*reflectionRightColor.rgb;
float refractionFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,refractionRightColor.a,refractionLeftColor.a);refractionColor.rgb*=refractionLeftColor.rgb*(1.0-refractionFresnelTerm)+refractionFresnelTerm*refractionRightColor.rgb;
vec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);
opacityMap.rgb=opacityMap.rgb*vec3(0.3,0.59,0.11);alpha*=(opacityMap.x+opacityMap.y+opacityMap.z)* vOpacityInfos.y;
alpha*=opacityMap.a*vOpacityInfos.y;
alpha*=vColor.a;
float opacityFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,opacityParts.z,opacityParts.w);alpha+=opacityParts.x*(1.0-opacityFresnelTerm)+opacityFresnelTerm*opacityParts.y;
if (alpha<alphaCutOff)
discard;
alpha=1.0;
vec3 emissiveColor=vEmissiveColor;
emissiveColor+=texture2D(emissiveSampler,vEmissiveUV+uvOffset).rgb*vEmissiveInfos.y;
float emissiveFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,emissiveRightColor.a,emissiveLeftColor.a);emissiveColor*=emissiveLeftColor.rgb*(1.0-emissiveFresnelTerm)+emissiveFresnelTerm*emissiveRightColor.rgb;
float diffuseFresnelTerm=computeFresnelTerm(viewDirectionW,normalW,diffuseRightColor.a,diffuseLeftColor.a);diffuseBase*=diffuseLeftColor.rgb*(1.0-diffuseFresnelTerm)+diffuseFresnelTerm*diffuseRightColor.rgb;
vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
vec3 finalDiffuse=clamp((diffuseBase+emissiveColor)*diffuseColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
vec3 finalDiffuse=clamp(diffuseBase*diffuseColor+emissiveColor+vAmbientColor,0.0,1.0)*baseColor.rgb;
vec3 finalSpecular=specularBase*specularColor;
alpha=clamp(alpha+dot(finalSpecular,vec3(0.3,0.59,0.11)),0.,1.);
vec3 finalSpecular=vec3(0.0);
alpha=clamp(alpha+dot(reflectionColor.rgb,vec3(0.3,0.59,0.11)),0.,1.);
vec4 color=vec4(clamp(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+emissiveColor+refractionColor.rgb,0.0,1.0),alpha);
vec4 color=vec4(finalDiffuse*baseAmbientColor+finalSpecular+reflectionColor.rgb+refractionColor.rgb,alpha);
color.rgb*=lightmapColor.rgb;
color.rgb+=lightmapColor.rgb;
color.rgb=max(color.rgb,0.);
color.rgb=toLinearSpace(color.rgb);
color.rgb=toLinearSpace(color.rgb);color=applyImageProcessing(color);
color.a*=visibility;
color.rgb*=color.a;
float writeGeometryInfo=color.a>0.4 ? 1.0 : 0.0;
gl_FragData[PREPASS_COLOR_INDEX]=color;
gl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);
gl_FragData[PREPASS_LOCAL_POSITION_INDEX]=vec4(vPosition,writeGeometryInfo);
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);
vec2 velocity=vec2(0.5)*((vPreviousPosition.xy/vPreviousPosition.w)-(vCurrentPosition.xy/vCurrentPosition.w));gl_FragData[PREPASS_VELOCITY_LINEAR_INDEX]=vec4(velocity,0.0,writeGeometryInfo);
gl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(0.0,0.0,0.0,writeGeometryInfo);
gl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo);
gl_FragData[PREPASS_SCREENSPACE_DEPTH_INDEX]=vec4(gl_FragCoord.z,0.0,0.0,writeGeometryInfo);
gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalW,writeGeometryInfo);
gl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo);
gl_FragData[PREPASS_WORLD_NORMAL_INDEX]=vec4(normalW*0.5+0.5,writeGeometryInfo);
gl_FragData[PREPASS_ALBEDO_INDEX]=vec4(baseColor.rgb,writeGeometryInfo);
gl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqrt(baseColor.rgb),writeGeometryInfo);
gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularMapColor))*writeGeometryInfo;
gl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(toLinearSpace(specularColor),1.0)*writeGeometryInfo;
gl_FragColor=color;
if (fragDepth==nearestDepth) {frontColor.rgb+=color.rgb*color.a*alphaMultiplier;frontColor.a=1.0-alphaMultiplier*(1.0-color.a);} else {backColor+=color;}
}
`;
e.ShadersStore[i] || (e.ShadersStore[i] = n);
const v = { name: i, shader: n };
export {
v as defaultPixelShader
};