GAMES101作业2

作业任务：

填写并调用函数 rasterize_triangle(const Triangle& t)。

即实现光栅化

该函数的内部工作流程如下：

创建三角形的 2 维 bounding box。
遍历此 bounding box 内的所有像素（使用其整数索引）。然后，使用像素中
心的屏幕空间坐标来检查中心点是否在三角形内。
如果在内部，则将其位置处的插值深度值 (interpolated depth value) 与深度
缓冲区 (depth buffer) 中的相应值进行比较。
如果当前点更靠近相机，请设置像素颜色并更新深度缓冲区 (depth buffer)。
你需要修改的函数如下：
• rasterize_triangle(): 执行三角形栅格化算法
• static bool insideTriangle(): 测试点是否在三角形内。你可以修改此函
数的定义，这意味着，你可以按照自己的方式更新返回类型或函数参数。

开始实现：

在进行光栅化的时候，我们需要判断某个点是否在triangle内，来决定是否着色。

所以我们第一步实现static bool insideTriangle()

x:表示观测点的x值
y:表示观测点的y值
_v:是一个vector<Vector3f>,内含三角形的三个点，每个点存有x、y、z值
static bool insideTriangle(double x, double y, const Vector3f* _v)
{   
    Eigen::Vector2f p;      //检测目标
    p << x, y;

	//.head(2)指这个点的前两个数值，即x,y
    Eigen::Vector2f a, b, c;   //被检测的三角形三边向量  
    a = _v[0].head(2) - _v[1].head(2);          //a = A - B  即B->A
    b = _v[1].head(2) - _v[2].head(2);          //b = B - C  即C->B
    c = _v[2].head(2) - _v[0].head(2);          //c = C - A  即A->C  

    Eigen::Vector2f AP, BP, CP;
    AP = p - _v[0].head(2);
    BP = p - _v[1].head(2);
    CP = p - _v[2].head(2);
    
    //由于我这里的向量方向都是逆时针的，所以如果点p在内，那么所有边向量叉乘对应的XP都应该为正值，指向z的正半轴。
    return AP[0] * c[1] - AP[1] * c[0] > 0 && BP[0] * a[1] - BP[1] * a[0] > 0 && CP[0] * b[1] - CP[1] * b[0] > 0;
}

现在来实现rasterize_triangle(const Triangle& t)

分析：

第一步确定bounding box
给定一个三角形，我们先要扫描出这个三角占据了哪些格子(像素单元)，即定义bounding box，取得这个三角形的x和y轴上的边界值，使得这个bounding box尽可能的小，但又必须包裹住这个三角形。
第二步扫描bounding box
逐一扫描这个bounding box内的所有单元，以每个单元的中心位置代替此单元，将坐标传入insideTriangle函数中，如果不在，则扫描下一个，如果在，则以三角形三点做插值得到这个中心点的z值,进一步判断，这个z值是否比深度缓存中对应位置的值要小，不小则不处理，小则替换深度缓存中的值为当前值。随后设置这个单元的颜色值。

这里很容易就能想到，如果这个单元尺寸越小，就能更加精确的确定边界。也就是MSAA，多重采样抗锯齿，这个并不是从物理上将单元切割成更小的，而是将一个单元看成多个单元组合，然后对这个更小单元进行采样。每个单元的尺寸越小，成像的边界锯齿效果就越虚，即成像效果越好，但这样会使效率降低，将一个单元切割成2x2的四个小单元，会使原来一个单位的工作量升至四个单位的工作量。

//Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle& t) {
    auto v = t.toVector4();//这里是把三角形结构体换成三个顶点如（x1,y1,z1,1） 
			   //还记得嘛？最后的1表示它是一个点,用于齐次坐标
			   
    //bounding box
    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]));
    float max_y = std::max(v[0][1], std::max(v[1][1], v[2][1]));

    min_x = static_cast<int>(std::floor(min_x));
    min_y = static_cast<int>(std::floor(min_y));
    max_x = static_cast<int>(std::ceil(max_x));
    max_y = static_cast<int>(std::ceil(max_y));

	//左边界小数部分全部直接舍，右边界小数部分直接入，确保单元边界坐标都是整数，三角形一定在bounding box内。

    bool MSAA = true;//MSAA是否启用

    if (MSAA)
    {
        std::vector<Eigen::Vector2f> pos
        {                               //对一个像素分割四份 当然你还可以分成4x4 8x8等等甚至你还可以为了某种特殊情况设计成不规则的图形来分割单元
            {0.25,0.25},                //左下
            {0.75,0.25},                //右下
            {0.25,0.75},                //左上
            {0.75,0.75}                 //右上
        };
        for (int i = min_x; i <= max_x; ++i)
        {
            for (int j = min_y; j <= max_y; ++j)
            {
                int count = 0;
                float minDepth = FLT_MAX;
                for (int MSAA_4 = 0; MSAA_4 < 4; ++MSAA_4)
                {
                    if (insideTriangle(static_cast<float>(i+pos[MSAA_4][0]), static_cast<float>(j+pos[MSAA_4][1]),t.v))
                    {
			    auto[alpha, beta, gamma] = computeBarycentric2D(static_cast<float>(i + pos[MSAA_4][0]), static_cast<float>(j + pos[MSAA_4][1]), t.v);
	                    float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
	                    float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
	                    z_interpolated *= w_reciprocal;

                        minDepth = std::min(minDepth, z_interpolated);
                        ++count;
                    }
                }
                if (count)
                {
                    if (depth_buf[get_index(i, j)] > minDepth)
                    {
                        depth_buf[get_index(i, j)] = minDepth;//更新深度

                        Eigen::Vector3f color = t.getColor() * (count / 4.0);//对颜色进行平均，使得边界更平滑，也是一种模糊的手段
                        Eigen::Vector3f point;
                        point << static_cast<float>(i), static_cast<float>(j), minDepth;
                        set_pixel(point, color);//设置颜色
                    }
                }
            }
        }
    }
    else
    {
		for (int i = min_x; i <= max_x; ++i)
		{
			for (int j = min_y; j <= max_y; ++j)
			{
				if (insideTriangle(static_cast<float>(i+0.5), static_cast<float>(j+0.5),t.v))
				{
					auto [alpha, beta, gamma] = computeBarycentric2D(static_cast<float>(i + 0.5), static_cast<float>(j + 0.5), t.v);
					float w_reciprocal = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
					float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
					z_interpolated *= w_reciprocal;

					if (depth_buf[get_index(i, j)] > z_interpolated)
					{
						depth_buf[get_index(i, j)] = z_interpolated;//更新深度
						Eigen::Vector3f color = t.getColor();
						Eigen::Vector3f point;
						point << static_cast<float>(i), static_cast<float>(j), z_interpolated;
						set_pixel(point, color);//设置颜色
					}
				}
			}
		}
	}
}