TinyRenderer笔记5：阴影和矫正透视变形 - 完结

pub struct PhongShaderWithShadow<'a> {
    model: &'a obj::Obj<TexturedVertex, u32>,
    diffuse: &'a ImageBuffer<Rgba<u8>, Vec<u8>>,
    diffuse_nm: &'a ImageBuffer<Rgba<u8>, Vec<u8>>, // 法线贴图
    diffuse_spec: &'a ImageBuffer<Rgba<u8>, Vec<u8>>, // 高光贴图
    shadow_buffer: &'a Vec<f32>,                    // 阴影缓冲区
    varying_uv: glm::Mat3,                          // 三个顶点的纹理坐标
    varying_tri: glm::Mat3,                         // 三个顶点的屏幕坐标
    uniform_m: Mat4, // 模型的变换矩阵m projection*model_view ,不带view_port,不用到屏幕坐标
    uniform_mv_it: Mat4, // uniform_m的逆转置矩阵 m.inverse().transpose()
    uniform_m_shadow: Mat4, // 用来将frame buffer中的屏幕坐标，转换为shadow buffer中的屏幕坐标
    light_dir: Vec3,
    view_port: Mat4,
    projection: Mat4,
    model_view: Mat4,
    width: u32, // 画布宽度
}
impl<'a> IShader for PhongShaderWithShadow<'a> {
    fn vertex(&mut self, i_face: usize, nth_vert: usize) -> glm::Vec4 {
        let i_vert = self.model.indices[i_face * 3 + nth_vert];
        let vert = self.model.vertices[i_vert as usize];
        let v = Vec3::from_array(&vert.position); // 顶点位置
        let uv = Vec3::from_array(&vert.texture); // 纹理坐标

        self.varying_uv.as_array_mut()[nth_vert] = uv.clone(); // 每一列是一个顶点处的纹理坐标
        let gl_v = self.view_port * self.projection * self.model_view * v.extend(1.); // 直接到屏幕坐标
        self.varying_tri.as_array_mut()[nth_vert] = v4p2v3(gl_v);
        gl_v
    }

    fn fragment(&mut self, bar: glm::Vec3, color: &mut image::Rgba<u8>) -> bool {
        // 把当前fragment的屏幕坐标转换到shadow buffer的屏幕坐标
        let sb_p = self.uniform_m_shadow * (self.varying_tri * bar).extend(1.);
        let sb_p = v4p2v3(sb_p);
        let idx = sb_p.x as u32 + (sb_p.y as u32 * self.width); // shadow buffer的下标

        // 当前点的阴影深度大于深度缓冲时，说明没有被遮挡光线
        let shadow = 0.3
            + 0.7
                * (if self.shadow_buffer[idx as usize] <= sb_p.z {
                    1.
                } else {
                    0.
                });

        // ...

        let mut n = Vec3::from_array(&[nm_px[0] as _, nm_px[1] as _, nm_px[2] as _]).clone(); // 从贴图中加载法向量
        n.as_array_mut()
            .iter_mut()
            .for_each(|v| *v = *v / 255. * 2. - 1.); // tga图像中[0,255], 转换到[-1,-1]
                                                     //println!("normal: {:?}", n);

        let n = self.uniform_mv_it * n.extend(0.); // 法线映射 注意向量转换位齐次坐标是填0
        let n = glm::normalize(vec4_to_3(n)); // 齐次坐标投影回3d 注意向量不需要除w分量

        let l = self.uniform_m * self.light_dir.extend(0.); // 映射光照方向
        let l = glm::normalize(vec4_to_3(l));

        let r = glm::normalize(n * (glm::dot(n, l) * 2.) - l); // 反射光方向

        let spec = glm::pow(r.z.max(0.), spec_v); // 我们从z轴看, dot(v,r)
        let diff = glm::dot(n, l).max(0.);

        let arg_ambient = 20.; // 环境光
        let arg_diffuse = 1.2; // 漫反射光
        let arg_specular = 0.6; // 镜面反射光
        let intensity = glm::dot(n, l);

        // 阴影参与计算
        let r = (arg_ambient + px[0] as f32 * shadow * (arg_diffuse * diff + arg_specular * spec))
            as u8;
        let g = (arg_ambient + px[1] as f32 * shadow * (arg_diffuse * diff + arg_specular * spec))
            as u8;
        let b = (arg_ambient + px[2] as f32 * shadow * (arg_diffuse * diff + arg_specular * spec))
            as u8;
        *color = image::Rgba([r, g, b, 255]);
        return false; // 不丢弃任何像素
    }
}

// 渲染shadow buffer
let mut shader = ShadowShader::new(&model, model_view_light, projection, view_port);
for i in 0..model.indices.len() / 3 {
	let mut clip_coords: [glm::Vec4; 3] = [glm::Vec4::zero(); 3];
	for j in 0..3 {
		clip_coords[j] = shader.vertex(i, j);
	}
	triangle_with_shader_shadow(
		clip_coords[0],
		clip_coords[1],
		clip_coords[2],
		&mut shader,
		&mut image,
		&mut shadowbuffer,
	);
}
// 记录下渲染shadow buffer时的变换矩阵
let shadow_m = view_port * projection * model_view_light;
flip_verticin_place(&mut image);
image.save("a.png").unwrap();

// 渲染模型
#[rustfmt::skip]
let projection = glm::mat4(
	1., 0., 0., 0.,
	0., 1., 0., 0.,
	0., 0., 1., -1./ glm::distance(eye, center),
	0., 0., 0., 1.);
let mut shader = PhongShaderWithShadow::new(
	&model,
	&diffus,
	&diffus_nm,
	&diffus_spec,
	projection * model_view, // uniform_m
	(projection * model_view).inverse().unwrap().transpose(), // uniform_m 的逆转置矩阵，用来做法线变换
	shadow_m * (view_port * projection * model_view).inverse().unwrap(), // uniform_m_shadow
	light_dir,
	view_port,
	projection,
	model_view,
	width,
	&mut shadowbuffer, // 阴影信息
);
for i in 0..model.indices.len() / 3 {
	let mut clip_coords: [glm::Vec4; 3] = [glm::Vec4::zero(); 3];
	for j in 0..3 {
		clip_coords[j] = shader.vertex(i, j);
	}
	triangle_with_shader_shadow(
		clip_coords[0],
		clip_coords[1],
		clip_coords[2],
		&mut shader,
		&mut image,
		&mut zbuffer,
	);
}

flip_vertical_in_place(&mut image);
image.save("b.png").unwrap();