LNXSDK/leenkx/Shaders/ssr_pass/ssr_pass.frag.glsl

#version 450

#include "compiled.inc"
#include "std/math.glsl"
#include "std/gbuffer.glsl"

uniform samplerCube probeTex;
uniform sampler2D tex;
uniform sampler2D gbufferD;
uniform sampler2D gbuffer0; // Normal, roughness
uniform sampler2D gbuffer1; // basecol, spec
uniform mat4 P;
uniform mat3 V3;
uniform vec2 cameraProj;

#ifdef _CPostprocess
uniform vec3 PPComp9;
uniform vec3 PPComp10;
#endif

in vec3 viewRay;
in vec2 texCoord;
out vec4 fragColor;

vec3 hitCoord;
float depth;

const int numBinarySearchSteps = 7;
const int maxSteps = int(ceil(1.0 / ssrRayStep) * ssrSearchDist);

// Project a view-space hit coordinate into screen UVs
vec2 getProjectedCoord(const vec3 hit) {
    vec4 projectedCoord = P * vec4(hit, 1.0);
    projectedCoord.xy /= projectedCoord.w;
    projectedCoord.xy = projectedCoord.xy * 0.5 + 0.5;
    #ifdef _InvY
    projectedCoord.y = 1.0 - projectedCoord.y;
    #endif
    return projectedCoord.xy;
}

// Compute depth difference between current ray hit and gbuffer depth
float getDeltaDepth(const vec3 hit) {
    depth = textureLod(gbufferD, getProjectedCoord(hit), 0.0).r * 2.0 - 1.0;
    vec3 viewPos = getPosView(viewRay, depth, cameraProj);
    return viewPos.z - hit.z;
}

// Refine hit using binary search
vec4 binarySearch(vec3 dir) {
    float ddepth;
    for (int i = 0; i < numBinarySearchSteps; i++) {
        dir *= 0.5;
        hitCoord -= dir;
        ddepth = getDeltaDepth(hitCoord);
        if (ddepth < 0.0) hitCoord += dir;
    }
    #ifdef _CPostprocess
    if (abs(ddepth) > PPComp9.z / 500) return vec4(0.0);
    #else
    if (abs(ddepth) > ssrSearchDist / 500) return vec4(0.0);
    #endif
    return vec4(getProjectedCoord(hitCoord), 0.0, 1.0);
}

// Perform raymarching using view-space direction
vec4 rayCast(vec3 dir) {
    #ifdef _CPostprocess
    dir *= PPComp9.x;
    #else
    dir *= ssrRayStep;
    #endif
    for (int i = 0; i < maxSteps; i++) {
        hitCoord += dir;
        if (getDeltaDepth(hitCoord) > 0.0) return binarySearch(dir);
    }
    return vec4(0.0);
}

void main() {
    vec4 g0 = textureLod(gbuffer0, texCoord, 0.0);
    float roughness = unpackFloat(g0.b).y;
    if (roughness >= 1.0) { fragColor.rgb = vec3(0.0); return; }

    float spec = fract(textureLod(gbuffer1, texCoord, 0.0).a);
    if (spec == 0.0) { fragColor.rgb = vec3(0.0); return; }

    float d = textureLod(gbufferD, texCoord, 0.0).r * 2.0 - 1.0;
    if (d == 1.0) { fragColor.rgb = vec3(0.0); return; }

    // Decode octahedral normal
    vec2 enc = g0.rg;
    vec3 n;
    n.z = 1.0 - abs(enc.x) - abs(enc.y);
    n.xy = n.z >= 0.0 ? enc.xy : octahedronWrap(enc.xy);
    n = normalize(n);
    vec3 viewNormal = normalize(V3 * n);

    // View-space position and reflection
    vec3 viewPos = getPosView(viewRay, d, cameraProj);
    vec3 viewDir = normalize(viewPos);
    vec3 reflected = normalize(reflect(viewDir, viewNormal));

    hitCoord = viewPos;

    // Importance sampling jitter based on roughness
    float jitterStrength = roughness * roughness;
    vec3 randVec = normalize(vec3(rand(texCoord), rand(texCoord * 1.3), rand(texCoord * 2.7)) * 2.0 - 1.0);
    vec3 dir = normalize(mix(reflected, randVec, jitterStrength));

    vec4 coords = rayCast(dir);
    vec2 deltaCoords = abs(vec2(0.5, 0.5) - coords.xy);
    float screenEdgeFactor = clamp(1.0 - (deltaCoords.x + deltaCoords.y), 0.0, 1.0);

    float reflectivity = 1.0 - roughness;
    #ifdef _CPostprocess
    float distAtten = clamp((PPComp9.z - length(viewPos - hitCoord)) / PPComp9.z, 0.0, 1.0);
    float intensity = pow(reflectivity, PPComp10.x) * screenEdgeFactor * clamp(-reflected.z, 0.0, 1.0) * distAtten * coords.w;
    #else
    float distAtten = clamp((ssrSearchDist - length(viewPos - hitCoord)) / ssrSearchDist, 0.0, 1.0);
    float intensity = pow(reflectivity, ssrFalloffExp) * screenEdgeFactor * clamp(-reflected.z, 0.0, 1.0) * distAtten * coords.w;
    #endif

    intensity = clamp(intensity, 0.0, 1.0);
    vec3 ssrColor = textureLod(tex, coords.xy, roughness * 4.0).rgb;
    ssrColor = clamp(ssrColor, 0.0, 1.0);

    // Cubemap fallback with roughness-aware LOD sampling
    vec3 cubemapColor = textureLod(probeTex, reflected, roughness * 6.0).rgb;

    // Additively blend SSR with cubemap fallback
    fragColor.rgb = mix(cubemapColor, ssrColor, intensity) * spec;
}