CIS565-Fall-2017 · GUOYI1 · Oct 17, 2017 · Oct 17, 2017 · Oct 18, 2017 · Oct 18, 2017
diff --git a/README.md b/README.md
@@ -3,16 +3,128 @@ CUDA Rasterizer
 
 [CLICK ME FOR INSTRUCTION OF THIS PROJECT](./INSTRUCTION.md)
 
-**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 4**
+* Yi Guo
+* Tested on:  Windows 8.1, Intel(R) Core(TM)i5-4200M CPU @ 2.50GHz 8GB, NVIDIA GeForce 840M (Personal Notebook)
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+### Description
+
+This is a rasterizer on GPU. The basic pipeline of vertex shader, primitive assembly, rasterization, fragment shader and frame buffer are implemented. Here are the images and performance analysis of the project.
 
-### (TODO: Your README)
+### ScreenShot
 
-*DO NOT* leave the README to the last minute! It is a crucial part of the
-project, and we will not be able to grade you without a good README.
+#### Blinning rasterization result
 
+I slight adjust the blinning parameter to make the material some how metallic.
+<table class="image">
+<tr>
+	<td>duck.gltf (Blinn-Phong)</td>
+	<td>cow.gltf (Blinn-Phong)</td>
+	<td>CeisumMilkTruck.gltf (Blinn-Phong)</td>
+</tr>
+<tr>
+	<td><img src="renders/duck.gif"/></td>
+	<td><img src="renders/cow.gif"/></td>
+	<td><img src="renders/CesiumMilkTruck.gif"/></td>
+</tr>
+</table>
+
+
+Here are the normal debug mode
+<table class="image">
+<tr>
+	<td>duckNormal.gltf </td>
+	<td>cowNormal.gltf</td>
+	<td>CeisumMilkTruckNormal.gltf</td>
+</tr>
+<tr>
+	<td><img src="renders/duckNormal.gif"/></td>
+	<td><img src="renders/cowNormal.gif"/></td>
+	<td><img src="renders/CesiumMilkTruckNormal.gif"/></td>
+</tr>
+</table>
+
+## Performance Analysis
+
+I use the cuda timer to record the time of each process of the rasterization. Here are the graphs.
+
+![](./renders/TimeCost1.png)
+
+From the graph above, we can notice that the rasterization system spends most time on rasterization and fragment shading. The time cost of vertex shading and primitive assembly is related to the number of triangles of the primitive. However, it is not fair to compare the time cost of rasterization and fragment shading of different models based on the number of triangles they have. Since for the rasterization process, each thread renders a single triangle, so the changes on the number of triangles may not cause great difference on the time cost. What really makes a difference here is the time that each thread spends on rendering a single triangle. The graph below can be a good argument.
+
+![](./renders/TimeCost2.png)
+
+The graph above shows the time cost of a singel model(here I use the CeisumMilkTruckNormal.gltf) with different z values. The z values here mean the distance between the model and camera. As it shows, the time cost of rasterization and fragment shading will increase dramaticlly when the model get closer and closer to the camera. The reason is when the distance between camera and model decreases, each triangle in the primitive will take up more grids on the screen than before and in each thread we have to scan a larger range to render a triangle. 
+
+There are some better solutions for rasterizing a triangle. For each triangle, instead of scanning all the pixels in the bounding box, we can computer the intersection points of each row and triangle's sides and only render the pixel between 2 intersection points. I may implement this algorithm in the future to optimize the rasterization process.
+
+### Extra features
+
+#### Backface Culling
+
+I implment the Backface Culling for the rasterization system. Here is the comparison for the efficiency.
+
+![](./renders/BackFace_Culling_Plot.png)
+
+As the graph shows, backface culling may slightly increase the overall efficiency. BackFace culling fliters out the triangles we cannot see, but as we discussed above, the number of triangles is not the main factor of the time cost, thus it cannot cause great difference on the oveall time cost.
+
+#### SSAA(Super Sample Anti-Aliasing)
+
+Supersampling is used to remove aliasing (jagged and pixelated edges). It is achived by rendering the image at a higher resolution than the one being displayed, then shrinking it to the desired size, using the extra pixels for calculation. The color of a pixel in the desired size image equals to the average color values of the corresponding pixels in the higher resolution image. Since we render a image with higher resolution, the rasterize process will be slower.
+
+<table class="image">
+<tr>
+	<td>SSAA=1.gltf </td>
+	<td>SSAA=2.gltf</td>
+	<td>SSAA=4.gltf</td>
+</tr>
+<tr>
+	<td><img src="renders/SSAA1.png"/></td>
+	<td><img src="renders/SSAA2.png"/></td>
+	<td><img src="renders/SSAA4.png"/></td>
+</tr>
+</table>
+
+#### Perspective Correction
+
+<table class="image">
+<tr>
+	<td>checkboard NoPerspective</td>
+	<td>checkboard Perspective</td>
+</tr>
+<tr>
+	<td><img src="renders/checkboardNoPerspective.gif"/></td>
+	<td><img src="renders/checkboardPerspective.gif"/></td>
+</tr>
+</table>
+
+#### Bilinear Interpolation
+
+<table class="image">
+<tr>
+	<td>No Bilinear Interpolation</td>
+	<td>Bilinear Interpolation</td>
+</tr>
+<tr>
+	<td><img src="renders/Nobilinear.png"/></td>
+	<td><img src="renders/Bilinear.png"/></td>
+</tr>
+</table>
+
+#### Different Render Mode(triangle, line ,point)
+
+For the line rendering, I use the [Bresenham algorithm](https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm)
+<table class="image">
+<tr>
+	<td>duck.gltf (Blinn-Phong)</td>
+	<td>cow.gltf (Blinn-Phong)</td>
+	<td>CeisumMilkTruck.gltf (Blinn-Phong)</td>
+</tr>
+<tr>
+	<td><img src="renders/duckDifferentMode.gif"/></td>
+	<td><img src="renders/cowDifferentMode.gif"/></td>
+	<td><img src="renders/CesiumMilkTruckDifferentMode.gif"/></td>
+</tr>
+</table>
 
 ### Credits
 

diff --git a/renders/BackFace_Culling_Plot.png b/renders/BackFace_Culling_Plot.png
diff --git a/renders/Bilinear.png b/renders/Bilinear.png
diff --git a/renders/CesiumMilkTruck.gif b/renders/CesiumMilkTruck.gif
diff --git a/renders/CesiumMilkTruckDifferentMode.gif b/renders/CesiumMilkTruckDifferentMode.gif
diff --git a/renders/CesiumMilkTruckNormal.gif b/renders/CesiumMilkTruckNormal.gif
diff --git a/renders/Nobilinear.png b/renders/Nobilinear.png
diff --git a/renders/SSAA1.png b/renders/SSAA1.png
diff --git a/renders/SSAA2.png b/renders/SSAA2.png
diff --git a/renders/SSAA4.png b/renders/SSAA4.png
diff --git a/renders/TimeCost1.png b/renders/TimeCost1.png
diff --git a/renders/TimeCost2.png b/renders/TimeCost2.png
diff --git a/renders/checkboardNoPerspective.gif b/renders/checkboardNoPerspective.gif
diff --git a/renders/checkboardPerspective.gif b/renders/checkboardPerspective.gif
diff --git a/renders/cow.gif b/renders/cow.gif
diff --git a/renders/cowDifferentMode.gif b/renders/cowDifferentMode.gif
diff --git a/renders/cowLine.gif b/renders/cowLine.gif
diff --git a/renders/cowNormal.gif b/renders/cowNormal.gif
diff --git a/renders/duck.gif b/renders/duck.gif
diff --git a/renders/duckDifferentMode.gif b/renders/duckDifferentMode.gif
diff --git a/renders/duckNormal.gif b/renders/duckNormal.gif
diff --git a/src/main.cpp b/src/main.cpp
@@ -97,8 +97,11 @@ void mainLoop() {
 //---------RUNTIME STUFF---------
 //-------------------------------
 float scale = 1.0f;
-float x_trans = 0.0f, y_trans = 0.0f, z_trans = -10.0f;
+float x_trans = 0.0f, y_trans = -0.5f, z_trans = -6.0f;
 float x_angle = 0.0f, y_angle = 0.0f;
+float timecount[5] = { 0.f,0.f,0.f,0.f,0.f };
+int loop = 0;
+int renderMode = 0;//0: Triangle, 1: Line: 2: Point
 void runCuda() {
     // Map OpenGL buffer object for writing from CUDA on a single GPU
     // No data is moved (Win & Linux). When mapped to CUDA, OpenGL should not use this buffer
@@ -120,11 +123,27 @@ void runCuda() {
 	glm::mat4 MVP = P * MV;
 
     cudaGLMapBufferObject((void **)&dptr, pbo);
-	rasterize(dptr, MVP, MV, MV_normal);
+	rasterize(dptr, MVP, MV, MV_normal,renderMode,timecount);
     cudaGLUnmapBufferObject(pbo);
 
     frame++;
     fpstracker++;
+	//y_angle += 0.01f;
+	/*loop++;
+	if (loop == 60) {
+		FILE *fp = fopen("time.txt", "a+");
+		float total = 0;
+		for (int i = 0; i < 5; i++) {
+			fprintf(fp, "%f	", timecount[i]);
+			total += timecount[i];
+		}
+		fprintf(fp, "%f	", total);
+
+		fprintf(fp, "\n");
+		fclose(fp);
+		printf("DONE\n");
+		exit(0);
+	}*/
 }
 
 //-------------------------------
@@ -328,6 +347,10 @@ void keyCallback(GLFWwindow *window, int key, int scancode, int action, int mods
     if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
         glfwSetWindowShouldClose(window, GL_TRUE);
     }
+	else if (key == GLFW_KEY_T && action==GLFW_RELEASE) {
+		renderMode++;
+		if (renderMode > 2) renderMode = 0;
+	}
 }
 
 //----------------------------
@@ -395,6 +418,6 @@ void mouseMotionCallback(GLFWwindow* window, double xpos, double ypos)
 
 void mouseWheelCallback(GLFWwindow* window, double xoffset, double yoffset)
 {
-	const double s = 1.0;	// sensitivity
+	const double s = 0.2;	// sensitivity
 	z_trans += (float)(s * yoffset);
 }