Merged csm branch with minor fixes.

Author: bryanedds

Nu/Nu.Gaia/Assets/Default/FilterGaussianArray2d.glsl

@@ -0,0 +1,36 @@
+#shader vertex
+#version 460 core
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec2 texCoords;
+
+out vec2 texCoordsOut;
+
+void main()
+{
+    texCoordsOut = texCoords;
+    gl_Position = vec4(position, 1.0);
+}
+
+#shader fragment
+#version 460 core
+
+uniform vec2 scale;
+uniform int inputIndex;
+uniform sampler2DArray inputTextureArray;
+
+in vec2 texCoordsOut;
+
+layout(location = 0) out vec2 frag;
+
+void main()
+{
+    frag =
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(-3.0) * scale, float(inputIndex))).xy * (1.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(-2.0) * scale, float(inputIndex))).xy * (6.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(-1.0) * scale, float(inputIndex))).xy * (15.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(0.0) * scale, float(inputIndex))).xy * (20.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(1.0) * scale, float(inputIndex))).xy * (15.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(2.0) * scale, float(inputIndex))).xy * (6.0 / 64.0) +
+        texture(inputTextureArray, vec3(texCoordsOut + vec2(3.0) * scale, float(inputIndex))).xy * (1.0 / 64.0);
+}

Nu/Nu.Gaia/Assets/Default/PhysicallyBasedDeferredLighting.glsl

@@ -19,10 +19,13 @@ const float PI = 3.141592654;
 const float PI_OVER_2 = PI / 2.0;
 const float ATTENUATION_CONSTANT = 1.0;
 const int LIGHTS_MAX = 64;
-const int SHADOW_TEXTURES_MAX = 9;
-const int SHADOW_MAPS_MAX = 9;
+const int SHADOW_TEXTURES_MAX = 8;
+const int SHADOW_MAPS_MAX = 8;
+const float SHADOW_DIRECTIONAL_SEAM_INSET = 0.05; // TODO: see if this should be proportionate to shadow texel size.
+const int SHADOW_CASCADES_MAX = 2;
+const int SHADOW_CASCADE_LEVELS = 3;
+const float SHADOW_CASCADE_SEAM_INSET = 0.001;
 const float SHADOW_FOV_MAX = 2.1;
-const float SHADOW_SEAM_INSET = 0.05; // TODO: see if this should be proportionate to shadow texel size.
 
 const vec4 SSVF_DITHERING[4] =
 vec4[](
@@ -55,6 +58,7 @@ uniform sampler2D subdermalPlusTexture;
 uniform sampler2D scatterPlusTexture;
 uniform sampler2D shadowTextures[SHADOW_TEXTURES_MAX];
 uniform samplerCube shadowMaps[SHADOW_MAPS_MAX];
+uniform sampler2DArray shadowCascades[SHADOW_CASCADES_MAX];
 uniform vec3 lightOrigins[LIGHTS_MAX];
 uniform vec3 lightDirections[LIGHTS_MAX];
 uniform vec3 lightColors[LIGHTS_MAX];
@@ -69,7 +73,7 @@ uniform int lightDesireFogs[LIGHTS_MAX];
 uniform int lightShadowIndices[LIGHTS_MAX];
 uniform int lightsCount;
 uniform float shadowNear;
-uniform mat4 shadowMatrices[SHADOW_TEXTURES_MAX];
+uniform mat4 shadowMatrices[SHADOW_TEXTURES_MAX + SHADOW_CASCADES_MAX * SHADOW_CASCADE_LEVELS];
 
 in vec2 texCoordsOut;
 
@@ -186,7 +190,7 @@ float fadeShadowScalar(vec2 shadowTexCoords, float shadowScalar)
     return 1.0 - (1.0 - shadowScalar) * (1.0 - fadeScalar);
 }
 
-float computeShadowScalarPoint(vec4 position, vec3 lightOrigin, int shadowMapIndex)
+float computeShadowScalarPoint(vec4 position, vec3 lightOrigin, int shadowIndex)
 {
     vec3 positionShadow = position.xyz - lightOrigin;
     float shadowZ = length(positionShadow);
@@ -198,7 +202,7 @@ float computeShadowScalarPoint(vec4 position, vec3 lightOrigin, int shadowMapInd
             for (int k = 0; k < lightShadowSamples; ++k)
             {
                 vec3 offset = (vec3(i, j, k) - vec3(lightShadowSamples / 2.0)) * (lightShadowSampleScalar / lightShadowSamples);
-                shadowHits += shadowZ - lightShadowBias > texture(shadowMaps[shadowMapIndex], positionShadow + offset).x ? 1.0 : 0.0;
+                shadowHits += shadowZ - lightShadowBias > texture(shadowMaps[shadowIndex - SHADOW_TEXTURES_MAX], positionShadow + offset).x ? 1.0 : 0.0;
             }
         }
     }
@@ -232,9 +236,9 @@ float computeShadowScalarDirectional(vec4 position, int shadowIndex)
     vec4 positionShadowClip = shadowMatrix * position;
     vec3 shadowTexCoordsProj = positionShadowClip.xyz / positionShadowClip.w;
     vec3 shadowTexCoords = shadowTexCoordsProj * 0.5 + 0.5;
-    if (shadowTexCoords.x > SHADOW_SEAM_INSET && shadowTexCoords.x < 1.0 - SHADOW_SEAM_INSET &&
-        shadowTexCoords.y > SHADOW_SEAM_INSET && shadowTexCoords.y < 1.0 - SHADOW_SEAM_INSET &&
-        shadowTexCoords.z > 0.5 + SHADOW_SEAM_INSET && shadowTexCoords.z < 1.0 - SHADOW_SEAM_INSET) // TODO: figure out why shadowTexCoords.z range is 0.5 to 1.0.
+    if (shadowTexCoords.x > SHADOW_DIRECTIONAL_SEAM_INSET && shadowTexCoords.x < 1.0 - SHADOW_DIRECTIONAL_SEAM_INSET &&
+        shadowTexCoords.y > SHADOW_DIRECTIONAL_SEAM_INSET && shadowTexCoords.y < 1.0 - SHADOW_DIRECTIONAL_SEAM_INSET &&
+        shadowTexCoords.z > 0.5 + SHADOW_DIRECTIONAL_SEAM_INSET && shadowTexCoords.z < 1.0 - SHADOW_DIRECTIONAL_SEAM_INSET) // TODO: figure out why shadowTexCoords.z range is 0.5 to 1.0.
     {
         float shadowZ = shadowTexCoords.z;
         float shadowZExp = exp(-lightShadowExponent * shadowZ);
@@ -246,7 +250,30 @@ float computeShadowScalarDirectional(vec4 position, int shadowIndex)
     return 1.0;
 }
 
-float geometryTravelPoint(vec4 position, int lightIndex, int shadowMapIndex)
+float computeShadowScalarCascaded(vec4 position, float shadowCutoff, int shadowIndex)
+{
+    for (int i = 0; i < SHADOW_CASCADE_LEVELS; ++i)
+    {
+        mat4 shadowMatrix = shadowMatrices[SHADOW_TEXTURES_MAX + (shadowIndex - SHADOW_TEXTURES_MAX) * SHADOW_CASCADE_LEVELS + i];
+        vec4 positionShadowClip = shadowMatrix * position;
+        vec3 shadowTexCoordsProj = positionShadowClip.xyz / positionShadowClip.w;
+        vec3 shadowTexCoords = shadowTexCoordsProj * 0.5 + 0.5;
+        if (shadowTexCoords.x > SHADOW_CASCADE_SEAM_INSET && shadowTexCoords.x < 1.0 - SHADOW_CASCADE_SEAM_INSET &&
+            shadowTexCoords.y > SHADOW_CASCADE_SEAM_INSET && shadowTexCoords.y < 1.0 - SHADOW_CASCADE_SEAM_INSET &&
+            shadowTexCoords.z > 0.5 + SHADOW_CASCADE_SEAM_INSET && shadowTexCoords.z < 1.0 - SHADOW_CASCADE_SEAM_INSET) // TODO: figure out why shadowTexCoords.z range is 0.5 to 1.0.
+        {
+            float shadowZ = shadowTexCoordsProj.z * 0.5 + 0.5;
+            float shadowZExp = exp(-lightShadowExponent * shadowZ);
+            float shadowDepthExp = texture(shadowCascades[shadowIndex - SHADOW_TEXTURES_MAX], vec3(shadowTexCoords.xy, float(i))).y;
+            float shadowScalar = clamp(shadowZExp * shadowDepthExp, 0.0, 1.0);
+            shadowScalar = pow(shadowScalar, lightShadowDensity);
+            return shadowScalar;
+        }
+    }
+    return 1.0;
+}
+
+float geometryTravelPoint(vec4 position, int lightIndex, int shadowIndex)
 {
     // compute travel average in world space
     vec3 lightOrigin = lightOrigins[lightIndex];
@@ -260,7 +287,7 @@ float geometryTravelPoint(vec4 position, int lightIndex, int shadowMapIndex)
             for (int k = -1; k <= 1; k += 2)
             {
                 vec3 offset = vec3(i, j, k) * lightShadowSampleScalar;
-                float shadowDepth = texture(shadowMaps[shadowMapIndex], positionShadow + offset).x;
+                float shadowDepth = texture(shadowMaps[shadowIndex - SHADOW_TEXTURES_MAX], positionShadow + offset).x;
                 float delta = shadowZ - shadowDepth;
                 travel += max(0.0, delta);
             }
@@ -330,6 +357,34 @@ float geometryTravelDirectional(vec4 position, int lightIndex, int shadowIndex)
     return 1.0;
 }
 
+float geometryTravelCascaded(vec4 position, int lightIndex, int shadowIndex)
+{
+    for (int i = 0; i < SHADOW_CASCADE_LEVELS; ++i)
+    {
+        // attempt to compute travel average in view space
+        mat4 shadowMatrix = shadowMatrices[SHADOW_TEXTURES_MAX + (shadowIndex - SHADOW_TEXTURES_MAX) * SHADOW_CASCADE_LEVELS + i];
+        vec4 positionShadowClip = shadowMatrix * position;
+        vec3 shadowTexCoordsProj = positionShadowClip.xyz / positionShadowClip.w; // ndc space
+        vec3 shadowTexCoords = shadowTexCoordsProj * 0.5 + 0.5; // adj-ndc space
+        if (shadowTexCoords.x > 0.0 && shadowTexCoords.x < 1.0 &&
+            shadowTexCoords.y > 0.0 && shadowTexCoords.y < 1.0 &&
+            shadowTexCoords.z > 0.5 && shadowTexCoords.z < 1.0) // TODO: figure out why shadowTexCoords.z range is 0.5 to 1.0.
+        {
+            // compute light distance travel through surface (not accounting for incidental surface concavity)
+            float shadowZScreen = shadowTexCoords.z; // linear, screen space
+            vec2 shadowTextureSize = textureSize(shadowCascades[shadowIndex - SHADOW_TEXTURES_MAX], 0).xy;
+            vec2 shadowTexelSize = 1.0 / shadowTextureSize;
+            float shadowDepthScreen = texture(shadowCascades[shadowIndex - SHADOW_TEXTURES_MAX], vec3(shadowTexCoords.xy, float(i))).x; // linear, screen space
+            float delta = shadowZScreen - shadowDepthScreen;
+            float shadowFar = lightCutoffs[lightIndex];
+            return max(0.0, delta * shadowFar);
+        }
+    }
+
+    // tracing out of range, return default
+    return 1.0;
+}
+
 vec3 computeSubsurfaceScatter(vec4 position, vec3 albedo, vec4 subdermalPlus, vec4 scatterPlus, float nDotL, vec2 texCoords, int lightIndex)
 {
     // retrieve light and shadow values
@@ -343,14 +398,17 @@ vec3 computeSubsurfaceScatter(vec4 position, vec3 albedo, vec4 subdermalPlus, ve
         switch (lightType)
         {
         case 0: // point light
-            travel = geometryTravelPoint(position, lightIndex, shadowIndex - SHADOW_TEXTURES_MAX);
+            travel = geometryTravelPoint(position, lightIndex, shadowIndex);
             break;
         case 1: // spot light
             travel = geometryTravelSpot(position, lightIndex, shadowIndex);
             break;
-        default: // directional light
+        case 2: // directional light
             travel = geometryTravelDirectional(position, lightIndex, shadowIndex);
             break;
+        default: // cascaded light
+            travel = geometryTravelCascaded(position, lightIndex, shadowIndex);
+            break;
         }
     }
 
@@ -601,6 +659,66 @@ vec3 computeFogAccumDirectional(vec4 position, int lightIndex)
     return result;
 }
 
+vec3 computeFogAccumCascaded(vec4 position, int lightIndex)
+{
+    vec3 result = vec3(0.0);
+    int shadowIndex = lightShadowIndices[lightIndex];
+    if (shadowIndex >= 0)
+    {
+        // grab light values
+        vec3 lightOrigin = lightOrigins[lightIndex];
+        vec3 lightDirection = lightDirections[lightIndex];
+
+        // compute ray info
+        vec3 startPosition = eyeCenter;
+        vec3 rayVector = position.xyz - startPosition;
+        float rayLength = length(rayVector);
+        vec3 rayDirection = rayVector / rayLength;
+
+        // compute step info
+        float stepLength = rayLength / ssvfSteps;
+        vec3 step = rayDirection * stepLength;
+
+        // compute light view term
+        float theta = dot(-rayDirection, lightDirection);
+
+        // compute dithering
+        float dithering = SSVF_DITHERING[int(gl_FragCoord.x) % 4][int(gl_FragCoord.y) % 4];
+
+        // march over ray, accumulating fog light value
+        vec3 currentPosition = startPosition + step * dithering;
+        for (int i = 0; i < ssvfSteps; ++i)
+        {
+            // use the nearest available cascade for this step
+            for (int j = 0; j < SHADOW_CASCADE_LEVELS; ++j)
+            {
+                // compute depths
+                mat4 shadowMatrix = shadowMatrices[SHADOW_TEXTURES_MAX + (shadowIndex - SHADOW_TEXTURES_MAX) * SHADOW_CASCADE_LEVELS + j];
+                vec4 positionShadowClip = shadowMatrix * vec4(currentPosition, 1.0);
+                vec3 shadowTexCoordsProj = positionShadowClip.xyz / positionShadowClip.w;
+                vec3 shadowTexCoords = shadowTexCoordsProj * 0.5 + 0.5;
+                bool shadowTexCoordsInRange = shadowTexCoords.x >= 0.0 && shadowTexCoords.x < 1.0 && shadowTexCoords.y >= 0.0 && shadowTexCoords.y < 1.0;
+                float shadowZ = shadowTexCoords.z;
+                float shadowDepth = shadowTexCoordsInRange ? texture(shadowCascades[shadowIndex - SHADOW_TEXTURES_MAX], vec3(shadowTexCoords.xy, float(i))).x : 1.0;
+
+                // step through ray, accumulating fog light moment
+                if (shadowZ <= shadowDepth || shadowZ >= 1.0f)
+                {
+                    // mie scaterring approximated with Henyey-Greenstein phase function
+                    float asymmetrySquared = ssvfAsymmetry * ssvfAsymmetry;
+                    float fogMoment = (1.0 - asymmetrySquared) / (4.0 * PI * pow(1.0 + asymmetrySquared - 2.0 * ssvfAsymmetry * theta, 1.5));
+                    result += fogMoment;
+                }
+            }
+
+            // step
+            currentPosition += step;
+        }
+        result = smoothstep(0.0, 1.0, result / (ssvfSteps * SHADOW_CASCADE_LEVELS)) * lightColors[lightIndex] * lightBrightnesses[lightIndex] * ssvfIntensity;
+    }
+    return result;
+}
+
 void main()
 {
     // ensure fragment was written
@@ -634,19 +752,20 @@ void main()
     {
         // per-light radiance
         vec3 lightOrigin = lightOrigins[i];
+        float lightCutoff = lightCutoffs[i];
         int lightType = lightTypes[i];
         bool lightDirectional = lightType == 2;
+        bool lightCascaded = lightType == 3;
         vec3 l, h, radiance;
         float intensity = 0.0;
-        if (!lightDirectional)
+        if (!lightDirectional && !lightCascaded)
         {
             vec3 d = lightOrigin - position.xyz;
             l = normalize(d);
             h = normalize(v + l);
             float distanceSquared = dot(d, d);
             float distance = sqrt(distanceSquared);
-            float cutoff = lightCutoffs[i];
-            float cutoffScalar = 1.0 - smoothstep(cutoff * (1.0 - lightCutoffMargin), cutoff, distance);
+            float cutoffScalar = 1.0 - smoothstep(lightCutoff * (1.0 - lightCutoffMargin), lightCutoff, distance);
             float attenuation = 1.0 / (ATTENUATION_CONSTANT + lightAttenuationLinears[i] * distance + lightAttenuationQuadratics[i] * distanceSquared);
             float angle = acos(dot(l, -lightDirections[i]));
             float halfConeInner = lightConeInners[i] * 0.5;
@@ -672,9 +791,10 @@ void main()
         {
             switch (lightType)
             {
-                case 0: { shadowScalar = computeShadowScalarPoint(position, lightOrigin, shadowIndex - SHADOW_TEXTURES_MAX); break; } // point
+                case 0: { shadowScalar = computeShadowScalarPoint(position, lightOrigin, shadowIndex); break; } // point
                 case 1: { shadowScalar = computeShadowScalarSpot(position, lightConeOuters[i], shadowIndex); break; } // spot
-                default: { shadowScalar = computeShadowScalarDirectional(position, shadowIndex); break; } // directional
+                case 2: { shadowScalar = computeShadowScalarDirectional(position, shadowIndex); break; } // directional
+                default: { shadowScalar = computeShadowScalarCascaded(position, lightCutoff, shadowIndex); break; } // cascaded
             }
         }
 
@@ -713,7 +833,8 @@ void main()
             {
                 case 0: { fogAccum.rgb += computeFogAccumPoint(position, i); break; } // point
                 case 1: { fogAccum.rgb += computeFogAccumSpot(position, i); break; } // spot
-                default: { fogAccum.rgb += computeFogAccumDirectional(position, i); break; } // directional
+                case 2: { fogAccum.rgb += computeFogAccumDirectional(position, i); break; } // directional
+                default: { fogAccum.rgb += computeFogAccumCascaded(position, i); break; } // cascaded
             }
         }
     }