hotfix

Author: Mohammed-Nour

src/renderer/raytracer/raytracer.h

@@ -51,20 +51,24 @@ namespace cg::renderer
 	};
 
 	template<typename VB>
-	inline triangle<VB>::triangle(
-			const VB& vertex_a, const VB& vertex_b, const VB& vertex_c)
+	inline triangle<VB>::triangle(const VB& vertex_a, const VB& vertex_b,
+								  const VB& vertex_c)
 	{
 		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};
-		emissive = float3{vertex_a.emissive_r, vertex_a.emissive_g, vertex_a.emissive_b};
+		emissive =
+				float3{vertex_a.emissive_r, vertex_a.emissive_g, vertex_a.emissive_b};
 	}
 
 	template<typename VB>
@@ -99,21 +103,29 @@ namespace cg::renderer
 		void clear_render_target(const RT& in_clear_value);
 		void set_viewport(size_t in_width, size_t in_height);
 
-		void set_vertex_buffers(std::vector<std::shared_ptr<cg::resource<VB>>> in_vertex_buffers);
-		void set_index_buffers(std::vector<std::shared_ptr<cg::resource<unsigned int>>> in_index_buffers);
+		void set_vertex_buffers(
+				std::vector<std::shared_ptr<cg::resource<VB>>> in_vertex_buffers);
+		void
+		set_index_buffers(std::vector<std::shared_ptr<cg::resource<unsigned int>>>
+								  in_index_buffers);
 		void build_acceleration_structure();
 		std::vector<aabb<VB>> acceleration_structures;
 
-		void ray_generation(float3 position, float3 direction, float3 right, float3 up, size_t depth, size_t accumulation_num);
+		void ray_generation(float3 position, float3 direction, float3 right,
+							float3 up, size_t depth, size_t accumulation_num);
 
-		payload trace_ray(const ray& ray, size_t depth, float max_t = 1000.f, float min_t = 0.001f) const;
-		payload intersection_shader(const triangle<VB>& triangle, const ray& ray) const;
+		payload trace_ray(const ray& ray, size_t depth, float max_t = 1000.f,
+						  float min_t = 0.001f) const;
+		payload intersection_shader(const triangle<VB>& triangle,
+									const ray& ray) const;
 
 		std::function<payload(const ray& ray)> miss_shader = nullptr;
-		std::function<payload(const ray& ray, payload& payload, const triangle<VB>& triangle, size_t depth)>
+		std::function<payload(const ray& ray, payload& payload,
+							  const triangle<VB>& triangle, size_t depth)>
 				closest_hit_shader = nullptr;
-		std::function<payload(const ray& ray, payload& payload, const triangle<VB>& triangle)> any_hit_shader =
-				nullptr;
+		std::function<payload(const ray& ray, payload& payload,
+							  const triangle<VB>& triangle)>
+				any_hit_shader = nullptr;
 
 		float2 get_jitter(int frame_id);
 
@@ -136,17 +148,16 @@ namespace cg::renderer
 	}
 
 	template<typename VB, typename RT>
-	inline void raytracer<VB, RT>::set_viewport(size_t in_width,
-												size_t in_height)
+	inline void raytracer<VB, RT>::set_viewport(size_t in_width, size_t in_height)
 	{
-		width = in_width;
 		height = in_height;
+		width = in_width;
+
 		history = std::make_shared<cg::resource<float3>>(width, height);
 	}
 
 	template<typename VB, typename RT>
-	inline void raytracer<VB, RT>::clear_render_target(
-			const RT& in_clear_value)
+	inline void raytracer<VB, RT>::clear_render_target(const RT& in_clear_value)
 	{
 		for (size_t i = 0; i < render_target->count(); i++) {
 			render_target->item(i) = in_clear_value;
@@ -155,42 +166,43 @@ 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)
+	inline void raytracer<VB, RT>::set_vertex_buffers(
+			std::vector<std::shared_ptr<cg::resource<VB>>> in_vertex_buffers)
 	{
 		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)
+	void raytracer<VB, RT>::set_index_buffers(
+			std::vector<std::shared_ptr<cg::resource<unsigned int>>> in_index_buffers)
 	{
 		index_buffers = in_index_buffers;
 	}
 
 	template<typename VB, typename RT>
 	inline void raytracer<VB, RT>::build_acceleration_structure()
 	{
-		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;
+		for (size_t shape_id = 0; shape_id < index_buffers.size(); shape_id++) {
+			auto& index_buffer = index_buffers[shape_id];
+			auto& vertex_buffer = vertex_buffers[shape_id];
+			size_t index_id = 0;
 			aabb<VB> aabb;
-			while (index < index_buffer->count())
-			{
+			while (index_id < index_buffer->count()) {
 				triangle<VB> triangle(
-						vertex_buffer->item(index_buffer->item(index++)),
-						vertex_buffer->item(index_buffer->item(index++)),
-						vertex_buffer->item(index_buffer->item(index++)));
-				aabb.push_back(triangle);
+						vertex_buffer->item(index_buffer->item(index_id++)),
+						vertex_buffer->item(index_buffer->item(index_id++)),
+						vertex_buffer->item(index_buffer->item(index_id++)));
+				aabb.add_triangle(triangle);
 			}
+			acceleration_structures.push_back(aabb);
 		}
-		acceleration_structures.push_back(aabb);
 	}
 
 	template<typename VB, typename RT>
-	inline void raytracer<VB, RT>::ray_generation(
-			float3 position, float3 direction,
-			float3 right, float3 up, size_t depth, size_t accumulation_num)
+	inline void raytracer<VB, RT>::ray_generation(float3 position, float3 direction,
+												  float3 right, float3 up,
+												  size_t depth,
+												  size_t accumulation_num)
 	{
 
 		float frame_weight = 1.f / static_cast<float>(accumulation_num);
@@ -220,25 +232,23 @@ namespace cg::renderer
 	}
 
 	template<typename VB, typename RT>
-	inline payload raytracer<VB, RT>::trace_ray(
-			const ray& ray, size_t depth, float max_t, float min_t) const
+	inline payload raytracer<VB, RT>::trace_ray(const ray& ray, size_t depth,
+												float max_t, float min_t) const
 	{
-		if (depth == 0) {
+		if (depth == 0)
 			return miss_shader(ray);
-		}
 		depth--;
+
 		payload closest_hit_payload{};
 		closest_hit_payload.t = max_t;
 		const triangle<VB>* closest_triangle = nullptr;
+
 		for (auto& aabb: acceleration_structures) {
-			if (!aabb.aabb_test(ray)) {
+			if (!aabb.aabb_test(ray))
 				continue;
-			}
-			for (auto& triangle: aabb.get_triangles())
-			{
+			for (auto& triangle: aabb.get_triangles()) {
 				payload payload = intersection_shader(triangle, ray);
-				if (payload.t > min_t && payload.t < closest_hit_payload.t)
-				{
+				if (payload.t > min_t && payload.t < closest_hit_payload.t) {
 					closest_hit_payload = payload;
 					closest_triangle = &triangle;
 					if (any_hit_shader)
@@ -257,26 +267,32 @@ namespace cg::renderer
 	}
 
 	template<typename VB, typename RT>
-	inline payload raytracer<VB, RT>::intersection_shader(
-			const triangle<VB>& triangle, const ray& ray) const
+	inline payload
+	raytracer<VB, RT>::intersection_shader(const triangle<VB>& triangle,
+										   const ray& ray) const
 	{
 		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;
+
+		float3 gvec = cross(tvec, triangle.ba);
+		float v = dot(ray.direction, gvec) * inv_det;
 		if (v < 0.f || u + v > 1.f)
 			return payload;
-		payload.t = dot(triangle.ca, qvec) * inv_det;
+
+		payload.t = dot(triangle.ca, gvec) * inv_det;
 		payload.bary = float3{1.f - u - v, u, v};
+
 		return payload;
 	}
 
@@ -287,33 +303,32 @@ namespace cg::renderer
 
 		constexpr int base_x = 2;
 		int index = frame_id + 1;
-		float inv_base = 1.f / base_x;
+		float inv_base = 1.f / static_cast<float>(base_x);
 		float fraction = inv_base;
 		while (index > 0) {
-			result.x += static_cast<float>(index % base_x) * fraction;
+			result.x = (index % base_x) * fraction;
 			index /= base_x;
 			fraction *= inv_base;
 		}
 
 		constexpr int base_y = 3;
 		index = frame_id + 1;
-		inv_base = 1.f / base_x;
+		inv_base = 1.f / static_cast<float>(base_y);
 		fraction = inv_base;
 		while (index > 0) {
-			result.y += static_cast<float>(index % base_y) * fraction;
+			result.y = (index % base_y) * fraction;
 			index /= base_y;
 			fraction *= inv_base;
 		}
 
 		return result - 0.5f;
 	}
 
-
 	template<typename VB>
 	inline void aabb<VB>::add_triangle(const triangle<VB> triangle)
 	{
 		if (triangles.empty()) {
-			aabb_min = aabb_max = triangle.a;
+			aabb_max = aabb_min = triangle.a;
 		}
 
 		triangles.push_back(triangle);
@@ -336,12 +351,12 @@ namespace cg::renderer
 	template<typename VB>
 	inline bool aabb<VB>::aabb_test(const ray& ray) const
 	{
-		float3 inv_ray_dir = 1.f / ray.direction;
-		float3 t0 = (aabb_max - ray.position) * inv_ray_dir;
-		float3 t1 = (aabb_min - ray.position) * inv_ray_dir;
-		float3 t_min = min(t0, t1);
-		float3 t_max = max(t0, t1);
-		return maxelem(t_min) <= maxelem(t_max);
+		float3 inv_dir = 1.f / ray.direction;
+		float3 t0 = (aabb_max - ray.position) * inv_dir;
+		float3 t1 = (aabb_min - ray.position) * inv_dir;
+		float3 tmin = min(t0, t1);
+		float3 tmax = max(t0, t1);
+		return maxelem(tmin) <= minelem(tmax);
 	}
 
 }// namespace cg::renderer