Do Lab 2.02

Author: Mohammed-Nour

src/renderer/raytracer/raytracer.h

@@ -54,7 +54,18 @@ namespace cg::renderer
 	inline triangle<VB>::triangle(
 			const VB& vertex_a, const VB& vertex_b, const VB& vertex_c)
 	{
-		// TODO Lab: 2.02 Implement a constructor of `triangle` struct
+		a = float3{vertex_a.x, vertex_a.y, vertex_a.z};
+		b = float3{vertex_b.x, vertex_b.y, vertex_b.z};
+		c = float3{vertex_c.x, vertex_c.y, vertex_c.z};
+		ba = b - a;
+		ca = c - a;
+		na = float3{vertex_a.nx, vertex_a.ny, vertex_a.nz};
+		nb = float3{vertex_b.nx, vertex_b.ny, vertex_b.nz};
+		nc = float3{vertex_c.nx, vertex_c.ny, vertex_c.nz};
+		ambient = float3{vertex_a.ambient_r, vertex_a.ambient_g, vertex_a.ambient_b};
+		diffuse = float3{vertex_a.diffuse_r, vertex_a.diffuse_g, vertex_a.diffuse_b};
+		diffuse = float3{vertex_a.diffuse_r, vertex_a.diffuse_g, vertex_a.diffuse_b};
+		emissive = float3{vertex_a.emissive_r, vertex_a.emissive_g, vertex_a.emissive_b};
 	}
 
 	template<typename VB>
@@ -147,19 +158,32 @@ namespace cg::renderer
 	template<typename VB, typename RT>
 	inline void raytracer<VB, RT>::set_vertex_buffers(std::vector<std::shared_ptr<cg::resource<VB>>> in_vertex_buffers)
 	{
-		// TODO Lab: 2.02 Implement `set_vertex_buffers` and `set_index_buffers` of `raytracer` class
+		vertex_buffers = in_vertex_buffers;
 	}
 
 	template<typename VB, typename RT>
 	void raytracer<VB, RT>::set_index_buffers(std::vector<std::shared_ptr<cg::resource<unsigned int>>> in_index_buffers)
 	{
-		// TODO Lab: 2.02 Implement `set_vertex_buffers` and `set_index_buffers` of `raytracer` class
+		index_buffers = in_index_buffers;
 	}
 
 	template<typename VB, typename RT>
 	inline void raytracer<VB, RT>::build_acceleration_structure()
 	{
-		// TODO Lab: 2.02 Fill `triangles` vector in `build_acceleration_structure` of `raytracer` class
+		for (size_t i = 0; i < index_buffers.size(); i++)
+		{
+			auto& index_buffer = index_buffers[i];
+			auto& vertex_buffer = vertex_buffers[i];
+			size_t index = 0;
+			while (index < index_buffer->get_number_of_elements())
+			{
+				triangle<VB> triangle(
+						vertex_buffer->item(index_buffer->item(index++)),
+						vertex_buffer->item(index_buffer->item(index++)),
+						vertex_buffer->item(index_buffer->item(index++)));
+				triangles.push_back(triangle);
+			}
+		}
 		// TODO Lab: 2.05 Implement `build_acceleration_structure` method of `raytracer` class
 	}
 
@@ -191,7 +215,22 @@ namespace cg::renderer
 			return miss_shader(ray);
 		}
 		depth--;
-		// TODO Lab: 2.02 Adjust `trace_ray` method of `raytracer` class to traverse geometry and call a closest hit shader
+		payload closest_hit_payload{};
+		closest_hit_payload.t = max_t;
+		const triangle<VB>* closest_triangle = nullptr;
+		for (auto& triangle: triangles)
+		{
+			payload payload = intersection_shader(triangle, ray);
+			if (payload.t > min_t && payload.t < closest_hit_payload.t)
+			{
+				closest_hit_payload = payload;
+				closest_triangle = &triangle;
+			}
+		}
+		if (closest_hit_payload.t < max_t) {
+			if (closest_hit_shader)
+				return closest_hit_shader(ray, closest_hit_payload, *closest_triangle, depth);
+		}
 		// TODO Lab: 2.04 Adjust `trace_ray` method of `raytracer` to use `any_hit_shader`
 		// TODO Lab: 2.05 Adjust `trace_ray` method of `raytracer` class to traverse the acceleration structure
 		return miss_shader(ray);
@@ -201,8 +240,24 @@ namespace cg::renderer
 	inline payload raytracer<VB, RT>::intersection_shader(
 			const triangle<VB>& triangle, const ray& ray) const
 	{
-		// TODO Lab: 2.02 Implement an `intersection_shader` method of `raytracer` class
-		return payload{};
+		payload payload{};
+		payload.t = -1.f;
+		float3 pvec = cross(ray.direction, triangle.ca);
+		float det = dot(triangle.ba, pvec);
+		if (det > -1e-8 && det < 1e-8)
+			return payload;
+		float inv_det = 1.f / det;
+		float3 tvec = ray.position - triangle.a;
+		float u = dot(tvec, pvec) * inv_det;
+		if (u < 0.f || u > 1.f)
+			return payload;
+		float3 qvec = cross(tvec, triangle.ba);
+		float v = dot(ray.direction, qvec) * inv_det;
+		if (v < 0.f || u + v > 1.f)
+			return payload;
+		payload.t = dot(triangle.ca, qvec) * inv_det;
+		payload.bary = float3{1.f - u - v, u, v};
+		return payload;
 	}
 
 	template<typename VB, typename RT>

src/renderer/raytracer/raytracer_renderer.cpp

@@ -27,6 +27,8 @@ void cg::renderer::ray_tracing_renderer::init()
 	raytracer = std::make_shared<cg::renderer::raytracer<cg::vertex, cg::unsigned_color>>();
 	raytracer->set_viewport(settings->width, settings->height);
 	raytracer->set_render_target(render_target);
+	raytracer->set_vertex_buffers(model->get_vertex_buffers());
+	raytracer->set_index_buffers(model->get_index_buffers());
 	// TODO Lab: 2.03 Add light information to `lights` array of `ray_tracing_renderer`
 	// TODO Lab: 2.04 Initialize `shadow_raytracer` in `ray_tracing_renderer`
 }
@@ -52,8 +54,13 @@ void cg::renderer::ray_tracing_renderer::render()
 	std::chrono::duration<float, std::milli> rt_duration = stop-start;
 	std::cout<<"Ray tracing took "<< rt_duration.count()<<"ms\n";
 	cg::utils::save_resource(*render_target, settings->result_path);
-
-	// TODO Lab: 2.02 Add `closest_hit_shader` to `raytracer` class to return diffuse color
+	raytracer->closest_hit_shader = [](const ray& ray, payload& payload,
+									   const triangle<cg::vertex>& triangle,
+									   size_t depth){
+		payload.color = cg::color::from_float3(triangle.diffuse);
+		return payload;
+	};
+	raytracer->build_acceleration_structure();
 	// TODO Lab: 2.03 Adjust `closest_hit_shader` of `raytracer` to implement Lambertian shading model
 	// TODO Lab: 2.04 Define `any_hit_shader` and `miss_shader` for `shadow_raytracer`
 	// TODO Lab: 2.04 Adjust `closest_hit_shader` of `raytracer` to cast shadows rays and to ignore occluded lights