Bentuk yang benar dari istilah geometri GGX

Saya mencoba menerapkan mikrofacet BRDF dalam raytracer saya tetapi saya mengalami beberapa masalah. Banyak makalah dan artikel yang saya baca mendefinisikan istilah geometri parsial sebagai fungsi tampilan dan setengah vektor: G1 (v, h). Namun, ketika menerapkan ini saya mendapat hasil sebagai berikut:

(Baris bawah adalah dielektrik dengan kekasaran 1.0 - 0.0, Baris atas adalah logam dengan kekasaran 1.0 - 0.0)

Ada highlight aneh di sekitar tepi dan cut-off di sekitar nl == 0. Saya benar-benar tidak tahu dari mana ini berasal. Saya menggunakan Unity sebagai referensi untuk memeriksa render saya, jadi saya memeriksa sumber shader mereka untuk melihat apa yang mereka gunakan dan dari apa yang saya tahu istilah geometri mereka tidak ditentukan oleh setengah vektor sama sekali! Jadi saya mencoba kode yang sama tetapi digunakan untuk permukaan makro normal, bukan setengah vektor dan mendapat hasil sebagai berikut:

Bagi mata saya yang tidak terlatih ini tampaknya jauh lebih dekat dengan hasil yang diinginkan. Tetapi saya merasa ini tidak benar? Mayoritas artikel yang saya baca menggunakan setengah vektor tetapi tidak semuanya. Apakah ada alasan untuk perbedaan ini?

Saya menggunakan kode berikut sebagai istilah geometri saya:

float RayTracer::GeometryGGX(const Vector3& v, const Vector3& l, const Vector3& n, const Vector3& h, float a)
{
    return G1GGX(v, h, a) * G1GGX(l, h, a);
}

float RayTracer::G1GGX(const Vector3& v, const Vector3& h, float a)
{
    float NoV = Util::Clamp01(cml::dot(v, h));
    float a2 = a * a;

    return (2.0f * NoV) / std::max(NoV + sqrt(a2 + (1.0f - a2) * NoV * NoV), 1e-7f);
}

Dan untuk referensi, ini adalah fungsi distribusi normal saya:

float RayTracer::DistributionGGX(const Vector3& n, const Vector3& h, float alpha)
{
    float alpha2 = alpha * alpha;
    float NoH = Util::Clamp01(cml::dot(n, h));
    float denom = (NoH * NoH * (alpha2 - 1.0f)) + 1.0f;
    return alpha2 / std::max((float)PI * denom * denom, 1e-7f);
}

TL; DR: Formula Anda salah.$G1$

Untuk menghindari kebingungan, saya mengasumsikan versi isotropik dari BRDF, model microfacet Smith (sebagai lawan dari model V-cavity), dan distribusi mikrofacet GGX.

Menurut Heitz 2014 , istilah masking / shadowing adalah$G1$

dan menurut Walter 2007 , rumusnya adalah

Di mana adalah arah normal mikrofacet (vektor setengah jalan), adalah arah normal utama (geometris) (normal), adalah arah masuk atau keluar, adalah isotropik parameter kekasaran, dan adalah fungsi karakteristik positif, atau fungsi langkah Heaviside (sama dengan satu jika dan nol sebaliknya).$\omega_{m}$$\omega_{g}$$\omega_{v}$$\alpha$$\chi^{+}\left(a\right)$$a>0$

Seperti yang Anda perhatikan, setengah vektor hanya digunakan untuk memastikan nol jika konfigurasi geometri dilarang. Lebih tepatnya, itu memastikan bahwa permukaan belakang tidak pernah terlihat dari arah di sisi depan dari makrosurface dan sebaliknya (kasus terakhir hanya berarti ketika juga refraksi didukung). Jika kode panggilan menjamin ini, maka Anda jelas dapat menghilangkan parameter ini. Mungkin itulah alasan mengapa mereka melakukannya di Unity.$\omega_{m}$$G1$$\omega_{v}$

Implementasi Anda, di sisi lain, menggunakan setengah vektor untuk menghitung kosinus dari arah sehubungan dengan mikrofaset, yang mengarah ke perhitungan sesuatu yang lain daripada formula yang disajikan.$\omega_{v}$

Jika ini bisa membantu, maka ini adalah implementasi saya dari faktor :$G1$

float SmithMaskingFunctionGgx(
    const Vec3f &aDir,  // the direction to compute masking for (either incoming or outgoing)
    const Vec3f &aMicrofacetNormal,
    const float  aRoughnessAlpha)
{
    PG3_ASSERT_VEC3F_NORMALIZED(aDir);
    PG3_ASSERT_VEC3F_NORMALIZED(aMicrofacetNormal);
    PG3_ASSERT_FLOAT_NONNEGATIVE(aRoughnessAlpha);

    if (aMicrofacetNormal.z <= 0)
        return 0.0f;

    const float cosThetaVM = Dot(aDir, aMicrofacetNormal);
    if ((aDir.z * cosThetaVM) < 0.0f)
        return 0.0f; // up direction is below microfacet or vice versa

    const float roughnessAlphaSqr = aRoughnessAlpha * aRoughnessAlpha;
    const float tanThetaSqr = Geom::TanThetaSqr(aDir);
    const float root = std::sqrt(1.0f + roughnessAlphaSqr * tanThetaSqr);

    const float result = 2.0f / (1.0f + root);

    PG3_ASSERT_FLOAT_IN_RANGE(result, 0.0f, 1.0f);

    return result;
}