Files
cocos4/editor/assets/chunks/builtin/functionalities/shadow-map.chunk
T
2022-08-02 19:13:03 +08:00

294 lines
11 KiB
Plaintext

// used for replacing cc-shadow-map-base.chunk
#include <builtin/uniforms/cc-shadow>
#if CC_SUPPORT_CASCADED_SHADOW_MAP
#include <builtin/uniforms/cc-csm>
#endif
#include <common/common-define>
#include <common/math/coordinates>
#pragma define SHADOWMAP_FORMAT_RGBA8 1
#pragma define SHADOWMAP_FORMAT_FLOAT 0
float CCGetLinearDepth(vec3 worldPos, float viewSpaceBias) {
vec4 viewPos = cc_matLightView * vec4(worldPos.xyz, 1.0);
viewPos.z += viewSpaceBias;
return GetLinearDepthFromViewSpace(viewPos.xyz, cc_shadowNFLSInfo.x, cc_shadowNFLSInfo.y);
}
float CCGetLinearDepth(vec3 worldPos) {
return CCGetLinearDepth(worldPos, 0.0);
}
#if CC_RECEIVE_SHADOW
#include <builtin/uniforms/cc-global>
#include <builtin/uniforms/cc-shadow-map>
#include <common/data/packing>
#include <common/shadow/native-pcf>
//////////////////////////////////////////////////////////Helper Functions
// When screenSpaceSingY and clipSpaceSignY have different signs, need to flip the uv
#pragma define CC_HANDLE_NDC_SAMPLE_FLIP(uv) uv = cc_cameraPos.w == 1.0 ? vec2(uv.x, 1.0 - uv.y) : uv
bool GetShadowNDCPos(out vec3 shadowNDCPos, vec4 shadowPosWithDepthBias)
{
shadowNDCPos = shadowPosWithDepthBias.xyz / shadowPosWithDepthBias.w * 0.5 + 0.5;
if (shadowNDCPos.x < 0.0 || shadowNDCPos.x > 1.0 ||
shadowNDCPos.y < 0.0 || shadowNDCPos.y > 1.0 ||
shadowNDCPos.z < 0.0 || shadowNDCPos.z > 1.0) {
return false;
}
CC_HANDLE_NDC_SAMPLE_FLIP(shadowNDCPos.xy);
return true;
}
vec4 ApplyShadowDepthBias_FaceNormal(vec4 shadowPos, vec3 worldNormal, float normalBias, vec3 matViewDir0, vec3 matViewDir1, vec3 matViewDir2, vec2 projScaleXY)
{
vec4 newShadowPos = shadowPos;
if (normalBias > EPSILON_LOWP)
{
vec3 viewNormal = vec3(dot(matViewDir0, worldNormal), dot(matViewDir1, worldNormal), dot(matViewDir2, worldNormal));
if (viewNormal.z < 0.1)
newShadowPos.xy += viewNormal.xy * projScaleXY * normalBias * clamp(viewNormal.z, 0.001, 0.1);
}
return newShadowPos;
}
vec4 ApplyShadowDepthBias_FaceNormal(vec4 shadowPos, vec3 worldNormal, float normalBias, mat4 matLightView, vec2 projScaleXY)
{
vec4 newShadowPos = shadowPos;
if (normalBias > EPSILON_LOWP)
{
vec4 viewNormal = matLightView * vec4(worldNormal, 0.0);
if (viewNormal.z < 0.1)
newShadowPos.xy += viewNormal.xy * projScaleXY * normalBias * clamp(viewNormal.z, 0.001, 0.1);
}
return newShadowPos;
}
vec4 ApplyShadowDepthBias_Perspective(vec4 shadowPos, float viewspaceDepthBias)
{
// Recover the coord in view space: cc_matLightInvProj * shadowPos
vec3 viewSpacePos;
viewSpacePos.xy = shadowPos.xy * cc_shadowProjInfo.zw;
viewSpacePos.z = shadowPos.z * cc_shadowInvProjDepthInfo.x + shadowPos.w * cc_shadowInvProjDepthInfo.y;
// Apply bias
viewSpacePos.xyz += cc_shadowProjDepthInfo.z * normalize(viewSpacePos.xyz) * viewspaceDepthBias;
// Reconstuct clipspace: cc_matLightProj * viewSpacePos
vec4 clipSpacePos;
clipSpacePos.xy = viewSpacePos.xy * cc_shadowProjInfo.xy;
clipSpacePos.zw = viewSpacePos.z * cc_shadowProjDepthInfo.xz + vec2(cc_shadowProjDepthInfo.y, 0.0);
// enabled linear depth?
#if CC_SHADOWMAP_USE_LINEAR_DEPTH
clipSpacePos.z = GetLinearDepthFromViewSpace(viewSpacePos.xyz, cc_shadowNFLSInfo.x, cc_shadowNFLSInfo.y);
clipSpacePos.z = (clipSpacePos.z * 2.0 - 1.0) * clipSpacePos.w;
#endif
return clipSpacePos;
}
// (projScaleZ, projBiasZ) = cc_shadowProjDepthInfo.xy
vec4 ApplyShadowDepthBias_Orthographic(vec4 shadowPos, float viewspaceDepthBias, float projScaleZ, float projBiasZ)
{
float coeffA = projScaleZ;
float coeffB = projBiasZ;
// Recover the Z distance in view space:
float viewSpacePos_z = (shadowPos.z - coeffB) / coeffA;
// Apply bias
viewSpacePos_z += viewspaceDepthBias;
// Reconstuct clipspace
vec4 result = shadowPos;
result.z = viewSpacePos_z * coeffA + coeffB;
return result;
}
vec4 ApplyShadowDepthBias_PerspectiveLinearDepth(vec4 shadowPos, float viewspaceDepthBias, vec3 worldPos)
{
// reverse operation for GetShadowNDCPos
shadowPos.z = CCGetLinearDepth(worldPos, viewspaceDepthBias) * 2.0 - 1.0;
shadowPos.z *= shadowPos.w;
return shadowPos;
}
//////////////////////////////////////////////////////////Directional Light Shadow
float CCGetDirLightShadowFactorHard (vec4 shadowPosWithDepthBias) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorHard(shadowNDCPos, cc_shadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetDirLightShadowFactorSoft (vec4 shadowPosWithDepthBias) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft(shadowNDCPos, cc_shadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetDirLightShadowFactorSoft3X (vec4 shadowPosWithDepthBias) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft3X(shadowNDCPos, cc_shadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetDirLightShadowFactorSoft5X (vec4 shadowPosWithDepthBias) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft5X(shadowNDCPos, cc_shadowMap, cc_shadowWHPBInfo.xy);
}
//////////////////////////////////////////////////////////Spot Light Shadow
float CCGetSpotLightShadowFactorHard (vec4 shadowPosWithDepthBias, vec3 worldPos) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorHard(shadowNDCPos, cc_spotShadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetSpotLightShadowFactorSoft (vec4 shadowPosWithDepthBias, vec3 worldPos) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft(shadowNDCPos, cc_spotShadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetSpotLightShadowFactorSoft3X (vec4 shadowPosWithDepthBias, vec3 worldPos) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft3X(shadowNDCPos, cc_spotShadowMap, cc_shadowWHPBInfo.xy);
}
float CCGetSpotLightShadowFactorSoft5X (vec4 shadowPosWithDepthBias, vec3 worldPos) {
vec3 shadowNDCPos;
if (!GetShadowNDCPos(shadowNDCPos, shadowPosWithDepthBias)) {
return 1.0;
}
return NativePCFShadowFactorSoft5X(shadowNDCPos, cc_spotShadowMap, cc_shadowWHPBInfo.xy);
}
//////////////////////////////////////////////////////////Main Functions
float CCSpotShadowFactorBase(vec4 shadowPos, vec3 worldPos, vec2 shadowBias)
{
float pcf = cc_shadowWHPBInfo.z;
vec4 pos = vec4(1.0);
#if CC_SHADOWMAP_USE_LINEAR_DEPTH
pos = ApplyShadowDepthBias_PerspectiveLinearDepth(shadowPos, shadowBias.x, worldPos);
#else
pos = ApplyShadowDepthBias_Perspective(shadowPos, shadowBias.x);
#endif
/*todo: use CC_SHADOWMAP_PCF_TYPE for better performance
if (pcf > 2.9) {
return CCGetSpotLightShadowFactorSoft5X(pos, worldPos);
} else */
if (pcf > 1.9) {
return CCGetSpotLightShadowFactorSoft3X(pos, worldPos);
}else if (pcf > 0.9) {
return CCGetSpotLightShadowFactorSoft(pos, worldPos);
}else {
return CCGetSpotLightShadowFactorHard(pos, worldPos);
}
}
float CCShadowFactorBase(vec4 shadowPos, vec3 N, vec2 shadowBias)
{
float realtimeShadow = 1.0;
vec4 pos = ApplyShadowDepthBias_FaceNormal(shadowPos, N, shadowBias.y, cc_matLightView, cc_shadowProjInfo.xy);
pos = ApplyShadowDepthBias_Orthographic(pos, shadowBias.x, cc_shadowProjDepthInfo.x, cc_shadowProjDepthInfo.y);
float pcf = cc_shadowWHPBInfo.z;
/*todo: use CC_SHADOWMAP_PCF_TYPE for better performance
if (pcf > 2.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft5X(pos);
} else */
if (pcf > 1.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft3X(pos);
}else if (pcf > 0.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft(pos);
}else {
realtimeShadow = CCGetDirLightShadowFactorHard(pos);
}
return mix(realtimeShadow, 1.0, cc_shadowNFLSInfo.w);
}
#if CC_SUPPORT_CASCADED_SHADOW_MAP
int CCGetCSMLevel(out vec4 csmPos, out vec4 shadowProjDepthInfo, out vec4 shadowProjInfo, out vec3 shadowViewDir0, out vec3 shadowViewDir1, out vec3 shadowViewDir2, vec3 worldPos) {
int layer = -1;
highp float layerThreshold = cc_csmViewDir0[0].w;
for (int i = 0; i < NUMCASCADES; i++) {
vec4 shadowPos = cc_matCSMViewProj[i] * vec4(worldPos.xyz, 1.0);
vec3 clipPos = shadowPos.xyz / shadowPos.w * 0.5 + 0.5;
if (clipPos.x >= (0.0 + layerThreshold) && clipPos.x <= (1.0 - layerThreshold) &&
clipPos.y >= (0.0 + layerThreshold) && clipPos.y <= (1.0 - layerThreshold) &&
clipPos.z >= 0.0 && clipPos.z <= 1.0 && layer < 0) {
csmPos = cc_matCSMViewProj[i] * vec4(worldPos.xyz, 1.0);
csmPos.xy = csmPos.xy * cc_csmAtlas[i].xy + cc_csmAtlas[i].zw;
shadowProjDepthInfo = cc_csmProjDepthInfo[i];
shadowProjInfo = cc_csmProjInfo[i];
shadowViewDir0 = cc_csmViewDir0[i].xyz;
shadowViewDir1 = cc_csmViewDir1[i].xyz;
shadowViewDir2 = cc_csmViewDir2[i].xyz;
layer = i;
}
}
return layer;
}
float CCCSMFactorBase(vec3 worldPos, vec3 N, vec2 shadowBias)
{
vec4 csmPos = vec4(1.0);
vec4 shadowProjDepthInfo, shadowProjInfo;
vec3 shadowViewDir0, shadowViewDir1, shadowViewDir2;
int level = CCGetCSMLevel(csmPos, shadowProjDepthInfo, shadowProjInfo, shadowViewDir0, shadowViewDir1, shadowViewDir2, worldPos);
if (level < 0) { return 1.0; }
float realtimeShadow = 1.0;
vec4 pos = ApplyShadowDepthBias_FaceNormal(csmPos, N, shadowBias.y, shadowViewDir0, shadowViewDir1, shadowViewDir2, shadowProjInfo.xy);
pos = ApplyShadowDepthBias_Orthographic(pos, shadowBias.x, shadowProjDepthInfo.x, shadowProjDepthInfo.y);
float pcf = cc_shadowWHPBInfo.z;
/*todo: use CC_SHADOWMAP_PCF_TYPE for better performance
if (pcf > 2.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft5X(pos);
} else */
if (pcf > 1.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft3X(pos);
} else if (pcf > 0.9) {
realtimeShadow = CCGetDirLightShadowFactorSoft(pos);
}else {
realtimeShadow = CCGetDirLightShadowFactorHard(pos);
}
return mix(realtimeShadow, 1.0, cc_shadowNFLSInfo.w);
}
#else
int CCGetCSMLevel(out vec4 csmPos, out vec4 shadowProjDepthInfo, out vec4 shadowProjInfo, out vec3 shadowViewDir0, out vec3 shadowViewDir1, out vec3 shadowViewDir2, vec3 worldPos) {
return -1;
}
float CCCSMFactorBase(vec3 worldPos, vec3 N, vec2 shadowBias) {
vec4 shadowPos = cc_matLightViewProj * vec4(worldPos, 1.0);
return CCShadowFactorBase(shadowPos, N, shadowBias);
}
#endif
#endif