games101 作业三

已于 2022-05-31 01:13:32 修改
阅读量263 收藏
点赞数
分类专栏： games101作业 文章标签： c++ games101
于 2022-05-31 01:02:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czw0723/article/details/125057036
版权

注意下面几张PPT：（bump mapping和displacement mapping都是按照注释来弄的，我也没整明白）

Blinn-phong模型：

重心坐标插值：

bump mapping：

displacement mapping：

rasterize_triangle：

static bool mySymbol(float x){
    return x > 0;
}

static bool insideTriangle(int x, int y, const Vector3f* _v)
{   
    auto A = _v[0];
    auto B = _v[1];
    auto C = _v[2];
    auto P = Vector2f(x,y);

    auto PA = Vector2f(A[0]-P[0],A[1]-P[1]);
    auto PB = Vector2f(B[0]-P[0],B[1]-P[1]);
    auto PC = Vector2f(C[0]-P[0],C[1]-P[1]);
    
    auto PA_PB = PA[0]*PB[1]-PA[1]*PB[0];
    auto PB_PC = PB[0]*PC[1]-PB[1]*PC[0];
    auto PC_PA = PC[0]*PA[1]-PC[1]*PA[0];

    return mySymbol(PA_PB) == mySymbol(PB_PC) == mySymbol(PC_PA);
    
}

//Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle& t, const std::array<Eigen::Vector3f, 3>& view_pos) 
{
    auto v = t.toVector4();
    
    // 找bounding box
    int left=INT32_MAX,right=INT32_MIN,top=INT32_MIN,buttom=INT32_MAX;

    for (int i = 0; i < 3; i++)
    {
        float x = t.v[i][0];
        float y = t.v[i][1];
        
        left = left > floor(x) ? floor(x):left;
        right = right < ceil(x) ? ceil(x):right;

        buttom = buttom > floor(y) ? floor(y):buttom;
        top = top < ceil(y) ? ceil(y):top;
        
    }
    
    for (int x = left; x <= right; x++)
    {
        for (int y = buttom; y <= top; y++)
        {
            bool isInside = insideTriangle(x+0.5,y+0.5,t.v);
            if(isInside){
                auto[alpha, beta, gamma] = computeBarycentric2D(x, y, 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;

                bool shouldBePainted = depth_buf[get_index(x,y) ] >  zp;
                if(shouldBePainted){
                    // 更新 z_buffer
                    depth_buf[get_index(x,y) ] =  zp;
                    
                    // 插值
                    auto interpolated_color = interpolate(alpha,beta,gamma,t.color[0],t.color[1],t.color[2],1);
                    auto interpolated_normal = interpolate(alpha,beta,gamma,t.normal[0],t.normal[1],t.normal[2],1).normalized();
                    auto interpolated_texcoords = interpolate(alpha,beta,gamma,t.tex_coords[0],t.tex_coords[1],t.tex_coords[2],1);
                    auto interpolated_shadingcoords = interpolate(alpha,beta,gamma, view_pos[0], view_pos[1], view_pos[2], 1);

                    fragment_shader_payload payload( interpolated_color, interpolated_normal.normalized(), interpolated_texcoords, texture ? &*texture : nullptr);
                    
                    payload.view_pos = interpolated_shadingcoords;
   
                    auto pixel_color = fragment_shader(payload);

                    set_pixel(Eigen::Vector2i(x, y), pixel_color);
                }
                
            }
        }
        
    }
 
}

get_projection_matrix：

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio, float zNear, float zFar)
{
    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

    float n = zNear;
	float f = zFar;
    
    eye_fov = eye_fov * MY_PI / 180.0;
	float t = tan(eye_fov/2) * -abs(n);
    float b = -t;

	float r = aspect_ratio * t;
    float l = -r;

    Eigen::Matrix4f M_ortho_1,M_ortho_2,M_ortho;
	M_ortho_2 << 	2/(r-l), 0.0, 0.0, 0.0,
					0.0, 2/(t-b), 0.0, 0.0,
					0.0, 0.0, 2/(n-f), 0.0,
					0.0, 0.0, 0.0, 		1.0;

	M_ortho_1 << 	1.0, 0.0, 0.0, -(r+l)/2,
					0.0, 1.0, 0.0, -(t+b)/2,
					0.0, 0.0, 1.0, -(n+f)/2,
					0.0, 0.0, 0.0, 1.0;
	M_ortho = M_ortho_2 * M_ortho_1;

	Eigen::Matrix4f M_persp_ortho;
	M_persp_ortho << n, 0.0, 0.0, 0.0,
					0.0, n, 0.0, 0.0,
					0.0, 0.0, n+f, -n*f,
					0.0, 0.0, 1.0, 0.0;
	M_ortho = M_ortho_2 * M_ortho_1;

    projection = M_ortho * M_persp_ortho * projection;

    return projection;

}

phong_fragment_shader：

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 light_dir = light.position - point;
        Eigen::Vector3f view_dir = eye_pos - point;
		// 衰减因子
		float r2 = light_dir.dot(light_dir);

        auto ambient = ka.cwiseProduct(amb_light_intensity);
        auto diffuse = kd.cwiseProduct((light.intensity / r2) * max(0.0f,normal.normalized().dot(light_dir.normalized())));

        Eigen::Vector3f h = (light_dir + view_dir).normalized();
        auto specular = ks.cwiseProduct(light.intensity / r2 * pow(max(0.0f,normal.normalized().dot(h)),p));
        
        result_color += ambient + diffuse + specular;
    }

    return result_color * 255.f;
}

displacement_fragment_shader：

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;
    
    // TODO: Implement displacement mapping here
    // Let n = normal = (x, y, z)
    // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    // Vector b = n cross product t
    // Matrix TBN = [t b n]
    // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    // Vector ln = (-dU, -dV, 1)
    // Position p = p + kn * n * h(u,v)
    // Normal n = normalize(TBN * ln)


	float x = normal.x();
	float y = normal.y();
	float z = normal.z();
	Eigen::Vector3f t{ x*y / std::sqrt(x*x + z * z), std::sqrt(x*x + z * z), z*y / std::sqrt(x*x + z * z) };
	Eigen::Vector3f b = normal.cross(t);
	Eigen::Matrix3f TBN;
	TBN << t.x(), b.x(), normal.x(),
		t.y(), b.y(), normal.y(),
		t.z(), b.z(), normal.z();

	float u = payload.tex_coords.x();
	float v = payload.tex_coords.y();
	float w = payload.texture->width;
	float h = payload.texture->height;


	float dU = kh * kn * (payload.texture->getColor(u + 1.0f / w, v).norm() - payload.texture->getColor(u , v).norm());
	float dV = kh * kn * (payload.texture->getColor(u, v + 1.0f / h).norm() - payload.texture->getColor(u , v).norm());

	Eigen::Vector3f ln{ -dU,-dV,1.0f };

    point += (kn * normal * payload.texture->getColor(u , v).norm());
	normal = TBN * ln;
    normal = normal.normalized();


    Eigen::Vector3f result_color = {0, 0, 0};

    for (auto& light : lights)
    {
        // TODO: For each light source in the code, calculate what the *ambient*, *diffuse*, and *specular* 
        // components are. Then, accumulate that result on the *result_color* object.

        Eigen::Vector3f light_dir = light.position - point;
        Eigen::Vector3f view_dir = eye_pos - point;
		// 衰减因子
		float r2 = light_dir.dot(light_dir);

        auto ambient = ka.cwiseProduct(amb_light_intensity);
        auto diffuse = kd.cwiseProduct((light.intensity / r2) * max(0.0f,normal.normalized().dot(light_dir.normalized())));

        Eigen::Vector3f h = (light_dir + view_dir).normalized();
        auto specular = ks.cwiseProduct(light.intensity / r2 * pow(max(0.0f,normal.normalized().dot(h)),p));
        
        result_color += ambient + diffuse + specular;
    }

    return result_color * 255.f;
}

bump_fragment_shader：

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;

    // TODO: Implement bump mapping here
    // Let n = normal = (x, y, z)
    // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    // Vector b = n cross product t
    // Matrix TBN = [t b n]
    // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    // Vector ln = (-dU, -dV, 1)
    // Normal n = normalize(TBN * ln)

    float x = normal.x();
	float y = normal.y();
	float z = normal.z();
	Eigen::Vector3f t{ x * y / std::sqrt(x * x + z * z), std::sqrt(x * x + z * z), z*y / std::sqrt(x * x + z * z) };
	Eigen::Vector3f b = normal.cross(t);
	Eigen::Matrix3f TBN;
	TBN << t.x(), b.x(), normal.x(),
		t.y(), b.y(), normal.y(),
		t.z(), b.z(), normal.z();

	float u = payload.tex_coords.x();
	float v = payload.tex_coords.y();
	float w = payload.texture->width;
	float h = payload.texture->height;

	float dU = kh * kn * (payload.texture->getColor(u + 1.0f / w , v).norm() - payload.texture->getColor(u, v).norm());
	float dV = kh * kn * (payload.texture->getColor(u, v + 1.0f / h).norm() - payload.texture->getColor(u, v).norm());

	Eigen::Vector3f ln{ -dU,-dV,1.0f };

	normal = TBN * ln;
	// 归一化
	Eigen::Vector3f result_color = normal.normalized();
    return result_color * 255.f;
}

czw0723
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GAMES101:作业3
qq_41765657的博客
12-05 8116
GAMES101:作业3 照旧把这段代码粘贴过来： Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio, float zNear, float zFar) { float n = zNear; float f = zFar; Eigen::Matrix4f projection = Eigen::Matrix4f::Identity(); float t = -tan((eye_fov
【GAMES101 作业3】渲染小奶牛+使用.obj模型+双线性插值+踩坑总结
onion23的博客
08-21 1707
作业3的基础题+提高部分全解析
GAMES101-现代计算机图形学学习笔记（作业03）
06-28
在这次编程任务中，我们会进一步模拟现代图形技术。我们在代码中添加了 Object Loader(用于加载三维模型), Vertex Shader 与 Fragment Shader，并且支持 了纹理映射。 而在本次实验中，你需要完成的任务是: 1. 修改函数 rasterize_triangle(const Triangle& t) in rasterizer.cpp: 在此 处实现与作业 2 类似的插值算法，实现法向量、颜色、纹理颜色的插值。 2. 修改函数 get_projection_matrix() in main.cpp: 将你自己在之前的实验中 实现的投影矩阵填到此处，此时你可以运行 ./Rasterizer output.png normal 来观察法向量实现结果。 3. 修改函数 phong_fragment_shader() in main.cpp: 实现 Blinn-Phong 模型计 算 Fragment Color. 4. 修改函数 texture_fragment_shader() in main.cpp: 在实现 Blinn-Phong 的基础上，将纹理颜色视为公式中的 kd，实现 Texture Shading Fragment Shader. 5. 修改函数 bump_fragment_shader() in main.cpp: 在实现 Blinn-Phong 的 基础上，仔细阅读该函数中的注释，实现 Bump mapping. 6. 修改函数 displacement_fragment_shader() in main.cpp: 在实现 Bump mapping 的基础上，实现 displacement mapping.
【Games101】作业3总结
最新发布
m0_52058484的博客
05-28 952
本次作业有一定难度，真的汗流浃背了。做了好几天，看了各种博客，也不敢保证做得很好，但基本的也搞懂了课上的原理可以这么说，这次作业的难度主要在凹凸贴图的实现，也就是bump shading，其他的只要上课注意听和做笔记，多理解一下代码的提示也还好。
games101_作业3
weixin_43789369的博客
11-21 3343
games101作业3——部分解答题目答案与解析rasterize_triangle(const Triangle& t)函数get_projection_matrix()函数phong_fragment_shader()函数texture_fragment_shader()函数未完成(记录)bump_fragment_shader()函数displacement_fragment_shader()函数 题目 在这次编程任务中，我们会进一步模拟现代图形技术。我们在代码中添加了 Object Load
games101——作业3
hhhcbw的博客，欢迎各位来访
10-13 2010
games101作业三，包括提高作业
Games101：作业3（管线分析、深度插值、libpng warning、双线性插值等）
Q_pril的博客
03-21 7400
作业介绍： 如上图所示为本次作业需要完成的任务，在介绍我对于本次作业的心得体会之前，我想先主观的感叹一句，我真的觉得这次作业很难。虽然上课时理论的学习是可以接受并理解的，但实操问题真的很多，我感觉我本次的作业基本上是“临摹”出来的。理论与实践脱轨的一个关键原因，我认为是有很多变量、对象没有弄清，没有理解它们对应的物理意义，所以在编写代码有些无从下手，不知道怎么把公式“变现”，所以我决定很有必要先介绍一下整个代码的实现流程，其中部分流程其实是在前两个作业已经出现的，但因为当时代码相对好...
Assignment1_games101作业1_games101作业7_C++_games101作业_
10-03
在本作业中，我们关注的是GAMES101课程中的第一份作业，它涉及到了图形学中的一个重要概念——投影矩阵。GAMES101通常是一门计算机图形学的基础课程，涵盖了游戏开发和3D图形渲染的基本原理。在这个作业中，学生被...
Games101 作业3 interpolate + phong + texture + bump
weixin_43485513的博客
08-29 789
       学霸笔记        又是学霸笔记        还是学霸笔记        rasterize_triangle 在作业2的基础上对法向量、颜色、纹理颜色与底纹颜色(Shading Colors) 进行插值。翻阅代
GAMES101 作业3（附三角形重心坐标，Blinn-Phong光照模型及法线贴图推导）
m0_53161412的博客
03-04 2457
GAMES101 作业3（附三角形重心坐标，Blinn-Phong光照模型及法线贴图推导）
Games101第三次作业(渲染管线分析、着色模型分析、双线性插值)
Phantom1516的博客
11-17 908
Games101：作业3（渲染管线分析、着色模型分析、双线性插值等）
计算机图形学 第三章 光栅化图形的生成4
03-23
依据陈传波的计算机图形学制作的课件 第三章 光栅化图形的生成5
games101，作业3
Elsa的迷弟
12-11 2285
games101 作业3 任务1. 1. 配置环境 2. 任务（代码分析，框架解释，运行错误的解决） 3. 运行结果
games101 作业3
liveRTL的博客
05-02 4067
环境光： 环境光系数 环境光强度（两个值感觉老师讲的有点乱，但是应该可以直接看成一个常数） 漫反射光： 漫反射系数 当前点的光照强度 当前点接收到的能量（单位向量点乘夹角余弦） 高光： 高光反射系数 当前点的光照强度 高光反射强度，其中h称为半程向量 一个很好的解释：Blinn-Phong光照模型从定义到实现,一文就够了(1.5w字) - 知乎 ............
Games101：作业3 （旋转模型与使用其他模型）
Q_pril的博客
03-22 632
旋转模型 本文分为两部分，第一部分是对于原始模型以下方的命令形式调用，通过键入a或d对模型进行旋转，观察模型结果。 ./Rasterizer 如果模型旋转无变化，注意未必是电脑渲染结果慢，而是angle角度变化太小了，可以设置anlgle = 10，如下图所示。 如此便可以任意旋转，下图是我旋转到某一角度的截图。 如果想要使用其他的着色模型，需要修改active_shader为你想要使用的着色模型，注意如果要想使用texture纹理着色，还需要同步修改texture_path，即纹...
【games101】作业笔记——作业3
A843151774的博客
06-07 328
这里我第一篇写的文章就是作业3，因为作业3包含了整个1-3作业的代码，除了作业代码本身之外，我也会写一些额外自己的拓展。
GAMES101 闫令琪图形学 作业3
再学一个就睡的博客
03-27 1489
作业3 问题描述 重心坐标公式： auto v = t.toVector4(); // 构建包围盒 float min_x = std::min(v[0][0], std::min(v[1][0], v[2][0])); float max_x = std::max(v[0][0], std::max(v[1][0], v[2][0])); float min_y = std::min(v[0][1], std::min(v[1][1], v[2][1]));
Games101作业3:重心插值、着色模型
LuLou_的博客
02-23 402
Assignment3 前置知识 Blinn-Phong 一种局部着色模型（不会生成阴影，因为不涉及多物体） 光源方向I和视角方向v均是从片元出发（指向光源或摄像机） diffuse（漫反射）：与视角无关，只与接受到的光的总量有关 Ld=kd(I/r2)max(0,n∗I) L_d=k_d(I/r^2)max(0,n*I) Ld​=kd​(I/r2)max(0,n∗I) specular（高光）：与视角有关，用光源和视角的半角和法向量作比较 Ls=ks(I/r2)max(0,n∗h)p L_s=k_s(I/
games101作业3
07-25
关于GAMES101作业3，根据引用内容，这个作业涉及到了phong模型的高亮位置、main.cpp文件中的phong_fragment_shader()函数以及其他一些函数和流程。\[1\]\[2\]\[3\]\[4\]根据学生的反馈，这次作业相对较难，需要理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值