import defined from "../Core/defined.js";
import ShaderSource from "../Renderer/ShaderSource.js";
/**
* @private
*/
function ShadowMapShader() {}
ShadowMapShader.getShadowCastShaderKeyword = function (
isPointLight,
isTerrain,
usesDepthTexture,
isOpaque
) {
return (
"castShadow " +
isPointLight +
" " +
isTerrain +
" " +
usesDepthTexture +
" " +
isOpaque
);
};
ShadowMapShader.createShadowCastVertexShader = function (
vs,
isPointLight,
isTerrain
) {
var defines = vs.defines.slice(0);
var sources = vs.sources.slice(0);
defines.push("SHADOW_MAP");
if (isTerrain) {
defines.push("GENERATE_POSITION");
}
var positionVaryingName = ShaderSource.findPositionVarying(vs);
var hasPositionVarying = defined(positionVaryingName);
if (isPointLight && !hasPositionVarying) {
var length = sources.length;
for (var j = 0; j < length; ++j) {
sources[j] = ShaderSource.replaceMain(sources[j], "czm_shadow_cast_main");
}
var shadowVS =
"varying vec3 v_positionEC; \n" +
"void main() \n" +
"{ \n" +
" czm_shadow_cast_main(); \n" +
" v_positionEC = (czm_inverseProjection * gl_Position).xyz; \n" +
"}";
sources.push(shadowVS);
}
return new ShaderSource({
defines: defines,
sources: sources,
});
};
ShadowMapShader.createShadowCastFragmentShader = function (
fs,
isPointLight,
usesDepthTexture,
opaque
) {
var defines = fs.defines.slice(0);
var sources = fs.sources.slice(0);
var positionVaryingName = ShaderSource.findPositionVarying(fs);
var hasPositionVarying = defined(positionVaryingName);
if (!hasPositionVarying) {
positionVaryingName = "v_positionEC";
}
var length = sources.length;
for (var i = 0; i < length; ++i) {
sources[i] = ShaderSource.replaceMain(sources[i], "czm_shadow_cast_main");
}
var fsSource = "";
if (isPointLight) {
if (!hasPositionVarying) {
fsSource += "varying vec3 v_positionEC; \n";
}
fsSource += "uniform vec4 shadowMap_lightPositionEC; \n";
}
if (opaque) {
fsSource += "void main() \n" + "{ \n";
} else {
fsSource +=
"void main() \n" +
"{ \n" +
" czm_shadow_cast_main(); \n" +
" if (gl_FragColor.a == 0.0) \n" +
" { \n" +
" discard; \n" +
" } \n";
}
if (isPointLight) {
fsSource +=
" float distance = length(" +
positionVaryingName +
"); \n" +
" if (distance >= shadowMap_lightPositionEC.w) \n" +
" { \n" +
" discard; \n" +
" } \n" +
" distance /= shadowMap_lightPositionEC.w; // radius \n" +
" gl_FragColor = czm_packDepth(distance); \n";
} else if (usesDepthTexture) {
fsSource += " gl_FragColor = vec4(1.0); \n";
} else {
fsSource += " gl_FragColor = czm_packDepth(gl_FragCoord.z); \n";
}
fsSource += "} \n";
sources.push(fsSource);
return new ShaderSource({
defines: defines,
sources: sources,
});
};
ShadowMapShader.getShadowReceiveShaderKeyword = function (
shadowMap,
castShadows,
isTerrain,
hasTerrainNormal
) {
var usesDepthTexture = shadowMap._usesDepthTexture;
var polygonOffsetSupported = shadowMap._polygonOffsetSupported;
var isPointLight = shadowMap._isPointLight;
var isSpotLight = shadowMap._isSpotLight;
var hasCascades = shadowMap._numberOfCascades > 1;
var debugCascadeColors = shadowMap.debugCascadeColors;
var softShadows = shadowMap.softShadows;
return (
"receiveShadow " +
usesDepthTexture +
polygonOffsetSupported +
isPointLight +
isSpotLight +
hasCascades +
debugCascadeColors +
softShadows +
castShadows +
isTerrain +
hasTerrainNormal
);
};
ShadowMapShader.createShadowReceiveVertexShader = function (
vs,
isTerrain,
hasTerrainNormal
) {
var defines = vs.defines.slice(0);
var sources = vs.sources.slice(0);
defines.push("SHADOW_MAP");
if (isTerrain) {
if (hasTerrainNormal) {
defines.push("GENERATE_POSITION_AND_NORMAL");
} else {
defines.push("GENERATE_POSITION");
}
}
return new ShaderSource({
defines: defines,
sources: sources,
});
};
ShadowMapShader.createShadowReceiveFragmentShader = function (
fs,
shadowMap,
castShadows,
isTerrain,
hasTerrainNormal
) {
var normalVaryingName = ShaderSource.findNormalVarying(fs);
var hasNormalVarying =
(!isTerrain && defined(normalVaryingName)) ||
(isTerrain && hasTerrainNormal);
var positionVaryingName = ShaderSource.findPositionVarying(fs);
var hasPositionVarying = defined(positionVaryingName);
var usesDepthTexture = shadowMap._usesDepthTexture;
var polygonOffsetSupported = shadowMap._polygonOffsetSupported;
var isPointLight = shadowMap._isPointLight;
var isSpotLight = shadowMap._isSpotLight;
var hasCascades = shadowMap._numberOfCascades > 1;
var debugCascadeColors = shadowMap.debugCascadeColors;
var softShadows = shadowMap.softShadows;
var bias = isPointLight
? shadowMap._pointBias
: isTerrain
? shadowMap._terrainBias
: shadowMap._primitiveBias;
var defines = fs.defines.slice(0);
var sources = fs.sources.slice(0);
var length = sources.length;
for (var i = 0; i < length; ++i) {
sources[i] = ShaderSource.replaceMain(
sources[i],
"czm_shadow_receive_main"
);
}
if (isPointLight) {
defines.push("USE_CUBE_MAP_SHADOW");
} else if (usesDepthTexture) {
defines.push("USE_SHADOW_DEPTH_TEXTURE");
}
if (softShadows && !isPointLight) {
defines.push("USE_SOFT_SHADOWS");
}
// Enable day-night shading so that the globe is dark when the light is below the horizon
if (hasCascades && castShadows && isTerrain) {
if (hasNormalVarying) {
defines.push("ENABLE_VERTEX_LIGHTING");
} else {
defines.push("ENABLE_DAYNIGHT_SHADING");
}
}
if (castShadows && bias.normalShading && hasNormalVarying) {
defines.push("USE_NORMAL_SHADING");
if (bias.normalShadingSmooth > 0.0) {
defines.push("USE_NORMAL_SHADING_SMOOTH");
}
}
var fsSource = "";
if (isPointLight) {
fsSource += "uniform samplerCube shadowMap_textureCube; \n";
} else {
fsSource += "uniform sampler2D shadowMap_texture; \n";
}
var returnPositionEC;
if (hasPositionVarying) {
returnPositionEC = " return vec4(" + positionVaryingName + ", 1.0); \n";
} else {
returnPositionEC =
"#ifndef LOG_DEPTH \n" +
" return czm_windowToEyeCoordinates(gl_FragCoord); \n" +
"#else \n" +
" return vec4(v_logPositionEC, 1.0); \n" +
"#endif \n";
}
fsSource +=
"uniform mat4 shadowMap_matrix; \n" +
"uniform vec3 shadowMap_lightDirectionEC; \n" +
"uniform vec4 shadowMap_lightPositionEC; \n" +
"uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness; \n" +
"uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth; \n" +
"#ifdef LOG_DEPTH \n" +
"varying vec3 v_logPositionEC; \n" +
"#endif \n" +
"vec4 getPositionEC() \n" +
"{ \n" +
returnPositionEC +
"} \n" +
"vec3 getNormalEC() \n" +
"{ \n" +
(hasNormalVarying
? " return normalize(" + normalVaryingName + "); \n"
: " return vec3(1.0); \n") +
"} \n" +
// Offset the shadow position in the direction of the normal for perpendicular and back faces
"void applyNormalOffset(inout vec4 positionEC, vec3 normalEC, float nDotL) \n" +
"{ \n" +
(bias.normalOffset && hasNormalVarying
? " float normalOffset = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.x; \n" +
" float normalOffsetScale = 1.0 - nDotL; \n" +
" vec3 offset = normalOffset * normalOffsetScale * normalEC; \n" +
" positionEC.xyz += offset; \n"
: "") +
"} \n";
fsSource +=
"void main() \n" +
"{ \n" +
" czm_shadow_receive_main(); \n" +
" vec4 positionEC = getPositionEC(); \n" +
" vec3 normalEC = getNormalEC(); \n" +
" float depth = -positionEC.z; \n";
fsSource +=
" czm_shadowParameters shadowParameters; \n" +
" shadowParameters.texelStepSize = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy; \n" +
" shadowParameters.depthBias = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z; \n" +
" shadowParameters.normalShadingSmooth = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w; \n" +
" shadowParameters.darkness = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w; \n";
if (isTerrain) {
// Scale depth bias based on view distance to reduce z-fighting in distant terrain
fsSource += " shadowParameters.depthBias *= max(depth * 0.01, 1.0); \n";
} else if (!polygonOffsetSupported) {
// If polygon offset isn't supported push the depth back based on view, however this
// causes light leaking at further away views
fsSource +=
" shadowParameters.depthBias *= mix(1.0, 100.0, depth * 0.0015); \n";
}
if (isPointLight) {
fsSource +=
" vec3 directionEC = positionEC.xyz - shadowMap_lightPositionEC.xyz; \n" +
" float distance = length(directionEC); \n" +
" directionEC = normalize(directionEC); \n" +
" float radius = shadowMap_lightPositionEC.w; \n" +
" // Stop early if the fragment is beyond the point light radius \n" +
" if (distance > radius) \n" +
" { \n" +
" return; \n" +
" } \n" +
" vec3 directionWC = czm_inverseViewRotation * directionEC; \n" +
" shadowParameters.depth = distance / radius; \n" +
" shadowParameters.nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n" +
" shadowParameters.texCoords = directionWC; \n" +
" float visibility = czm_shadowVisibility(shadowMap_textureCube, shadowParameters); \n";
} else if (isSpotLight) {
fsSource +=
" vec3 directionEC = normalize(positionEC.xyz - shadowMap_lightPositionEC.xyz); \n" +
" float nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n" +
" applyNormalOffset(positionEC, normalEC, nDotL); \n" +
" vec4 shadowPosition = shadowMap_matrix * positionEC; \n" +
" // Spot light uses a perspective projection, so perform the perspective divide \n" +
" shadowPosition /= shadowPosition.w; \n" +
" // Stop early if the fragment is not in the shadow bounds \n" +
" if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n" +
" { \n" +
" return; \n" +
" } \n" +
" shadowParameters.texCoords = shadowPosition.xy; \n" +
" shadowParameters.depth = shadowPosition.z; \n" +
" shadowParameters.nDotL = nDotL; \n" +
" float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n";
} else if (hasCascades) {
fsSource +=
" float maxDepth = shadowMap_cascadeSplits[1].w; \n" +
" // Stop early if the eye depth exceeds the last cascade \n" +
" if (depth > maxDepth) \n" +
" { \n" +
" return; \n" +
" } \n" +
" // Get the cascade based on the eye-space depth \n" +
" vec4 weights = czm_cascadeWeights(depth); \n" +
" // Apply normal offset \n" +
" float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n" +
" applyNormalOffset(positionEC, normalEC, nDotL); \n" +
" // Transform position into the cascade \n" +
" vec4 shadowPosition = czm_cascadeMatrix(weights) * positionEC; \n" +
" // Get visibility \n" +
" shadowParameters.texCoords = shadowPosition.xy; \n" +
" shadowParameters.depth = shadowPosition.z; \n" +
" shadowParameters.nDotL = nDotL; \n" +
" float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n" +
" // Fade out shadows that are far away \n" +
" float shadowMapMaximumDistance = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.z; \n" +
" float fade = max((depth - shadowMapMaximumDistance * 0.8) / (shadowMapMaximumDistance * 0.2), 0.0); \n" +
" visibility = mix(visibility, 1.0, fade); \n" +
(debugCascadeColors
? " // Draw cascade colors for debugging \n" +
" gl_FragColor *= czm_cascadeColor(weights); \n"
: "");
} else {
fsSource +=
" float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n" +
" applyNormalOffset(positionEC, normalEC, nDotL); \n" +
" vec4 shadowPosition = shadowMap_matrix * positionEC; \n" +
" // Stop early if the fragment is not in the shadow bounds \n" +
" if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n" +
" { \n" +
" return; \n" +
" } \n" +
" shadowParameters.texCoords = shadowPosition.xy; \n" +
" shadowParameters.depth = shadowPosition.z; \n" +
" shadowParameters.nDotL = nDotL; \n" +
" float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n";
}
fsSource += " gl_FragColor.rgb *= visibility; \n" + "} \n";
sources.push(fsSource);
return new ShaderSource({
defines: defines,
sources: sources,
});
};
export default ShadowMapShader;
