Project 4: Kaixiang Miao

README.md

@@ -1,18 +1,104 @@
 CUDA Rasterizer
 ===============
 
-[CLICK ME FOR INSTRUCTION OF THIS PROJECT](./INSTRUCTION.md)
-
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 4**
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Kaixiang Miao
+* Tested on: Windows 7, i7-3630QM @ 2.40GHz 8GB, GTX 660M 2GB (Lenovo Y580 laptop, personal computer)
+
+### Screenshot
+
+----------------
+
+#### Perspective-correct Color Interpolation
+<table class="image">
+<tr>
+	<td>duck.gltf (Blinn-Phong)</td>
+	<td>cow.gltf (Blinn-Phong)</td>
+	<td>flower.gltf (Lambert)</td>
+</tr>
+<tr>
+	<td><img src="img/20.gif"/></td>
+	<td><img src="img/10.gif"/></td>
+	<td><img src="img/3.gif"/></td>
+</tr>
+</table>
+
+#### Bilinear Texture Mapping
+<table class="image">
+<tr>
+	<td>duck.gltf</td>
+	<td>CesiumMilkTruck.gltf</td>
+</tr>
+<tr>
+	<td><img src="img/51.gif"/></td>
+	<td><img src="img/61.gif"/></td>
+</tr>
+</table>
+
+#### Perspective-correct Texture Mapping
+<table class="image">
+<tr>
+	<td>Bad Mapping</td>
+	<td>Nice Mapping</td>
+</tr>
+<tr>
+	<td><img src="img/8.jpg"/></td>
+	<td><img src="img/81.jpg"/></td>
+</tr>
+</table>
+
+#### Bilinear Texture Mapping
+<table class="image">
+<tr>
+	<td>Bilinear Off</td>
+	<td>Bilinear On</td>
+</tr>
+<tr>
+	<td><img src="img/tex.jpg"/></td>
+	<td><img src="img/bitex.jpg"/></td>
+</tr>
+</table>
+
+#### Backface Culling
+<table class="image">
+<tr>
+	<td>Backface Culling Off</td>
+	<td>Backface Culling On</td>
+</tr>
+<tr>
+	<td><img src="img/71.gif"/></td>
+	<td><img src="img/7.gif"/></td>
+</tr>
+</table>
+
+###Performance Analysis
+
+#### Kernel Time of Different Stages
+
+The kernel time of different stages of different .gltf files is shown as below. However, in spite of the fixed distance from the object, the objects have different scale factors, which make the stacked chart below less meanningful.
+
+![](./img/Kernel.jpg)
+
+Instead of comparing different objects, different distance from the object `duck.gltf` to the opsition of the camera is applied.
+
+![](./img/Duck.jpg)
+
+As the camera getting closer and closer, the rasterizer stage takes up more time. It illustrates that as the object taking up more and more area of the screen, the workload of the rasterizer becomes heavier because of the large area of primitives and more pixels needed to be filled by scanline.
+
+The following graph shows the duration of the **fragment shader** of `duck.gltf`. Although the value is increasing, the ratio of this stage is decreasing, because of the steeper increase of the duration of the **rasterzier stage**. Besides, the duration of the **vertex shader**, the **primitive assembly** and the **backface culling** does not vary much because the number of vertices, primitives and backfaces is not relevant to the distance.
+
+![](./img/DuckFrag.jpg)
+
+#### Backface Culling
+
+Backface Culling reduce lots of execution time of both fragment shader and the rasterizer stage.
 
-### (TODO: Your README)
+![](./img/backface.jpg)
 
-*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.
+With no backface culling, the stacked chart appears different from the one shown at the beginning. The rasterizer stage takes up most duration because the rasterizer is shading numerous redundant primitives.
 
+![](./img/nobackface.jpg)
 
 ### Credits
 

src/main.cpp

@@ -96,17 +96,19 @@ void mainLoop() {
 //---------RUNTIME STUFF---------
 //-------------------------------
 float scale = 1.0f;
-float x_trans = 0.0f, y_trans = 0.0f, z_trans = -10.0f;
-float x_angle = 0.0f, y_angle = 0.0f;
+float x_trans = 0.0f, y_trans = 0.0f, z_trans = -5.0f;
+float x_angle = 0.0f, y_angle = 0.0f;bool flag = false;int c = 0;
+//float x_trans = 0.0f, y_trans = 0.0f, z_trans = -3.0f;
+//float x_angle = 0.63f, y_angle = 3.19f;bool flag = false;int c = 0;
 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
     dptr = NULL;
-
-	glm::mat4 P = glm::frustum<float>(-scale * ((float)width) / ((float)height),
-		scale * ((float)width / (float)height),
-		-scale, scale, 1.0, 1000.0);
-
+	//y_angle += 0.01f;
+	//glm::mat4 P = glm::frustum<float>(-scale * ((float)width) / ((float)height),
+	//	scale * ((float)width / (float)height),
+	//	-scale, scale, 1.0, 1000.0);
+	glm::mat4 P = glm::perspective(3.14159f / 3, 1.0f, .1f, 1000.0f);
 	glm::mat4 V = glm::mat4(1.0f);
 
 	glm::mat4 M =
@@ -117,9 +119,16 @@ void runCuda() {
 	glm::mat3 MV_normal = glm::transpose(glm::inverse(glm::mat3(V) * glm::mat3(M)));
 	glm::mat4 MV = V * M;
 	glm::mat4 MVP = P * MV;
-
+	//printf("camera:%f %f %f\n", x_angle, y_angle, z_trans);
     cudaGLMapBufferObject((void **)&dptr, pbo);
-	rasterize(dptr, MVP, MV, MV_normal);
+
+	//if (!flag)
+	{
+		rasterize(dptr, MVP, MV, MV_normal, c);
+		c++;
+		flag = true;
+	}
+
     cudaGLUnmapBufferObject(pbo);
 
     frame++;