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;
|
