question:
brdf中的几何因子考虑了微表面的自遮挡，当表面粗糙度较大或者与法线夹角越大时，这个因子越小，导致颜色越暗。这部分能量相等于直接忽略掉了，实际上被遮挡的光线会被反射，然后经过若干次反射，从另一点以另一角度重新进入视线。因此需要将缺失的能量重新补回来。
Kulla-Conty近似
Kulla-Conty近似额外添加了一个补充的brdf系数，使得总能量守恒。
引入颜色
注意Kulla-Conty实现的是：1次弹射+能量补充，而一次弹射的内容里面是已经有考虑颜色的菲涅尔项了，但是能量的补充我们始终认为是对于一个没有颜色的，F值为1的东西进行的补充【上边推导过程假设了F为1】，这对于有颜色的东西会补充过多，因为F小于1时，多次弹射时每次都会被吸收一部分。因此我们这里考虑颜色是对于补充的那一部分考虑颜色，对补充的能量进行衰减！
现在我们要把这个菲涅尔项考虑进来了，但是这里注意，这个菲涅尔的值，是和角度有关系的，如果在这里再考虑上角度，其实最后我们是很难得到一个实时的结果的。
所以这里再次采用了一种近似的方案，就是把菲涅尔选择一个各角度下的平均值，不管角度是多少都用这一个菲涅尔值。
这个平均和我们之前的E_avg
是一样的思路：
代码
离线计算E(u)
Vec3f IntegrateBRDF(Vec3f V, float roughness) {
float A = 0.0;
float B = 0.0;
float C = 0.0;
const int sample_count = 2048;
Vec3f N = Vec3f(0.0, 0.0, 1.0);
for (int i = 0; i < sample_count; i++) {
Vec2f Xi = Hammersley(i, sample_count);
Vec3f H = ImportanceSampleGGX(Xi, N, roughness);
Vec3f L = normalize(H * 2.0f * dot(V, H) - V);
float NoL = std::max(L.z, 0.0f);
float NoH = std::max(H.z, 0.0f);
float VoH = std::max(dot(V, H), 0.0f);
float NoV = std::max(dot(N, V), 0.0f);
// TODO: To calculate (fr * ni) / p_o here - Bonus 1
float g = GeometrySmith(roughness, NoV, NoL);
float w = VoH * g / (NoV*NoH);
A += w;
B += w;
C += w;
// Split Sum - Bonus 2
}
//return { 1.0f - A / sample_count,1.0f - B / sample_count, 1.0f - C / sample_count };
return { A / static_cast<float>(sample_count), B / static_cast<float>(sample_count), C / static_cast<float>(sample_count) };
//return Vec3f(1.0f);
}
结果：
离线计算E_avg:
Vec3f IntegrateEmu(Vec3f V, float roughness, float NdotV, Vec3f Ei) {
Vec3f Eavg = Vec3f(0.0f);
const int sample_count = 1024;
Vec3f N = Vec3f(0.0, 0.0, 1.0);
/*
for (int i = 0; i < sample_count; i++)
{
Vec2f Xi = Hammersley(i, sample_count);
Vec3f H = ImportanceSampleGGX(Xi, N, roughness);
Vec3f L = normalize(H * 2.0f * dot(V, H) - V);
float NoL = std::max(L.z, 0.0f);
float NoH = std::max(H.z, 0.0f);
float VoH = std::max(dot(V, H), 0.0f);
float NoV = std::max(dot(N, V), 0.0f);
// TODO: To calculate Eavg here - Bonus 1
}
*/
return Ei * NdotV * 2;
//NdotV = 1.0f - NdotV;
//return Ei * sqrt(1 - NdotV * NdotV) * 2;
//return Vec3f(1.0);
}
int main() {
unsigned char *Edata = stbi_load("./GGX_E_LUT.png", &resolution, &resolution, &channel, 3);
if (Edata == NULL)
{
std::cout << "ERROE_FILE_NOT_LOAD" << std::endl;
return -1;
}
else
{
std::cout << resolution << " " << resolution << " " << channel << std::endl;
// | -----> mu(j)
// |
// | rough（i）
// Flip it, if you want the data written to the texture
uint8_t data[128 * 128 * 3];
float step = 1.0 / resolution;
Vec3f Eavg = Vec3f(0.0);
for (int i = 0; i < resolution; i++)
{
float roughness = step * (static_cast<float>(i) + 0.5f);
for (int j = 0; j < resolution; j++)
{
float NdotV = step * (static_cast<float>(j) + 0.5f);
Vec3f V = Vec3f(std::sqrt(1.f - NdotV * NdotV), 0.f, NdotV);
//resolution - 1 - i
//这里非常隐晦，与产生图像是顺序相反
//产生图像时，theta从2/Pi到0
//这里theta从0到2/Pi进行访问
//这里的NdotV范围从0到1均匀采样，相当于sin(theta)
Vec3f Ei = getEmu((resolution - 1 - i), j, 0, Edata, NdotV, roughness);
Eavg += IntegrateEmu(V, roughness, NdotV, Ei) * step;
setRGB(i, j, 0.0, data);
}
for(int k = 0; k < resolution; k++)
{
setRGB(i, k, Eavg, data);
}
Eavg = Vec3f(0.0);
}
stbi_flip_vertically_on_write(true);
stbi_write_png("GGX_Eavg_LUT.png", resolution, resolution, channel, data, 0);
}
stbi_image_free(Edata);
return 0;
}
结果：
运行时，KullaContyFragment.glsl:
#ifdef GL_ES
precision mediump float;
#endif
uniform vec3 uLightPos;
uniform vec3 uCameraPos;
uniform vec3 uLightRadiance;
uniform vec3 uLightDir;
uniform sampler2D uAlbedoMap;
uniform float uMetallic;
uniform float uRoughness;
uniform sampler2D uBRDFLut;
uniform sampler2D uEavgLut;
uniform samplerCube uCubeTexture;
varying highp vec2 vTextureCoord;
varying highp vec3 vFragPos;
varying highp vec3 vNormal;
const float PI = 3.14159265359;
float DistributionGGX(vec3 N, vec3 H, float roughness)
{
// TODO: To calculate GGX NDF here
float a = roughness*roughness;
float a2 = a*a;
float NdotH = max(dot(N, H), 0.0);
float NdotH2 = NdotH*NdotH;
float nom = a2;
float denom = (NdotH2 * (a2 - 1.0) + 1.0);
denom = PI * denom * denom;
return nom / max(denom, 0.0001);
}
float GeometrySchlickGGX(float NdotV, float roughness)
{
// TODO: To calculate Schlick G1 here
float a = roughness;
//float k = (a +1.0)*(a+1.0) / 8.0;
float k = (a * a) / 2.0;//用这个才能得到assignment4.pdf中的效果图
float nom = NdotV;
float denom = NdotV * (1.0 - k) + k;
return nom / denom;
}
float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
{
// TODO: To calculate Smith G here
return GeometrySchlickGGX(max(dot(N,V),0.0),roughness)*GeometrySchlickGGX(max(dot(N,L),0.0),roughness);
}
vec3 fresnelSchlick(vec3 F0, vec3 V, vec3 H)
{
// TODO: To calculate Schlick F here
float HoV = max(dot(V,H), 0.0);
vec3 f = F0 + (vec3(1.0) - F0) * pow((1.0 - HoV), 5.0);
// TODO: To calculate Schlick F here
return f;
}
//https://blog.selfshadow.com/publications/s2017-shading-course/imageworks/s2017_pbs_imageworks_slides_v2.pdf
vec3 AverageFresnel(vec3 r, vec3 g)
{
return vec3(0.087237) + 0.0230685*g - 0.0864902*g*g + 0.0774594*g*g*g
+ 0.782654*r - 0.136432*r*r + 0.278708*r*r*r
+ 0.19744*g*r + 0.0360605*g*g*r - 0.2586*g*r*r;
}
vec3 MultiScatterBRDF(float NdotL, float NdotV)
{
vec3 albedo = pow(texture2D(uAlbedoMap, vTextureCoord).rgb, vec3(2.2));
vec3 E_o = texture2D(uBRDFLut, vec2(NdotL, uRoughness)).xyz;
vec3 E_i = texture2D(uBRDFLut, vec2(NdotV, uRoughness)).xyz;
vec3 E_avg = texture2D(uEavgLut, vec2(0, uRoughness)).xyz;
// copper
vec3 edgetint = vec3(0.827, 0.792, 0.678);
vec3 F_avg = AverageFresnel(albedo, edgetint);
// TODO: To calculate fms and missing energy here
float fms = (1.0-E_o.x)*(1.0-E_i.x)/(PI*(1.0-E_avg.x));
vec3 fadd = F_avg*E_avg/(vec3(1.0)-F_avg*(vec3(1.0)-E_avg));
return vec3(fms)*fadd;
}
void main(void) {
vec3 albedo = pow(texture2D(uAlbedoMap, vTextureCoord).rgb, vec3(2.2));
vec3 N = normalize(vNormal);
vec3 V = normalize(uCameraPos - vFragPos);
float NdotV = max(dot(N, V), 0.0);
vec3 F0 = vec3(0.04);
F0 = mix(F0, albedo, uMetallic);
vec3 Lo = vec3(0.0);
// calculate per-light radiance
vec3 L = normalize(uLightDir);
vec3 H = normalize(V + L);
float distance = length(uLightPos - vFragPos);
float attenuation = 1.0 / (distance * distance);
vec3 radiance = uLightRadiance;
float NDF = DistributionGGX(N, H, uRoughness);
float G = GeometrySmith(N, V, L, uRoughness);
vec3 F = fresnelSchlick(F0, V, H);
vec3 numerator = NDF * G * F;
float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0);
vec3 Fmicro = numerator / max(denominator, 0.001);
float NdotL = max(dot(N, L), 0.0);
vec3 Fms = MultiScatterBRDF(NdotL, NdotV);
vec3 BRDF = Fmicro + Fms;
Lo += BRDF * radiance * NdotL;
vec3 color = Lo;
color = color / (color + vec3(1.0));
color = pow(color, vec3(1.0/2.2));
gl_FragColor = vec4(color, 1.0);
}
结果：
上一排是使用了Kulla-Cony BRDF，下一排使用了没有添加补充的BRDF，可以看到在低粗糙度时，使用了Kulla-Cony BRDF的要更亮一些。
标签：Vec3f,NdotV,1.0,0.0,BRDF,float,Kulla,vec3,Conty From： https://www.cnblogs.com/bluebean/p/17981150