【GAMES101】作业5 简单光线追踪与代码流程理解

1. 作业描述

在这部分的课程中，我们将专注于使用光线追踪来渲染图像。在光线追踪中最重要的操作之一就是找到光线与物体的交点。一旦找到光线与物体的交点，就可以执行着色并返回像素颜色。在这次作业中，我们需要实现两个部分：光线的生成和光线与三角的相交。本次代码框架的工作流程为：

1. 从 main 函数开始。我们定义场景的参数，添加物体（球体或三角形）到场景中，并设置其材质，然后将光源添加到场景中。
2. 调用 Render(scene) 函数。在遍历所有像素的循环里，生成对应的光线并将返回的颜色保存在帧缓冲区（framebuffer）中。在渲染过程结束后，帧缓冲区中的信息将被保存为图像。
3. 在生成像素对应的光线后，我们调用 CastRay 函数，该函数调用 trace 来查询光线与场景中最近的对象的交点。
4. 然后，我们在此交点执行着色。我们设置了三种不同的着色情况，并且已经为你提供了代码。

• global.hpp：包含了整个框架中会使用的基本函数和变量。
• Vector.hpp: 由于我们不再使用 Eigen 库，因此我们在此处提供了常见的向量操作，例如：dotProduct，crossProduct，normalize。
• Object.hpp: 渲染物体的父类。Triangle 和 Sphere 类都是从该类继承的。
• Scene.hpp: 定义要渲染的场景。包括设置参数，物体以及灯光。
• Renderer.hpp: 渲染器类，它实现了所有光线追踪的操作。

你需要修改的函数是：

• Renderer.cpp 中的 Render()：这里你需要为每个像素生成一条对应的光线，然后调用函数 castRay()来得到颜色，最后将颜色存储在帧缓冲区的相应像素中。
• Triangle.hpp 中的 rayTriangleIntersect():v0, v1, v2 是三角形的三个顶点，orig 是光线的起点，dir 是光线单位化的方向向量。tnear, u, v是你需要使用我们课上推导的 Moller-Trumbore 算法来更新的参数

2. 解

本次作业要修改的部分很简单，但是还是有一些点需要注意

2.1 Render

根据题目要求，这部分我们需要为每个像素生成一条对应的光线，根据已知条件，我们已经有了相机的fov，场景的像素和宽高比，现在要求出相机到像素每个点的光线，但是根据这些，我们发现还差一个条件，那就是成像平面的深度未知，这样就无法通过fov求出场景在世界坐标系下的高，自然也无法根据宽高比求出它的宽，这条光线就不可求了，但是我们仔细看作业给的源代码中有这么一条语句：Vector3f dir = Vector3f(x, y, -1)；// Don’t forget to normalize this direction! 它说的是不要忘记对求出来的光线方向归一化，也就是说这条向量就是相机到像素的原始向量，那么就隐含了一个成像平面的深度为-1的条件（相机向-z方向看），就此，我们就可以根据现有条件算出具体的光线了（默认遍历顺序是左上到右下，像素坐标(640,480)对应世界坐标系(0,0)，在坐标转换时别忘了是转换的像素中心的坐标，对i和j要加0.5）：

void Renderer::Render(const Scene& scene)
{
    std::vector<Vector3f> framebuffer(scene.width * scene.height);

    float scale = std::tan(deg2rad(scene.fov * 0.5f));
    float imageAspectRatio = scene.width / (float)scene.height;

    // Use this variable as the eye position to start your rays.
    Vector3f eye_pos(0);
    int m = 0;
    for (int j = 0; j < scene.height; ++j)
    {
        for (int i = 0; i < scene.width; ++i)
        {
            // generate primary ray direction
            float x;
            float y;
            // TODO: Find the x and y positions of the current pixel to get the direction
            // vector that passes through it.
            // Also, don't forget to multiply both of them with the variable *scale*, and
            // x (horizontal) variable with the *imageAspectRatio*            
            x = 2 * scale * imageAspectRatio / scene.width * (i + 0.5) - scale * imageAspectRatio;
            y = - 2 * scale / scene.height * (j + 0.5) + scale;
            Vector3f dir = Vector3f(x, y, -1); // Don't forget to normalize this direction!
            dir = normalize(dir);
            framebuffer[m++] = castRay(eye_pos, dir, scene, 0);
        }
        UpdateProgress(j / (float)scene.height);
    }

    // save framebuffer to file
    FILE* fp = fopen("binary.ppm", "wb");
    (void)fprintf(fp, "P6\n%d %d\n255\n", scene.width, scene.height);
    for (auto i = 0; i < scene.height * scene.width; ++i) {
        static unsigned char color[3];
        color[0] = (char)(255 * clamp(0, 1, framebuffer[i].x));
        color[1] = (char)(255 * clamp(0, 1, framebuffer[i].y));
        color[2] = (char)(255 * clamp(0, 1, framebuffer[i].z));
        fwrite(color, 1, 3, fp);
    }
    fclose(fp);    
}

2.2 rayTriangleIntersect

这部分的代码就是对Lecture 13上提到的Möller Trumbore算法的具体实现：

算法具体的推导过程见：Möller Trumbore
需要注意的是计算结束以后别忘了对算得的tnear、u、v进行有效性计算，若范围正确则返回true

bool rayTriangleIntersect(const Vector3f& v0, const Vector3f& v1, const Vector3f& v2, const Vector3f& orig,
                          const Vector3f& dir, float& tnear, float& u, float& v)
{
    // TODO: Implement this function that tests whether the triangle
    // that's specified bt v0, v1 and v2 intersects with the ray (whose
    // origin is *orig* and direction is *dir*)
    // Also don't forget to update tnear, u and v.
    Vector3f E1, E2, S, S1, S2, re;
    E1 = v1 - v0;
    E2 = v2 - v0;
    S = orig - v0;
    S1 = crossProduct(dir, E2);
    S2 = crossProduct(S, E1);
    re = Vector3f(dotProduct(S2, E2), dotProduct(S1, S), dotProduct(S2, dir));
    re = re / dotProduct(S1, E1);
    tnear = re.x;
    u = re.y;
    v = re.z;
    if(tnear > 0 && v >= 0 && v <= 1 && u >= 0 && u <= 1)
        return true;
    return false;
}

3. 效果

与实例基本一致

4. 框架理解

课程进入到光追部分，作业框架也进一步扩充，引入了不少复杂的计算，为了方便对后来的作业更快上手，我就对作业的框架做了一点梳理

4.1 场景设置

首先程序开始于main.cpp，在这里的main函数创建了整个场景（1280*960像素）：

int main()
{
    Scene scene(1280, 960);
	...

之后创建了两个球体，设置了它们的圆心、材质和颜色等属性并加入场景：

	...
    auto sph1 = std::make_unique<Sphere>(Vector3f(-1, 0, -12), 2);//圆心是(-1, 0, -12)，半径是2
    sph1->materialType = DIFFUSE_AND_GLOSSY;//材质为DIFFUSE_AND_GLOSSY，可以看作在这个物体上的反射是粗糙反射（介于镜面反射和漫反射之间）与漫反射的叠加
    sph1->diffuseColor = Vector3f(0.6, 0.7, 0.8);//漫反射底色为(0.6, 0.7, 0.8)

    auto sph2 = std::make_unique<Sphere>(Vector3f(0.5, -0.5, -8), 1.5);圆心是(0.5, -0.5, -8)，半径是1.5
    sph2->ior = 1.5;//折射率为1.5
    sph2->materialType = REFLECTION_AND_REFRACTION;//材质为REFLECTION_AND_REFRACTION，可以看作在这个物体上的反射是镜面反射和折射的叠加

    scene.Add(std::move(sph1));
    scene.Add(std::move(sph2));//将两个球体加入场景
    ...

接下来就是创建一个地面矩形网格，可以看作两个三角形拼接以便于计算，这里是用vertIndex来区分两个三角形顶点，比如第一个三角形的顶点就是verts中的第0,1,3个顶点，第二个的顶点就是verts中第1,2,3个顶点：

	...
    Vector3f verts[4] = {{-5,-3,-6}, {5,-3,-6}, {5,-3,-16}, {-5,-3,-16}};//网格的四个顶点
    uint32_t vertIndex[6] = {0, 1, 3, 1, 2, 3};//两个三角形的顶点序号
    Vector2f st[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
    auto mesh = std::make_unique<MeshTriangle>(verts, vertIndex, 2, st);//2指的就是由两个三角形组成
    mesh->materialType = DIFFUSE_AND_GLOSSY;//设置网格材质为DIFFUSE_AND_GLOSSY

    scene.Add(std::move(mesh));//网格加入场景
    ...

然后就是创建两个点光源并加入场景：

	...    
    scene.Add(std::make_unique<Light>(Vector3f(-20, 70, 20), 0.5));//点光源坐标是(-20, 70, 20)，intensity是0.5
    scene.Add(std::make_unique<Light>(Vector3f(30, 50, -12), 0.5));    
	...

最后就是创建一个渲染器，并将创建好的场景加入渲染器渲染：

	...
    Renderer r;
    r.Render(scene);
    return 0;
}

4.2 渲染

进入到Renderer.cpp的Rander函数，也就是我们本次作业修改的其中一部分，我们完成了到每个成像平面像素的光线求解，接下来就是通过castRay对光线和场景求交并计算颜色，将颜色存储在framebuffer中等待画出：

void Renderer::Render(const Scene& scene)
{
    std::vector<Vector3f> framebuffer(scene.width * scene.height);

    float scale = std::tan(deg2rad(scene.fov * 0.5f));
    float imageAspectRatio = scene.width / (float)scene.height;

    // Use this variable as the eye position to start your rays.
    Vector3f eye_pos(0);
    int m = 0;
    for (int j = 0; j < scene.height; ++j)
    {
        for (int i = 0; i < scene.width; ++i)
        {
            // generate primary ray direction
            float x;
            float y;        
            x = 2 * scale * imageAspectRatio / scene.width * (i + 0.5) - scale * imageAspectRatio;
            y = - 2 * scale / scene.height * (j + 0.5) + scale;
            Vector3f dir = Vector3f(x, y, -1); // Don't forget to normalize this direction!
            dir = normalize(dir);
            framebuffer[m++] = castRay(eye_pos, dir, scene, 0);
        	...

4.3 求交

求出光线后要找出光线与场景的交点以方便计算着色，这里就进入到了castRay函数，首先是一些基本设置：

Vector3f castRay(const Vector3f &orig, const Vector3f &dir, const Scene& scene, int depth)
{
    if (depth > scene.maxDepth) {//如果超出了场景的最大光线反射/折射次数就设置颜色为黑色，并不再往下进行
        return Vector3f(0.0,0.0,0.0);
    }

    Vector3f hitColor = scene.backgroundColor;//设置默认hitcolor为场景背景颜色，如果光线不与物体相交则就是背景颜色
    ...

接下来就是通过trace函数判断光线是否和场景中的物体相交：

	...
	if (auto payload = trace(orig, dir, scene.get_objects()); payload)
	{
		...

转到trace函数，这部分就是利用传入的参数，调用每个物体的intersect方法进行求交

std::optional<hit_payload> trace(const Vector3f &orig, const Vector3f &dir, const std::vector<std::unique_ptr<Object>> &objects)
{
    float tNear = kInfinity;
    std::optional<hit_payload> payload;
    for (const auto & object : objects)
    {
        float tNearK = kInfinity;
        uint32_t indexK;
        Vector2f uvK;
        if (object->intersect(orig, dir, tNearK, indexK, uvK) && tNearK < tNear)//如果求得的交点有效，则保存下来
        {
        ...

因为object有sphere和triangle两个子类，所以自然intersect求交也有两种：

4.3.1 triangle求交

在Triangle.hpp中即可看到其intersect方法，在这里就是遍历一个网格中的两个三角形，并对它们运行rayTriangleIntersect函数进行求交计算，在之前的解中已经给出，这里就不重复贴上代码了

bool intersect(const Vector3f& orig, const Vector3f& dir, float& tnear, uint32_t& index, Vector2f& uv) const override
{
	bool intersect = false;
	for (uint32_t k = 0; k < numTriangles; ++k)
	{
		const Vector3f& v0 = vertices[vertexIndex[k * 3]];
		const Vector3f& v1 = vertices[vertexIndex[k * 3 + 1]];
		const Vector3f& v2 = vertices[vertexIndex[k * 3 + 2]];
		float t, u, v;
		if (rayTriangleIntersect(v0, v1, v2, orig, dir, t, u, v) && t < tnear)
		{
			...

4.3.2 sphere求交

在Sphere.hpp中即可看到其intersect方法，根据课上所学来列式：

bool intersect(const Vector3f& orig, const Vector3f& dir, float& tnear, uint32_t&, Vector2f&) const override
{
	// analytic solution
	Vector3f L = orig - center;
	float a = dotProduct(dir, dir);
	float b = 2 * dotProduct(dir, L);
	float c = dotProduct(L, L) - radius2;
	float t0, t1;
	if (!solveQuadratic(a, b, c, t0, t1))
		return false;
	if (t0 < 0)
		t0 = t1;
	if (t0 < 0)//如果两个解都是小于0的，则都无效
		return false;
	tnear = t0;
	return true;
}

接下来就是进入函数solveQuadratic解这个一元二次方程，只不过这里的解法稍微有些不同，想进一步了解的可戳链接：求解一元二次方程

bool solveQuadratic(const float &a, const float &b, const float &c, float &x0, float &x1)
{
    float discr = b * b - 4 * a * c;
    if (discr < 0) return false;
    else if (discr == 0) x0 = x1 = - 0.5 * b / a;
    else {
        float q = (b > 0) ?
            -0.5 * (b + sqrt(discr)) :
            -0.5 * (b - sqrt(discr));
        x0 = q / a;
        x1 = c / q;
    }
    if (x0 > x1) std::swap(x0, x1);
    return true;
}

4.4 着色

求得交点以后，我们把结果存入payload，返回到Randerer.cpp的castRay函数中：

接下来要做的就是获取被相交的物体的表面性质，以判断着色方式以及光线后续的走向

	...
	if (auto payload = trace(orig, dir, scene.get_objects()); payload)
    {
        Vector3f hitPoint = orig + dir * payload->tNear;//交点
        Vector3f N; // normal
        Vector2f st; // st coordinates
        payload->hit_obj->getSurfaceProperties(hitPoint, dir, payload->index, payload->uv, N, st);
        ...

4.4.1 REFLECTION_AND_REFRACTION着色

这种材质下就是分两条光线来考虑着色，分别是反射和折射光线，计算它们的方向以后再调用castRay，从当前点开始继续下一次光线追踪，最后利用fresnel（菲涅尔）函数来计算反射和折射在这个点的着色比例以得到最终颜色，菲涅尔的推导过程较复杂，想进一步了解的可以戳链接：菲涅尔公式

在计算新的RayOrig的时候是hitPoint ± N * scene.epsilon，经查询后发现默认的episilon=0.00001，也就是说新的RayOrig只与原来的交点有细微差距，比如折射时新光线与交点法向量的夹角大于90°，那么新光线起点就是hitPoint - N * scene.epsilon，处于物体内，所以应该只是为了区分内外光线用的

		...
		switch (payload->hit_obj->materialType) {
            case REFLECTION_AND_REFRACTION:
            {
                Vector3f reflectionDirection = normalize(reflect(dir, N));
                Vector3f refractionDirection = normalize(refract(dir, N, payload->hit_obj->ior));
                Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?
                                             hitPoint - N * scene.epsilon :
                                             hitPoint + N * scene.epsilon;
                Vector3f refractionRayOrig = (dotProduct(refractionDirection, N) < 0) ?
                                             hitPoint - N * scene.epsilon :
                                             hitPoint + N * scene.epsilon;
                Vector3f reflectionColor = castRay(reflectionRayOrig, reflectionDirection, scene, depth + 1);
                Vector3f refractionColor = castRay(refractionRayOrig, refractionDirection, scene, depth + 1);
                float kr = fresnel(dir, N, payload->hit_obj->ior);
                hitColor = reflectionColor * kr + refractionColor * (1 - kr);
                break;
            }
            ...

4.4.2 REFLECTION着色

这种材质的物体表面就是只考虑一条镜面反射光线，具体着色过程其实在上面部分已经覆盖：

			...
            case REFLECTION:
            {
                float kr = fresnel(dir, N, payload->hit_obj->ior);
                Vector3f reflectionDirection = reflect(dir, N);
                Vector3f reflectionRayOrig = (dotProduct(reflectionDirection, N) < 0) ?
                                             hitPoint + N * scene.epsilon :
                                             hitPoint - N * scene.epsilon;
                hitColor = castRay(reflectionRayOrig, reflectionDirection, scene, depth + 1) * kr;
                break;
            }
            ...

4.4.3 默认着色（漫反射加高光（Phong illumation 模型））

若是默认的材质的话，就简单利用之前作业3提到的phong模型来进行着色，只考虑高光和漫反射，注意这里要考虑交点是否被遮挡，如果交点处能看到光源，则用Phong模型计算光照颜色，反之则在阴影内，变成黑色。另外，光线打在粗糙的物体上后，不再做反射。这就是为啥我们最终渲染出来的阴影是硬阴影：

			...
			default:
            {
                Vector3f lightAmt = 0, specularColor = 0;
                Vector3f shadowPointOrig = (dotProduct(dir, N) < 0) ?
                                           hitPoint + N * scene.epsilon :
                                           hitPoint - N * scene.epsilon;
                for (auto& light : scene.get_lights()) {//对每个光源进行一次计算，并累加结果
                    Vector3f lightDir = light->position - hitPoint;
                    float lightDistance2 = dotProduct(lightDir, lightDir);
                    lightDir = normalize(lightDir);
                    float LdotN = std::max(0.f, dotProduct(lightDir, N));
                    // 若有交点且距离小于它到光源的距离，则该点不在阴影中
                    auto shadow_res = trace(shadowPointOrig, lightDir, scene.get_objects());
                    bool inShadow = shadow_res && (shadow_res->tNear * shadow_res->tNear < lightDistance2);
                    lightAmt += inShadow ? 0 : light->intensity * LdotN;
                    Vector3f reflectionDirection = reflect(-lightDir, N);
                    specularColor += powf(std::max(0.f, -dotProduct(reflectionDirection, dir)),
                        payload->hit_obj->specularExponent) * light->intensity;
                }
                hitColor = lightAmt * payload->hit_obj->evalDiffuseColor(st) * payload->hit_obj->Kd + specularColor * payload->hit_obj->Ks;
                break;
            }
            ...

4.5 保存

计算完着色后回到Render函数，将颜色保存在framebuffer中，并根据当前进度更新进度条，待所有颜色都计算完成后从framebuffer中取出数据，计算颜色并画在ppm图像文件上进行保存，流程结束

			...
            framebuffer[m++] = castRay(eye_pos, dir, scene, 0);
        }
        UpdateProgress(j / (float)scene.height);//更新进度条
    }

    // save framebuffer to file
    FILE* fp = fopen("binary.ppm", "wb");
    (void)fprintf(fp, "P6\n%d %d\n255\n", scene.width, scene.height);
    for (auto i = 0; i < scene.height * scene.width; ++i) {
        static unsigned char color[3];
        color[0] = (char)(255 * clamp(0, 1, framebuffer[i].x));
        color[1] = (char)(255 * clamp(0, 1, framebuffer[i].y));
        color[2] = (char)(255 * clamp(0, 1, framebuffer[i].z));
        fwrite(color, 1, 3, fp);
    }
    fclose(fp);    
}

5. 附件

附上源代码，有兴趣的朋友可以自己尝试一下效果：
CSDN:【GAMES101】作业5
GITHUB:【GAMES101】作业合集