How to implement an Disney BRDF PBR Render in Vulkan correctly?

I used to implement an Disney BRDF PBR Render in Vulkan with HLSL, but it seem that not looks right, the effect like this:


It not looks right.
And here is my main shader:

struct VSOutput
{
    float4 Pos : SV_POSITION;
    [[vk::location(0)]] float2 UV : TEXCOORD0;
    [[vk::location(1)]] float4 shadowCoord : TEXCOORD1;
    [[vk::location(2)]] float3 normal : NORMAL0;
    [[vk::location(3)]] float3 tangent : TANGENT0;
    [[vk::location(4)]] float3 binormal : BINORMAL0;
    [[vk::location(5)]] float4 fragmentPos : POSITION0;
};

struct CameraUBO
{
    float4x4 viewMatrix;
    float4x4 projectionMatrix;
    float4x4 shadowMVP;
    float3 cameraPosition;
    float4 lightPosition[4];
    int centerMarker;

};

cbuffer cameraUBO : register(b1)
{
    CameraUBO cameraUBO;
};

Texture2D textureColor : register(t2);
SamplerState samplerColor : register(s2);

Texture2D normalColor : register(t4);
SamplerState samplerNormal : register(s4);

Texture2D roughnessColor : register(t5);
SamplerState samplerRoughness : register(s5);

Texture2D metallicColor : register(t6);
SamplerState samplerMetallic : register(s6);

Texture2D outlineMask : register(t7);
SamplerState samplerOutlineMask : register(t7);

struct ViewportUBO
{
    float2 viewportSize;
};

cbuffer viewportUBO : register(b8)
{
    ViewportUBO viewportUBO;
}

struct DisneyMaterial
{
    float3 C; // 基础色
    float metallic; // 金属度
    float roughness; // 粗糙度
    float subsurface; // 次表面
    float sheen; // 光泽
    float sheenTint; // 光泽调色
    float specular; // 高光
    float specularTint; // 高光调色
    float anisotropic; // 各向异性
    float clearcoat; // 清漆
    float clearcoatGloss; // 清漆光滑
};

cbuffer materialUBO : register(b3)
{
    DisneyMaterial materialUBO;
};

Texture2D shadowmap : register(t10);
SamplerState samplerShadowmap : register(s10);

Texture2D brdfLUT : register(t11);
SamplerState samplerBrdfLUT : register(s11);

Texture2D irrandanceMap : register(t12);
SamplerState samplerIrrandanceMap : register(s12);

Texture2D prefilterMap : register(t13);
SamplerState samplerPrefilterMap : register(s13);

#define PI (3.14159265358979323846)
//圆周率
float sqr(float x)
{
    return x * x;
}
//平方
float SchlickFresnel(float u)
{ //SchlickFresnel 菲涅耳
    float m = clamp(1 - u, 0, 1);
              //反向,并限制在0-1范围内
    float m2 = m * m;
              //平方
    return m2 * m2 * m; // 5次方
}
float GTR1(float NdotH, float a)
{
    if (a >= 1)
        return 1 / PI;
    //如果a大于等于1,就返回圆周率倒数
    float a2 = a * a;
    float t = 1 + (a2 - 1) * NdotH * NdotH;
    return (a2 - 1) / (PI * log(a2) * t);
}
float GTR2(float NdotH, float a)
{
    float a2 = a * a;
    float t = 1 + (a2 - 1) * NdotH * NdotH;
    return a2 / (PI * t * t);
}
float GTR2_aniso(float NdotH, float HdotX, float HdotY, float ax, float ay)
{
    return 1 / (PI * ax * ay * sqr(sqr(HdotX / ax) + sqr(HdotY / ay) + NdotH * NdotH));
}
float smithG_GGX(float NdotV, float alphaG)
{
    float a = alphaG * alphaG;
    float b = NdotV * NdotV;
    return 1 / (NdotV + sqrt(a + b - a * b));
}
float smithG_GGX_aniso(float NdotV, float VdotX, float VdotY, float ax, float ay)
{
    return 1 / (NdotV + sqrt(sqr(VdotX * ax) + sqr(VdotY * ay) + sqr(NdotV)));
}
float3 mon2lin(float3 x)
{
    return float3(pow(x[0], 2.2), pow(x[1], 2.2), pow(x[2], 2.2));
}
float3 BRDF(float3 L, float3 V, float3 N, float3 X, float3 Y, DisneyMaterial mat)
{
    float NdotL = dot(N, L);
    float NdotV = dot(N, V);
    if (NdotL < 0 || NdotV < 0)
    {
        return float3(0, 0, 0);
    }
    //限制条件,如果小于0,则无意义
    float3 H = normalize(L + V);
    float NdotH = dot(N, H);
    float LdotH = dot(L, H);
    float3 Cdlin = mon2lin(mat.C);
    float Cdlum = .3 * Cdlin[0] + .6 * Cdlin[1] + .1 * Cdlin[2]; // luminance approx.
    float3 Ctint = Cdlum > 0 ? Cdlin / Cdlum : float3(1, 1, 1); // normalize lum. to isolate hue+sat
    float3 Cspec0 = lerp(mat.specular * .08 * lerp(float3(1, 1, 1), Ctint, mat.specularTint), Cdlin, mat.metallic);
    float3 Csheen = lerp(float3(1, 1, 1), Ctint, mat.sheenTint);
    // 并根据粗糙度混合漫反射回射
    float FL = SchlickFresnel(NdotL), FV = SchlickFresnel(NdotV);
    float Fd90 = 0.5 + 2 * LdotH * LdotH * mat.roughness;
    float Fd = lerp(1.0, Fd90, FL) * lerp(1.0, Fd90, FV);
     //基于各向同性bssrdf的Hanrahan-Krueger brdf逼近
     // 1.25刻度用于(大致)保留反照率
     // Fss90用于“平整”基于粗糙度的回射
    float Fss90 = LdotH * LdotH * mat.roughness;
    float Fss = lerp(1.0, Fss90, FL) * lerp(1.0, Fss90, FV);
    float ss = 1.25 * (Fss * (1 / (NdotL + NdotV) - .5) + .5);
    // specular
    float aspect = sqrt(1 - mat.anisotropic * .9);
    float ax = max(.001, sqr(mat.roughness) / aspect);
    float ay = max(.001, sqr(mat.roughness) * aspect);
    float Ds = GTR2_aniso(NdotH, dot(H, X), dot(H, Y), ax, ay);
    float FH = SchlickFresnel(LdotH);
    float3 Fs = lerp(Cspec0, float3(1, 1, 1), FH);
    float Gs;
    Gs = smithG_GGX_aniso(NdotL, dot(L, X), dot(L, Y), ax, ay);
    Gs *= smithG_GGX_aniso(NdotV, dot(V, X), dot(V, Y), ax, ay);
    // sheen
    float3 Fsheen = FH * mat.sheen * Csheen;
    // clearcoat (ior = 1.5 -> F0 = 0.04)
    float Dr = GTR1(NdotH, lerp(.1, .001, mat.clearcoatGloss));
    float Fr = lerp(.04, 1.0, FH);
    float Gr = smithG_GGX(NdotL, .25) * smithG_GGX(NdotV, .25);
    return ((1 / PI) * lerp(Fd, ss, mat.subsurface) * Cdlin + Fsheen)
        * (1 - mat.metallic)
        + Gs * Fs * Ds + .25 * mat.clearcoat * Gr * Fr * Dr;
}

float3 DiffuseDisney(float3 DiffuseColor, float Roughness, float NoV, float NoL, float VoH)
{
    float FD90 = 0.5 + 2 * VoH * VoH * Roughness;
    float FdV = 1 + (FD90 - 1) * pow(1 - NoV, 5);
    float FdL = 1 + (FD90 - 1) * pow(1 - NoL, 5);
    return DiffuseColor * ((1 / PI) * FdV * FdL);
}

#define LIGHT_NUMBER 4
// wi: 入射方向
// wo: 出射方向
// normal: 法线方向
// mat: 材质
float3 DisneyPBR(float3 wi[LIGHT_NUMBER], float3 wo, float3 normal, float3 tangent, float3 binormal, DisneyMaterial mat)
{
    float brightness = 1.0;
    float gamma = 2.2;
    float exposure = 0.0;
    float3 result = float3(0.0, 0.0, 0.0);
    for (int n = 0; n < LIGHT_NUMBER; n++)
    {
        float3 H = normalize(wo + wi[n]);
        float3 diffuse = DiffuseDisney(mat.C, mat.roughness, dot(normal, wo), dot(normal, wi[n]), dot(wi[n], H));
        result += (1.0 / LIGHT_NUMBER) * diffuse;
        float3 b = max(BRDF(wi[n], wo, normal, binormal, tangent, mat), float3(0.0, 0.0, 0.0));
        b *= dot(wi[n], normal);
        b *= brightness;
        b *= pow(2.0, exposure);
        float gammaInverse = 1.0 / gamma;
        b = pow(b, float3(gammaInverse, gammaInverse, gammaInverse));
        b = clamp(b, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0));
        result = result + b;
    }
    
    return float3(clamp(result, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0)));
}

float3 BlinnPhong(float3 l, float3 v, float3 normal, float3 ambient, float3 diffuse)
{
    float3 halfVector = normalize(l + v);
    float3 _diffuse = diffuse * max(dot(normal, l), 0.0);
    float gloss = 16;
    float3 specular = float3(1.0, 1.0, 1.0) * pow(max(dot(halfVector, normal), 0.0), gloss);
    return ambient + _diffuse + specular;
}

float shadowSampler(float2 uv)
{
    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)
    {
        return 1.0;
    }
    return shadowmap.Sample(samplerShadowmap, uv).r;
}

float textureProj(float4 shadowCoord, float2 offset, float bias)
{
    float shadow = 1.0;
    if (shadowCoord.z > -1.0 && shadowCoord.z < 1.0)
    {
        float dist = shadowSampler(shadowCoord.xy + offset).r;
        if (shadowCoord.w > 0.0 && (shadowCoord.z - bias) > dist)
        {
            shadow = 0.5;
        }
    }
    return shadow;
}

float filterPCF(float4 sc, float bias)
{
    int2 texDim;
    shadowmap.GetDimensions(texDim.x, texDim.y);
    float scale = 1.5;
    float dx = scale * 1.0 / float(texDim.x);
    float dy = scale * 1.0 / float(texDim.y);

    float shadowFactor = 0.0;
    int count = 0;
    int range = 1;

    for (int x = -range; x <= range; x++)
    {
        for (int y = -range; y <= range; y++)
        {
            shadowFactor += textureProj(sc, float2(dx * x, dy * y), bias);
            count++;
        }

    }
    return shadowFactor / count;
}

float3 fresnelSchlickRoughness(float cosTheta, float3 F0, float roughness)
{
    return F0 + (max(float3(roughness, roughness, roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
}

float2 cubeMapToEquirectangular(float3 v)
{
    const float2 invAtan = float2(0.1591, 0.3183);
    float2 uv = float2(atan2(v.z, v.x), asin(v.y));
    uv *= invAtan;
    uv += 0.5;
    uv.y = 1.0 - uv.y;
    return uv;
}

float3 sphereicalSample(Texture2D sphereicalTexture, SamplerState samplerState, float3 v, int mipLevel, bool flipY)
{
    float2 uv = cubeMapToEquirectangular(v);
    if (flipY)
    {
        uv.y = 1.0 - uv.y;
    }
    return sphereicalTexture.SampleLevel(samplerState, uv, mipLevel).xyz;

}

float3 ibl_fragment_shader(float roughness, float metalness, float3 normal, float3 albedo, float3 wo)
{
    float3 f0 = lerp(float3(0.04, 0.04, 0.04), albedo, metalness);
    float3 F = fresnelSchlickRoughness(dot(wo, normal), f0, roughness);
    float3 kS = F;
    float3 kD = (1 - metalness) * (float3(1, 1, 1) - kS);
 
 //diffuse
    float3 irradiance = sphereicalSample(irrandanceMap, samplerIrrandanceMap, normal, 0, true);
    float3 diffuse = irradiance * kD * albedo;
 
    float max_mip_level = 11;
    
 //prefilter
    float3 R = reflect(wo, normal);
    int specular_miplevel = (int) (roughness * max_mip_level + 0.5f);
    float3 prefilter_color = sphereicalSample(prefilterMap, samplerPrefilterMap, R, specular_miplevel, true);
 
 //lut
    float2 temp = brdfLUT.Sample(samplerBrdfLUT, float2(dot(normal, wo), roughness)).xy;
    float A = temp.x, B = temp.y;
 
 //specular
    float3 specular = f0 * A + float3(B, B, B);
    specular = clamp(prefilter_color * specular, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0));
 
    float3 result = kD * diffuse + specular;
    return result;
}

float4 main(VSOutput input, float4 pixelPosition : SV_Position) : SV_TARGET
{
    float3 lightPositions[LIGHT_NUMBER];
    lightPositions[0] = cameraUBO.lightPosition[0].xyz;
    lightPositions[1] = cameraUBO.lightPosition[1].xyz;
    lightPositions[2] = cameraUBO.lightPosition[2].xyz;
    lightPositions[3] = cameraUBO.lightPosition[3].xyz;
    float3 wi[LIGHT_NUMBER];
    wi[0] = normalize(lightPositions[0] - input.fragmentPos.xyz);
    wi[1] = normalize(lightPositions[1] - input.fragmentPos.xyz);
    wi[2] = normalize(lightPositions[2] - input.fragmentPos.xyz);
    wi[3] = normalize(lightPositions[3] - input.fragmentPos.xyz);
    float3 wo = normalize(cameraUBO.cameraPosition.xyz - input.fragmentPos.xyz);
    float3 normal;
    
    DisneyMaterial mat = materialUBO;
    uint width;
    uint height;
    textureColor.GetDimensions(width, height);
    
    mat.metallic = materialUBO.metallic * metallicColor.Sample(samplerMetallic, input.UV).x;
    mat.C = textureColor.Sample(samplerColor, input.UV).xyz;
    //if (width == 1 && height == 1)
    //{
    //    mat.C = float3(63.0 / 255.0, 72.0 / 255.0, 204.0 / 255.0);
    //}
    normalColor.GetDimensions(width, height);
    float3 binormal;
    float3 tangent;
    if (width == 1 && height == 1)
    {
        normal = input.normal;
        binormal = input.binormal;
        tangent = input.tangent;
    }
    else
    {
        normal = normalColor.Sample(samplerNormal, input.UV).xyz;
        normal = normalize(normal * 2.0 - float3(1.0, 1.0, 1.0));
        normal = normalize(input.tangent * normal.x + input.binormal * normal.y + input.normal * normal.z);
        if (((normal.x == 1.0 && normal.y == 0.0 && normal.z == 0.0) || (normal.x == -1.0 && normal.y == 0.0 && normal.z == 0.0)))
        {
            binormal = float3(0.0, 1.0, 0.0);
            tangent = float3(0.0, 0.0, 1.0);
        }
        else
        {
            binormal = cross(normal, float3(1.0, 0.0, 0.0));
            tangent = cross(binormal, normal);
        }
    }
    roughnessColor.GetDimensions(width, height);
    if (width == 1 && height == 1)
    {
        mat.roughness = materialUBO.roughness;
    }
    else
    {
        mat.roughness = roughnessColor.Sample(samplerRoughness, input.UV).x;
    }
    metallicColor.GetDimensions(width, height);
    if (width == 1 && height == 1)
    {
        mat.metallic = materialUBO.metallic;
    }
    else
    {
        mat.metallic = metallicColor.Sample(samplerMetallic, input.UV).x;
    }

    float3 ibl = ibl_fragment_shader(mat.roughness, mat.metallic, normal, mat.C, wo);
    
    float shadow = filterPCF(input.shadowCoord / input.shadowCoord.w, 0.005);
    float3 color = materialUBO.C * (shadow * DisneyPBR(wi, wo, normal, tangent, binormal, mat) + ibl);
    
    //return float4(tangent / 2.0 + float3(0.5, 0.5, 0.5), 1.0);
    return float4(color, 1.0);
}

What exactly was wrong about this shader. So makes the final result look so wield.
And is there any example that implementing disney principles pbr correctly? Any helpful advices? Thanks very much.