CIS565-Fall-2016 · xueyinw · Oct 29, 2016 · Oct 29, 2016 · Oct 29, 2016 · Oct 29, 2016
diff --git a/README.md b/README.md
@@ -1,20 +1,164 @@
 CUDA Rasterizer
 ===============
+**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 4**
 
-[CLICK ME FOR INSTRUCTION OF THIS PROJECT](./INSTRUCTION.md)
+* Xueyin Wan
+* Tested on: Windows 10 x64, i7-6700K @ 4.00GHz 16GB, GTX 970 4096MB (Personal Desktop)
+* Compiled with Visual Studio 2013 and CUDA 7.5
 
-**University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 4**
+## Project Objective
+Use CUDA to implement a simplified rasterized graphics pipeline, similar to the OpenGL pipeline. 
+
+## My CUDA Rasterizer Features
+### About Graphics Pipeline
+* Vertex shading
+* Primitive assembly with support for triangles read from buffers of index and vertex data
+* Rasterization
+* Fragment shading
+* A depth buffer for storing and depth testing fragments
+* Fragment-to-depth-buffer writing (with atomics for race avoidance)
+
+### Extra Coolness
+* Lambert and Blinn-Phong shading
+* UV texture mapping with bilinear texture filtering 
+* UV texture mapping with perspective correct texture coordinates
+* Support rasterizing Triangles, Lines, Points
+* Super Sampling Anti-Aliasing (SSAA)
+* Correct color interpolation between points on a primitive
+
+## Project Introduction
+As we all know, rasterizeration converts vector graphics into dot matrix graphics. It is quite popular and important in real-time rendering area. Modern 3D rendering APIs like OpenGL, DirectX (Microsoft), Vulkan (Khronos, quite new area) are all implemented related to rasterize techniques. 
+
+Different from ray tracing technique (as my last project shows), there's no concept of shooting rays during the whole procedure.
+The whole graphics pipeline is like this: (Sort by stage order)
+
+![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/readmepipeline.jpg "Graphics Pipeline") 
+
+#### 1. Vertex Assembly
+
+Pull together a vertex from one or more buffers
+
+#### 2. Vertex Shader
+
+Transform incoming vertex position from model to clip coordinates
+
+`World Space ->  View Space -> Clipping Space -> Normalized Device Coordinates (NDC) Space -> Viewport (Screen/Window) Space`
+
+#### 3. Primitive Assembly
+
+A vertex shader processes one vertex.  Primitive asstriangleembly groups vertices forming one primitive, e.g., a, line, etc.
+
+#### 4. Rasterization
+
+Determine what pixels a primitive overlaps
+
+#### 5. Fragment Shader
+
+Shades the fragment by simulating the interaction of light and material.
+Different rendering scheme could be applied here: Blinn-Phong, Lambert, Non-Photorealistic Rendering (NPR), etc.
+
+#### 6. Per-Fragment Tests
+
+Choose one candidate to fill framebuffer!
+Common techniques : Depth test, Scissor test, etc.
+
+#### 7. Blending
+
+Combine fragment color with framebuffer color
+
+#### 8. Framebuffer
+
+Write color to framebuffer, a.k.a tell each pixel its color :)
+
+
+## Showcase My Result
+###Lambert and Blinn-Phong shading
+|  Lambert  | Blinn-Phong shading |
+|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/duck_with_lambert.gif "Lambert Duck") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/duck_with_blinn_phong_1.gif "Blinn Phong Duck") |
+
+###UV texture mapping with bilinear texture filtering
+We could see the apparant better result of Bilinear Texture Filtering since we take into account more texture infomation.
+
+|  Without Bilinear Texture Filtering  | With Bilinear Texture Filtering |
+|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/NoBilinearEnlarged.png "NoBininear") |![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/BilinearEnlarged.png "WithBininear")|
+
+###UV texture mapping with perspective correct texture coordinates
+
+With Perspective Correctness, we figure out the texture coordinates in a more sophisticated way. We interpolate texture coordinates, and then do the perspective divide.
+
+|  Without Perspective Correctness | With Perspective Correctness |
+|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/WithoutPerspectiveCorrectnessCheckerBoard.PNG "WithoutPerspective") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/PerspectiveCorrectnessCheckerBoard.PNG "WithPerspective") |
+
+###Point Representation & Line Representation
+
+|  Point Representation | Line Representation |
+|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/truckpoint.gif "Truck Point") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/LineRepresentation.PNG "Truck Line") |
+
+|  Point Representation | Line Representation |
+|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/cowpoint.gif "Cow Point") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/cowcowcow.gif "Cow Line") |
+
+###Super Sampling Anti-Aliasing (SSAA)
+Divide one pixel into small pixels, then average to get the final color, put it into framebuffer
+
+|  No SSAA | SSAA = 2 | SSAA = 4 |
+|------|------|------|
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/SSAAnoSHOW.PNG "No SSAA") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/SSAA2SHOW.PNG "SSAA 2 * 2") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/SSAA4SHOW.PNG "SSAA 4 * 4") |
+
+###Correct color interpolation between points on a primitive
+
+I use barycentric calculation of each triangle's vertex coordinate v[0], v[1] & v[2]'s color to fill each fragment color.
+
+I use each vertex's normal in view(eye) coordinate system to represent its color in order to visualize.
+
+|![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/normalInterpolate1.gif "Normal Interpolation") 
+
+The two below are I accidently use the first triangle's vertex normal and create an interesting result. Also put here for fun.
+
+| First Triangle Normal Interpolation | First Triangle Normal Interpolation | 
+|------|------|
+| ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/normalinterpolation.gif "First Triangle Normal Interpolation") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/cownormalinterpolation.gif "First Triangle Normal Interpolation") |
+
+
+## Performance Analysis
+
+###Different Stages of rasterizer time arrangement percentage(Compare between Lines, Points and Triangles)
+
+From the picture below, we can see that when we choose triangle as our primitive, the rasterization stage occupies most of time since we do all the fragmentbuffer calculations & filling there, easpecially for the Axis-Aligned Bounding Box(AABB) calculation. In line & point cases, we need to do much less calculations about fragmentbuffer in rasterization stage, render case as a result plays a larger role to fill the framebuffer. 
+![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/StagePerformance.PNG "Stage Perfomance")
+
+
+###Compare between Super-Sampling Anti-Aliasing(SSAA) and No SSAA
+
+Based on CG knowledge, we all know that SSAA is a time-consuming stage. Since we need to open a larger fragment buffer, frame buffer and depth buffer, so the calculations maybe mutiple in order to get an average value then send it to PBO.
+Here the result is based on CesiumMilkTruck.gltf, and my table is based on the time/fps.
+We could see that as SSAA level increases, we get one frame with more time!
+
+![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/SSAAPerformance.PNG "SSAA Comparasion")
+
+
+###Compare between Bilinear, Bilinear Texture Filtering,  Perspective Correctness Texture Filtering
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+Bilinear adds the percentage of the render stage during the whole cuda launch since we need to consider more pixels around to improve correctness(super sampling comes into play again)!
+Perspective Correctness adds the percentage of rasterization, since it contains more interpolation and calculation during the rasterization procedure.
 
-### (TODO: Your README)
+|   | Bilinear Open | Perspective Open | Nothing Opens|
+|------|------|------|------|
+|Rasterization Stage Percentage of GPU(%)| 55.69 | 59.36 | 53.98 |
+|Render Stage Percentage of GPU(%)| 2.06 | 1.5 | 1.76 |
 
-*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.
 
+| Bilinear Open | Perspective Open | 
+|------|------|
+| ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/BilinearShow.PNG "Bilinear Open") | ![alt text](https://github.com/xueyinw/Project4-CUDA-Rasterizer/blob/master/results/PersShow.PNG "Perspective Open") |
 
 ### Credits
 
+* [UPENN CIS-565 GPU Programming : course & recitation slides](https://github.com/CIS565-Fall-2016) by [@Patrick](https://github.com/pjcozzi) [@Shrek](https://github.com/shrekshao) [@Gary](https://github.com/likangning93) 
+* UPENN CIS-561 Advanced Computer Graphics course slides
 * [tinygltfloader](https://github.com/syoyo/tinygltfloader) by [@soyoyo](https://github.com/syoyo)
 * [glTF Sample Models](https://github.com/KhronosGroup/glTF/blob/master/sampleModels/README.md)
diff --git a/gltfs/duck/duck.gltf b/gltfs/duck/duck.gltf
@@ -359,4 +359,4 @@
             "type": 5121
         }
     }
-}
+}
diff --git a/pinkduck.PNG b/pinkduck.PNG
diff --git a/results/BiliearCheckboard.PNG b/results/BiliearCheckboard.PNG
diff --git a/results/Bilinear.PNG b/results/Bilinear.PNG
diff --git a/results/BilinearEnlarged.png b/results/BilinearEnlarged.png
diff --git a/results/BilinearShow.PNG b/results/BilinearShow.PNG
diff --git a/results/LineRepresentation.PNG b/results/LineRepresentation.PNG
diff --git a/results/NoBiliearCheckboard.PNG b/results/NoBiliearCheckboard.PNG
diff --git a/results/NoBilinearEnlarged.png b/results/NoBilinearEnlarged.png
diff --git a/results/Pers.PNG b/results/Pers.PNG
diff --git a/results/PersCor+Blinear.PNG b/results/PersCor+Blinear.PNG
diff --git a/results/PersShow.PNG b/results/PersShow.PNG
diff --git a/results/PerspectiveCorrectnessCheckerBoard.PNG b/results/PerspectiveCorrectnessCheckerBoard.PNG
diff --git a/results/SSAA.PNG b/results/SSAA.PNG
diff --git a/results/SSAA2SHOW.PNG b/results/SSAA2SHOW.PNG
diff --git a/results/SSAA2x2.PNG b/results/SSAA2x2.PNG
diff --git a/results/SSAA4SHOW.PNG b/results/SSAA4SHOW.PNG
diff --git a/results/SSAA4x4.PNG b/results/SSAA4x4.PNG
diff --git a/results/SSAANone.PNG b/results/SSAANone.PNG
diff --git a/results/SSAAPerformance.PNG b/results/SSAAPerformance.PNG
diff --git a/results/SSAA_None.gif b/results/SSAA_None.gif
diff --git a/results/SSAAnoSHOW.PNG b/results/SSAAnoSHOW.PNG
diff --git a/results/StagePerformance.PNG b/results/StagePerformance.PNG
diff --git a/results/WithoutPerspectiveCorrectnessCheckerBoard.PNG b/results/WithoutPerspectiveCorrectnessCheckerBoard.PNG
diff --git a/results/blinnphongduck.PNG b/results/blinnphongduck.PNG
diff --git a/results/blooper1.PNG b/results/blooper1.PNG
diff --git a/results/blooperAntiAnailising.PNG b/results/blooperAntiAnailising.PNG
diff --git a/results/blooperAntiAnailising1.PNG b/results/blooperAntiAnailising1.PNG
diff --git a/results/blooperLineRasterizer.PNG b/results/blooperLineRasterizer.PNG
diff --git a/results/cowInterpolationUsingCustomColorOfVertices.PNG b/results/cowInterpolationUsingCustomColorOfVertices.PNG
diff --git a/results/cowcowcow.gif b/results/cowcowcow.gif
diff --git a/results/cownormalinterpolation.gif b/results/cownormalinterpolation.gif
diff --git a/results/cowpoint.gif b/results/cowpoint.gif
diff --git a/results/duckInterpolationUsingCustomColorOfVertices.PNG b/results/duckInterpolationUsingCustomColorOfVertices.PNG
diff --git a/results/duck_with_blinn_phong.gif b/results/duck_with_blinn_phong.gif
diff --git a/results/duck_with_blinn_phong_1.gif b/results/duck_with_blinn_phong_1.gif
diff --git a/results/duck_with_lambert.gif b/results/duck_with_lambert.gif
diff --git a/results/firstpart_finish_dark.PNG b/results/firstpart_finish_dark.PNG
diff --git a/results/nopersnobi.PNG b/results/nopersnobi.PNG
diff --git a/results/normalInterpolate1.gif b/results/normalInterpolate1.gif
diff --git a/results/normalInterpolate2.gif b/results/normalInterpolate2.gif
diff --git a/results/normalinterpolation.gif b/results/normalinterpolation.gif
diff --git a/results/normalvisualization.PNG b/results/normalvisualization.PNG
diff --git a/results/performDuckAllClose.PNG b/results/performDuckAllClose.PNG
diff --git a/results/performDuckAllClose1.PNG b/results/performDuckAllClose1.PNG
diff --git a/results/pinkduck.PNG b/results/pinkduck.PNG
diff --git a/results/readmepipeline.jpg b/results/readmepipeline.jpg
diff --git a/results/ssaa2.PNG b/results/ssaa2.PNG
diff --git a/results/ssaa4.PNG b/results/ssaa4.PNG
diff --git a/results/ssaaOFF.PNG b/results/ssaaOFF.PNG
diff --git a/results/truckpoint.gif b/results/truckpoint.gif
diff --git a/results/withoutSSAA.PNG b/results/withoutSSAA.PNG
diff --git a/src/main.cpp b/src/main.cpp
@@ -9,6 +9,7 @@
 
 
 #include "main.hpp"
+#include <chrono>
 
 #define STB_IMAGE_IMPLEMENTATION
 #define TINYGLTF_LOADER_IMPLEMENTATION
@@ -65,8 +66,11 @@ int main(int argc, char **argv) {
 void mainLoop() {
     while (!glfwWindowShouldClose(window)) {
         glfwPollEvents();
+		auto startTime = std::chrono::high_resolution_clock::now();
         runCuda();
 
+		cudaDeviceSynchronize(); //CUDA kernel launches are asynchronous, all GPU-related tasks placed in one stream are executed sequentially.
+		auto endTime = std::chrono::high_resolution_clock::now();
         time_t seconds2 = time (NULL);
 
         if (seconds2 - seconds >= 1) {
@@ -75,10 +79,11 @@ void mainLoop() {
             fpstracker = 0;
             seconds = seconds2;
         }
-
-        string title = "CIS565 Rasterizer | " + utilityCore::convertIntToString((int)fps) + " FPS";
+		std::chrono::duration<double, std::milli> eclipsed = endTime - startTime;
+		double delta = eclipsed.count();
+		//printf("Delata time is", delta);
+		string title = "CIS565 Rasterizer | " + utilityCore::convertIntToString((int)fps) + "FPS  |  " + utilityCore::convertIntToString((int)delta) + "ms";
         glfwSetWindowTitle(window, title.c_str());
-
         glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
         glBindTexture(GL_TEXTURE_2D, displayImage);
         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
@@ -97,6 +102,7 @@ void mainLoop() {
 //-------------------------------
 float scale = 1.0f;
 float x_trans = 0.0f, y_trans = 0.0f, z_trans = -10.0f;
+//we could change our angle here
 float x_angle = 0.0f, y_angle = 0.0f;
 void runCuda() {
     // Map OpenGL buffer object for writing from CUDA on a single GPU
-Original file line number
+Diff line change
@@ Expand Up / @@ -359,4 +359,4 @@ @@
                 "type": 5121
             }
         }
-    }
+    }