cesium
Version:
CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.
373 lines (311 loc) • 15.7 kB
JavaScript
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;