TODO Lab: 1.02 Implement

Author: Mohammed-Nour

src/renderer/rasterizer/rasterizer.h

@@ -4,8 +4,8 @@
 
 #include <functional>
 #include <iostream>
-#include <linalg.h>
 #include <limits>
+#include <linalg.h>
 #include <memory>
 
 
@@ -19,8 +19,8 @@ namespace cg::renderer
 	class rasterizer
 	{
 	public:
-		rasterizer(){};
-		~rasterizer(){};
+		rasterizer() {};
+		~rasterizer() {};
 		void set_render_target(
 				std::shared_ptr<resource<RT>> in_render_target,
 				std::shared_ptr<resource<float>> in_depth_buffer = nullptr);
@@ -46,7 +46,7 @@ namespace cg::renderer
 		size_t width = 1920;
 		size_t height = 1080;
 
-		int edge_function(int2 a, int2 b, int2 c);
+		float edge_function(float2 a, float2 b, float2 c);
 		bool depth_test(float z, size_t x, size_t y);
 	};
 
@@ -55,22 +55,31 @@ namespace cg::renderer
 			std::shared_ptr<resource<RT>> in_render_target,
 			std::shared_ptr<resource<float>> in_depth_buffer)
 	{
-		// TODO Lab: 1.02 Implement `set_render_target`, `set_viewport`, `clear_render_target` methods of `cg::renderer::rasterizer` class
-		// TODO Lab: 1.06 Adjust `set_render_target`, and `clear_render_target` methods of `cg::renderer::rasterizer` class to consume a depth buffer
+		if (in_render_target) {
+			render_target = in_render_target;
+		}
+		if (in_depth_buffer) {
+			depth_buffer = in_depth_buffer;
+		}
 	}
 
 	template<typename VB, typename RT>
 	inline void rasterizer<VB, RT>::set_viewport(size_t in_width, size_t in_height)
 	{
-		// TODO Lab: 1.02 Implement `set_render_target`, `set_viewport`, `clear_render_target` methods of `cg::renderer::rasterizer` class
+		width = in_width;
+		height = in_height;
 	}
 
 	template<typename VB, typename RT>
 	inline void rasterizer<VB, RT>::clear_render_target(
 			const RT& in_clear_value, const float in_depth)
 	{
-		// TODO Lab: 1.02 Implement `set_render_target`, `set_viewport`, `clear_render_target` methods of `cg::renderer::rasterizer` class
-		// TODO Lab: 1.06 Adjust `set_render_target`, and `clear_render_target` methods of `cg::renderer::rasterizer` class to consume a depth buffer
+		for (size_t i = 0; i < depth_buffer->count(); i++) {
+			render_target->item(i) = in_clear_value;
+		}
+		for (size_t i = 0; i < depth_buffer->count(); i++) {
+			depth_buffer->item(i) = in_depth;
+		}
 	}
 
 	template<typename VB, typename RT>
@@ -90,17 +99,72 @@ namespace cg::renderer
 	template<typename VB, typename RT>
 	inline void rasterizer<VB, RT>::draw(size_t num_vertexes, size_t vertex_offset)
 	{
-		// TODO Lab: 1.04 Implement `cg::world::camera` class
-		// TODO Lab: 1.05 Add `Rasterization` and `Pixel shader` stages to `draw` method of `cg::renderer::rasterizer`
-		// TODO Lab: 1.06 Add `Depth test` stage to `draw` method of `cg::renderer::rasterizer`
+		size_t vertex_id = vertex_offset;
+		while (vertex_id < vertex_offset + num_vertexes) {
+			std::vector<VB> vertices(3);
+			vertices[0] = vertex_buffer->item(index_buffer->item(vertex_id++));
+			vertices[1] = vertex_buffer->item(index_buffer->item(vertex_id++));
+			vertices[2] = vertex_buffer->item(index_buffer->item(vertex_id++));
+
+			for (auto& vertex: vertices) {
+				float4 coords{vertex.x, vertex.y, vertex.z, 1.f};
+				auto processed_vertex = vertex_shader(coords, vertex);
+
+				vertex.x = processed_vertex.first.x / processed_vertex.first.w;
+				vertex.y = processed_vertex.first.y / processed_vertex.first.w;
+				vertex.z = processed_vertex.first.z / processed_vertex.first.w;
+
+				vertex.x = (vertex.x + 1.f) * width / 2.f;
+				vertex.y = (-vertex.y + 1.f) * height / 2.f;
+			}
+			float2 vertex_a = float2{vertices[0].x, vertices[0].y};
+			float2 vertex_b = float2{vertices[1].x, vertices[1].y};
+			float2 vertex_c = float2{vertices[2].x, vertices[2].y};
+
+			float2 min_vertex = min(vertex_a, min(vertex_b, vertex_c));
+			float2 bounding_box_begin = round(clamp(
+					min_vertex, float2{0.f, 0.f},
+					float2{static_cast<float>(width - 1), static_cast<float>(height - 1)}));
+
+			float2 max_vertex = max(vertex_a, max(vertex_b, vertex_c));
+			float2 bounding_box_end = round(clamp(
+					max_vertex, float2{0.f, 0.f},
+					float2{static_cast<float>(width - 1), static_cast<float>(height - 1)}));
+
+			float edge = edge_function(vertex_a, vertex_b, vertex_c);
+
+			for (float x = bounding_box_begin.x; x <= bounding_box_end.x; x += 1.f) {
+				for (float y = bounding_box_begin.y; y <= bounding_box_end.y; y += 1.f) {
+					float2 point{x, y};
+					float edge0 = edge_function(vertex_a, vertex_b, point);
+					float edge1 = edge_function(vertex_b, vertex_c, point);
+					float edge2 = edge_function(vertex_c, vertex_a, point);
+					if (edge0 >= 0.f && edge1 >= 0.f && edge2 >= 0.f) {
+						size_t u_x = static_cast<float>(x);
+						size_t u_y = static_cast<float>(y);
+
+						float u = edge1 / edge;
+						float v = edge2 / edge;
+						float w = edge0 / edge;
+
+						float z = u * vertices[0].z + v * vertices[1].z + w * vertices[2].z;
+
+						if (depth_test(z, u_x, u_y)) {
+							auto pixel_result = pixel_shader(vertices[0], 0);
+							render_target->item(u_x, u_y) = RT::from_color(pixel_result);
+							depth_buffer->item(u_x, u_y) = z;
+						}
+					}
+				}
+			}
+		}
 	}
 
 	template<typename VB, typename RT>
-	inline int
-	rasterizer<VB, RT>::edge_function(int2 a, int2 b, int2 c)
+	inline float
+	rasterizer<VB, RT>::edge_function(float2 a, float2 b, float2 c)
 	{
-		// TODO Lab: 1.05 Implement `cg::renderer::rasterizer::edge_function` method
-		return 0;
+		return (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x);
 	}
 
 	template<typename VB, typename RT>

src/renderer/rasterizer/rasterizer_renderer.cpp

@@ -5,17 +5,66 @@
 
 void cg::renderer::rasterization_renderer::init()
 {
-	// TODO Lab: 1.02 Implement image clearing & saving in `cg::renderer::rasterization_renderer` class
-	// TODO Lab: 1.03 Adjust `cg::renderer::rasterization_renderer` class to consume `cg::world::model`
-	// TODO Lab: 1.04 Setup an instance of camera `cg::world::camera` class in `cg::renderer::rasterization_renderer`
-	// TODO Lab: 1.06 Add depth buffer in `cg::renderer::rasterization_renderer`
+	rasterizer = std::make_shared<cg::renderer::rasterizer<cg::vertex, cg::unsigned_color>>();	
+	rasterizer->set_viewport(settings->width, settings->height);
+	render_target = std::make_shared<cg::resource<cg::unsigned_color>>(
+			settings->width, settings->height);
+	rasterizer->set_render_target(render_target);
+	model = std::make_shared<cg::world::model>();
+	model->load_obj(settings->model_path);
+	camera = std::make_shared<cg::world::camera>();
+	camera->set_height(static_cast<float>(settings->height));
+	camera->set_width(static_cast<float>(settings->width));
+	camera->set_position(float3{
+			settings->camera_position[0],
+			settings->camera_position[1],
+			settings->camera_position[2]
+	});
+	camera->set_theta(settings->camera_theta);
+	camera->set_phi(settings->camera_phi);
+	camera->set_angle_of_view(settings->camera_angle_of_view);
+	camera->set_z_near(settings->camera_z_near);
+	camera->set_z_far(settings->camera_z_far);
+
+	depth_buffer = std::make_shared<cg::resource<float>>(settings->width, settings->height);
+
+	rasterizer->set_render_target(render_target, depth_buffer);
 }
 void cg::renderer::rasterization_renderer::render()
 {
-	// TODO Lab: 1.02 Implement image clearing & saving in `cg::renderer::rasterization_renderer` class
-	// TODO Lab: 1.04 Implement `vertex_shader` lambda for the instance of `cg::renderer::rasterizer`
-	// TODO Lab: 1.05 Implement `pixel_shader` lambda for the instance of `cg::renderer::rasterizer`
-	// TODO Lab: 1.03 Adjust `cg::renderer::rasterization_renderer` class to consume `cg::world::model`
+float4x4 matrix = mul(
+			camera->get_projection_matrix(),
+			camera->get_view_matrix(),
+			model->get_world_matrix()
+			);
+	rasterizer->vertex_shader = [&](float4 vertex, cg::vertex data){
+		auto processed = mul(matrix, vertex);
+		return std::make_pair(processed, data);
+	};
+	rasterizer->pixel_shader = [](cg::vertex data, float z){
+		return cg::color{
+				data.ambient_r,
+				data.ambient_g,
+				data.ambient_b};
+	};
+
+	auto start = std::chrono::high_resolution_clock::now();
+	rasterizer->clear_render_target({0,0,0});
+	auto stop = std::chrono::high_resolution_clock::now();
+	std::chrono::duration<float, std::milli> clear_duration = stop-start;
+	std::cout<<"Clearing took "<<clear_duration.count()<<"ms\n";
+
+	start = std::chrono::high_resolution_clock::now();
+	for(size_t shape_id=0; shape_id<model->get_index_buffers().size(); shape_id++){
+		rasterizer->set_vertex_buffer(model->get_vertex_buffers()[shape_id]);
+		rasterizer->set_index_buffer(model->get_index_buffers()[shape_id]);
+		rasterizer->draw(model->get_index_buffers()[shape_id]->count(), 0);
+	}
+	stop = std::chrono::high_resolution_clock::now();
+	std::chrono::duration<float, std::milli> rendering_duration = stop-start;
+	std::cout<<"Rendering took "<<rendering_duration.count()<<"ms\n";
+
+	utils::save_resource(*render_target, settings->result_path);
 }
 
 void cg::renderer::rasterization_renderer::destroy() {}

src/resource.h

@@ -36,12 +36,14 @@ namespace cg
 	template<typename T>
 	inline resource<T>::resource(size_t size)
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
+		data.resize(size);
+		stride = 0;
 	}
 	template<typename T>
 	inline resource<T>::resource(size_t x_size, size_t y_size)
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
+		data.resize(x_size * y_size);
+		stride = x_size;
 	}
 	template<typename T>
 	inline resource<T>::~resource()
@@ -50,52 +52,44 @@ namespace cg
 	template<typename T>
 	inline const T* resource<T>::get_data()
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return nullptr;
+		return data.data();
 	}
 	template<typename T>
 	inline T& resource<T>::item(size_t item)
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return T();
+		return data.at(item);
 	}
 	template<typename T>
 	inline T& resource<T>::item(size_t x, size_t y)
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return T();
+		return data.at(stride*y + x);
 	}
 	template<typename T>
 	inline size_t resource<T>::size_bytes() const
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return 0;
+		return data.size() * item_size;
 	}
 	template<typename T>
 	inline size_t resource<T>::count() const
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return 0;
+		return data.size();
 	}
 
 	template<typename T>
 	inline size_t resource<T>::get_stride() const
 	{
-		// TODO Lab: 1.02 Implement `cg::resource` class
-		return 0;
+		return stride;
 	}
 
 	struct color
 	{
 		static color from_float3(const float3& in)
 		{
-			// TODO Lab: 1.02 Implement `cg::color` and `cg::unsigned_color` structs
-			return color{};
+			return color{in.x, in.y, in.z};
 		};
 		float3 to_float3() const
 		{
-			// TODO Lab: 1.02 Implement `cg::color` and `cg::unsigned_color` structs
-			return float3{};
+			return float3{r,g,b};
 		}
 		float r;
 		float g;
@@ -106,18 +100,28 @@ namespace cg
 	{
 		static unsigned_color from_color(const color& color)
 		{
-			// TODO Lab: 1.02 Implement `cg::color` and `cg::unsigned_color` structs
-			return unsigned_color{};
+			return unsigned_color{
+					static_cast<uint8_t>(std::clamp(color.r*255.f,0.f,255.f)),
+					static_cast<uint8_t>(std::clamp(color.g*255.f,0.f,255.f)),
+					static_cast<uint8_t>(std::clamp(color.b*255.f,0.f,255.f)),
+			};
 		};
 		static unsigned_color from_float3(const float3& color)
 		{
-			// TODO Lab: 1.02 Implement `cg::color` and `cg::unsigned_color` structs
-			return unsigned_color{};
+			float3 clamped = clamp(255.f * color, 0.f, 255.f);
+			return unsigned_color{
+					static_cast<uint8_t>(clamped.x),
+					static_cast<uint8_t>(clamped.y),
+					static_cast<uint8_t>(clamped.z),
+			};
 		};
 		float3 to_float3() const
 		{
-			// TODO Lab: 1.02 Implement `cg::color` and `cg::unsigned_color` structs
-			return float3{};
+			return float3{
+					static_cast<float>(r),
+					static_cast<float>(g),
+					static_cast<float>(b),
+			}/255.f;
 		};
 		uint8_t r;
 		uint8_t g;
@@ -127,7 +131,23 @@ namespace cg
 
 	struct vertex
 	{
-		// TODO Lab: 1.03 Implement `cg::vertex` struct
+		float x;
+		float y;
+		float z;
+		float nx;
+		float ny;
+		float nz;
+		float u;
+		float v;
+		float ambient_r;
+		float ambient_g;
+		float ambient_b;
+		float diffuse_r;
+		float diffuse_g;
+		float diffuse_b;
+		float emissive_r;
+		float emissive_g;
+		float emissive_b;
 	};
 
 }// namespace cg