games101 作业3分析 详解bump mapping
代码分析
整体代码结构 其实变化还是不大 主要是引入了vertexshader（什么都没做） 与 fragmentshader（使用了不同的着色方法 直接用法线作为rgb 使用blingphong光照模型 纹理贴图 bumpmapping displacementmapping）
主要变化在光栅化部分 着色计算使用特定的fragmentshader
这里我之前写的代码有问题 boundingbox没有覆盖边界 导致第一次出来的牛牛不同的三角形之间有缝隙hhh
注意这里使用的w值不再是之前错误的1 而是真实深度 但是我感觉这里插值使用的公式还是没有矫正过的 不过整体影响不大
void rst::rasterizer::rasterize_triangle(const Triangle& t, const std::array<Eigen::Vector3f, 3>& view_pos)
{
//这里不要使用toVector4 会导致深度值直接赋值为1
auto v = t.v;
int XMin = std::min(std::min(v[0].x(), v[1].x()), v[2].x());
int XMax = std::max(std::max(v[0].x(), v[1].x()), v[2].x());
int YMin = std::min(std::min(v[0].y(), v[1].y()), v[2].y());
int YMax = std::max(std::max(v[0].y(), v[1].y()), v[2].y());
for (int x = XMin; x <= XMax; x++) {
for (int y = YMin; y <= YMax; y++) {
int index = get_index(x, y);
if (insideTriangle(x + 0.5, y + 0.5, t.v)) {
auto [alpha, beta, gamma] = computeBarycentric2D(x + 0.5, y + 0.5, t.v);
float Z = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
float zp = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
zp *= Z;
if (zp < depth_buf[index]) {
depth_buf[index] = zp;
auto interpolated_color = interpolate(alpha, beta, gamma, t.color[0], t.color[1], t.color[2], 1.0f);
auto interpolated_normal = interpolate(alpha, beta, gamma, t.normal[0], t.normal[1], t.normal[2], 1.0f);
auto interpolated_texcoords = interpolate(alpha, beta, gamma, t.tex_coords[0], t.tex_coords[1], t.tex_coords[2], 1.0f);
auto interpolated_shadingcoords = interpolate(alpha, beta, gamma, view_pos[0], view_pos[1], view_pos[2], 1.0f);
//frame_buf[index] = t.getColor();
fragment_shader_payload FragShader(interpolated_color, interpolated_normal.normalized(), interpolated_texcoords, texture ? &*texture : nullptr);
FragShader.view_pos = interpolated_shadingcoords;
auto pixel_color = fragment_shader(FragShader);
Vector2i point;
point << x, y;
set_pixel(point, pixel_color);
}
}
}
}
下面draw函数中还是有一些细节
比如透视除法 w分量保留了z值
用view_Pos来存储真实的世界坐标 因为光照计算必须是在三维空间中计算的 所以这里要存储
法线矫正 防止model矩阵中物体进行了非等比缩放
void rst::rasterizer::draw(std::vector<Triangle *> &TriangleList) {
float f1 = (50 - 0.1) / 2.0;
float f2 = (50 + 0.1) / 2.0;
Eigen::Matrix4f mvp = projection * view * model;
for (const auto& t:TriangleList)
{
Triangle newtri = *t;
//使用三维空间中的坐标获取着色点坐标
std::array<Eigen::Vector4f, 3> mm {
(view * model * t->v[0]),
(view * model * t->v[1]),
(view * model * t->v[2])
};
std::array<Eigen::Vector3f, 3> viewspace_pos;
std::transform(mm.begin(), mm.end(), viewspace_pos.begin(), [](auto& v) {
return v.template head<3>();
});
Eigen::Vector4f v[] = {
mvp * t->v[0],
mvp * t->v[1],
mvp * t->v[2]
};
//Homogeneous division
for (auto& vec : v) {
vec.x()/=vec.w();
vec.y()/=vec.w();
vec.z()/=vec.w();
}
//法线校正
Eigen::Matrix4f inv_trans = (view * model).inverse().transpose();
Eigen::Vector4f n[] = {
inv_trans * to_vec4(t->normal[0], 0.0f),
inv_trans * to_vec4(t->normal[1], 0.0f),
inv_trans * to_vec4(t->normal[2], 0.0f)
};
//Viewport transformation
for (auto & vert : v)
{
vert.x() = 0.5*width*(vert.x()+1.0);
vert.y() = 0.5*height*(vert.y()+1.0);
vert.z() = vert.z() * f1 + f2;
}
for (int i = 0; i < 3; ++i)
{
//screen space coordinates
newtri.setVertex(i, v[i]);
}
for (int i = 0; i < 3; ++i)
{
//view space normal
newtri.setNormal(i, n[i].head<3>());
}
newtri.setColor(0, 148,121.0,92.0);
newtri.setColor(1, 148,121.0,92.0);
newtri.setColor(2, 148,121.0,92.0);
// Also pass view space vertice position
rasterize_triangle(newtri, viewspace_pos);
}
}
理论分析
bling-phong模型 与 纹理映射的理论都比较简单 这里不再赘述
有关纹理寻址 与 纹理过大/过小的问题 大概会再写一篇 参考一下别的资料
重点分析一下 bumpmapping的理论
其实normal mapping 和bumpmapping 很像 Bump Mapping 使用高度图来扰动法线 Normal Mapping 使用法线贴图来直接定义表面法线 理论上normal mapping 能够实现更好的细节 这两者都是为了使用更少的三角形 来实现更多的细节：
不使用bump mapping
使用bump mapping
首先 可以参考一下learnopengl的资料：https://learnopengl-cn.github.io/05 Advanced Lighting/04 Normal Mapping/
简单总结一下： 为什么我们要使用切线空间来存储法线？
如果直接存储物体的法线信息 那么物体只要发生变化 我们的法线贴图就没办法使用了 但是在切线空间下存储 我们只要每次求出一个TBN矩阵 然后进行变换就可以将切线空间的法线转换到世界空间 然后计算光照了
关于TBN矩阵就是对应着切线空间的三个基向量 在世界空间中的坐标 这样进行空间转换
推导方面 需要求出切线 以及副切线 可以看看learnopengl中的推导 本次作业中切线的求解我没看太懂 感觉是做了个近似？
得到了TBN矩阵 如何使用：
我们直接使用TBN矩阵，这个矩阵可以把切线坐标空间的向量转换到世界坐标空间。因此我们把它传给片段着色器中，把通过采样得到的法线坐标左乘上TBN矩阵，转换到世界坐标空间中，这样所有法线和其他光照变量就在同一个坐标系中了。
这也是本次课程中的做法
现在唯一的问题就是我们如何求出这个法线坐标
而games101课程中介绍的就是我们如何求经过bump mapping得到的法线坐标
即经过高度图来扰动点的位置之后 利用偏导数来近似切线 进一步得到法线：
但其实这样也是一个近似的结果
pbr中的推导是这样的：
上述是点的位置发生了变化 d(u,v)代表着高度变化 n(u,v)是表面法线 本来应该是个标量 但是作业中用的是rgb形式的 所以要求它的范数
我们对上述求偏导实际的近似结果应该是：
作业中相当只使用了uv坐标的变化来近似 也是因为我们信息有限嘛
这里我们求得的其实是shading normal 而我们之前用的tbn中的n是surface normal 着色是计算我们要用高度扰动之后的位置以及法线（shading normal） 而高度扰动之后的位置计算 我们要使用surface normal来计算 这点很重要 我看到有些网上的答案计算是错误的
实际解决
注意所有的方向向量 都要归一化！
Eigen::Vector3f texture_fragment_shader(const fragment_shader_payload& payload)
{
Eigen::Vector3f return_color = {0, 0, 0};
if (payload.texture)
{
// TODO: Get the texture value at the texture coordinates of the current fragment
return_color = payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y());
}
Eigen::Vector3f texture_color;
texture_color << return_color.x(), return_color.y(), return_color.z();
Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
Eigen::Vector3f kd = texture_color / 255.f;
Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
auto l1 = light{{20, 20, 20}, {500, 500, 500}};
auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
std::vector<light> lights = {l1, l2};
Eigen::Vector3f amb_light_intensity{10, 10, 10};
Eigen::Vector3f eye_pos{0, 0, 10};
float p = 150;
Eigen::Vector3f color = texture_color;
Eigen::Vector3f point = payload.view_pos;
Eigen::Vector3f normal = payload.normal;
Eigen::Vector3f result_color = {0, 0, 0};
for (auto& light : lights)
{
Eigen::Vector3f ambient_color = ka.cwiseProduct(amb_light_intensity);
double distance = (light.position - point).norm();
Eigen::Vector3f light_dir = (light.position - point).normalized();
Eigen::Vector3f diffuse_color = kd.cwiseProduct(light.intensity) / (distance * distance) * std::max(normal.normalized().dot(light_dir), 0.0f);
Eigen::Vector3f half_vector = (light_dir + (eye_pos - point).normalized()).normalized();
Eigen::Vector3f specular_color = ks.cwiseProduct(light.intensity) / (distance * distance) * std::pow(std::max(normal.normalized().dot(half_vector), 0.0f), p);
result_color += (ambient_color + diffuse_color + specular_color);
}
return result_color * 255.f;
}
Eigen::Vector3f phong_fragment_shader(const fragment_shader_payload& payload)
{
Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
Eigen::Vector3f kd = payload.color;
Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
auto l1 = light{{20, 20, 20}, {500, 500, 500}};
auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
std::vector<light> lights = {l1, l2};
Eigen::Vector3f amb_light_intensity{10, 10, 10};
Eigen::Vector3f eye_pos{0, 0, 10};
float p = 150;
Eigen::Vector3f color = payload.color;
Eigen::Vector3f point = payload.view_pos;
Eigen::Vector3f normal = payload.normal;
Eigen::Vector3f result_color = {0, 0, 0};
for (auto& light : lights)
{
Eigen::Vector3f ambient_color = ka.cwiseProduct(amb_light_intensity);
double distance = (light.position - point).norm();
Eigen::Vector3f light_dir = (light.position - point).normalized();
Eigen::Vector3f diffuse_color = kd.cwiseProduct(light.intensity) / (distance * distance) * std::max(normal.normalized().dot(light_dir),0.0f);
Eigen::Vector3f half_vector = (light_dir + (eye_pos - point).normalized()).normalized();
Eigen::Vector3f specular_color = ks.cwiseProduct(light.intensity) / (distance * distance) * std::pow(std::max(normal.normalized().dot(half_vector),0.0f), p);
result_color += (ambient_color + diffuse_color + specular_color);
}
return (result_color) * 255.f;
}
//
Eigen::Vector3f displacement_fragment_shader(const fragment_shader_payload& payload)
{
Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
Eigen::Vector3f kd = payload.color;
Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
auto l1 = light{{20, 20, 20}, {500, 500, 500}};
auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
std::vector<light> lights = {l1, l2};
Eigen::Vector3f amb_light_intensity{10, 10, 10};
Eigen::Vector3f eye_pos{0, 0, 10};
float p = 150;
Eigen::Vector3f color = payload.color;
Eigen::Vector3f point = payload.view_pos;
Eigen::Vector3f normal = payload.normal;
float kh = 0.2, kn = 0.1;
Eigen::Vector3f tagent;
tagent << normal.x() * normal.y() / std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2)),
std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2)),
normal.z()* normal.y() / std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2));
Eigen::Vector3f bitangent = normal.cross(tagent);
Eigen::Matrix3f TBN;
TBN.col(0) = tagent.normalized();
TBN.col(1) = bitangent.normalized();
TBN.col(2) = normal.normalized();
float width = 1.0f / payload.texture->width;
float height = 1.0f / payload.texture->height;
float dU = kh * kn * (payload.texture->getColor(payload.tex_coords.x() + width, payload.tex_coords.y()).norm() -
payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y()).norm());
float dV = kh * kn * (payload.texture->getColor(payload.tex_coords.x() + width, payload.tex_coords.y() + height).norm() -
payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y()).norm());
//计算扰动之后的位置
point += kn * normal * payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y()).norm();
Eigen::Vector3f ln;
ln << -dU, -dV, 1;
Eigen::Vector3f shading_normal = (TBN * ln).normalized();
Eigen::Vector3f result_color = {0, 0, 0};
for (auto& light : lights)
{
Eigen::Vector3f ambient_color = ka.cwiseProduct(amb_light_intensity);
double distance = (light.position - point).norm();
Eigen::Vector3f light_dir = (light.position - point).normalized();
Eigen::Vector3f diffuse_color = kd.cwiseProduct(light.intensity) / (distance * distance) * std::max(shading_normal.normalized().dot(light_dir), 0.0f);
Eigen::Vector3f half_vector = (light_dir + (eye_pos - point).normalized()).normalized();
Eigen::Vector3f specular_color = ks.cwiseProduct(light.intensity) / (distance * distance) * std::pow(std::max(shading_normal.normalized().dot(half_vector), 0.0f), p);
result_color += (ambient_color + diffuse_color + specular_color);
}
return result_color * 255.f;
}
Eigen::Vector3f bump_fragment_shader(const fragment_shader_payload& payload)
{
Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
Eigen::Vector3f kd = payload.color;
Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
auto l1 = light{{20, 20, 20}, {500, 500, 500}};
auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
std::vector<light> lights = {l1, l2};
Eigen::Vector3f amb_light_intensity{10, 10, 10};
Eigen::Vector3f eye_pos{0, 0, 10};
float p = 150;
Eigen::Vector3f color = payload.color;
Eigen::Vector3f point = payload.view_pos;
Eigen::Vector3f normal = payload.normal;
float kh = 0.2, kn = 0.1;
Eigen::Vector3f tagent;
tagent << normal.x() * normal.y() / std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2)),
std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2)),
normal.z()* normal.y() / std::sqrt(std::pow(normal.x(), 2) + std::pow(normal.z(), 2));
Eigen::Vector3f bitangent = normal.cross(tagent);
Eigen::Matrix3f TBN;
TBN.col(0) = tagent.normalized();
TBN.col(1) = bitangent.normalized();
TBN.col(2) = normal.normalized();
float width = 1.0f / payload.texture->width;
float height = 1.0f / payload.texture->height;
float dU = kh * kn * (payload.texture->getColor(payload.tex_coords.x() + width, payload.tex_coords.y()).norm() -
payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y()).norm());
float dV = kh * kn * (payload.texture->getColor(payload.tex_coords.x() + width, payload.tex_coords.y() + height).norm() -
payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y()).norm());
Eigen::Vector3f ln;
ln << -dU, -dV, 1;
normal = (TBN * ln).normalized();
Eigen::Vector3f result_color = {0, 0, 0};
result_color = normal;
return result_color * 255.f;
}