Path Tracing
© DigiPen 2013
I wrote a path tracer in my final semester at DigiPen. The first step was to create an application that had a camera object and could handle light ray intersections with spheres, boxes, cylinders, and triangles. I added some simple Phong lighting for the first phase. Next, I added reflection, shadows, transmission, and anti-aliasing. At this point, the application was only a ray tracer. It performed one bounce for transmission or reflection. To make a path tracer, I added the ability to recursively bounce rays throughout the scene, collect color values, and terminate recursion after a certain number of bounces based on survival probability. This greatly enhanced the realism of the rendered images. Lastly, I added CSG (constructive solid geometry) and procedural perlin noise textures for fun.
Particle System – Hail and Tornado
© DigiPen 2013
For one of my classes, I created a particle system that is processed on the GPU. Initial particle emitters are sent to the GPU from the CPU. After that, geometry shaders are used to update and draw the particles. The update shader uses a stream out geometry shader. This allows it to add or drop particles as they are passed from one buffer to another. The draw shader takes this information and expands a point into a quad that is billboarded. I used this to create a scene simulating a storm with hail and a tornado. The hail uses gravity and a bounce operation when it hits the ground. A vortex operation is used to produce the tornado.
Tessellation
© DigiPen 2012
I implemented a demo of tessellation using an image of the earth and its associated height map. Photos courtesy of NASA Earth Observatory and the Blue Marble project. Three modes exist in this demo. First is a straight read from the height map to adjust vertices on the triangle mesh. A second method uses bicubic filtering to smooth height differences. The last method implements tessellation with bicubic filtering to add more terrain detail to the scene.
Animation
© DigiPen 2012
I implemented an animation system that included animation blending, path following, speed control, and orientation control. The animation blending for this model is rough because the walk and run cycles are not correctly synchronized. Path following is accomplished using a series of Bezier curves and an arc-length table. Speed control is implemented using an ease-in/ease-out method. The animation speed is also adjusted based on path speed to reduce sliding and skidding effects.
Shadow Mapping
© DigiPen 2012
This is an implementation of shadow mapping using OpenGL and GLSL. I use two render targets. The first pass maps the depth of the scene from the viewpoint of the light. On the second pass, this depth information is used to determine if a pixel is in shadow or not. Lighting calculations are performed if the pixel is not in shadow. Otherwise, only ambient light is used for the pixel color.
Reflection Mapping
© DigiPen 2012
This is an implementation of reflection mapping using OpenGL and GLSL. I used two render targets to capture a dual-paraboloid map. This stores the teapot’s view of the scene and is mapped onto the teapot surface to simulate reflection.
Bump Mapping
© DigiPen 2012
I implemented bump mapping using OpenGL and GLSL. Two textures are used to acquire tile color and tile height. Normals are altered based on the height-map to create the bump illusion.
World Texture
© DigiPen 2012
I implemented texture mapping using two images. One is the world. Another contains information on water versus land, night lighting, and clouds. Specular only reflects off water, night lighting only occurs when no light is present, and clouds are animated around the sphere.
Phong Shading
© DigiPen 2011
This is an implementation of the Phong Shading Algorithm. I developed this program using OpenGL. Before implementing the algorithm, I also wrote various parts of the graphics pipeline in software. These included the viewing transformation, perspective transformation, polygon clipper, scan-conversion algorithm, and lighting algorithm. In addition, this is an example of hierarchical modeling.
Texture Mapping
© DigiPen 2011
Here is an implementation of texture mapping and anti-aliasing in software using OpenGL. I embedded the texture lookup code in the scan-conversion algorithm. Anti-aliasing is accomplished through trilinear blending using mipmaps.