Renderman Fun

I created this crazy looking blobby thing using displacement and surface shading in Renderman. I think it came out kinda neat looking.

Ray Tracer: Tone Reproduction

This week I implemented Ward and Reinhard tone reproduction algorithms into the ray tracer. Below are tracing made with each. For each rendering, I modified the maximum luminance of the algorithm while keeping the device range set at 100cd/m^2

Ward Model

1 cd/m^2

1000 cd/m^2

10000 cd/m^2

Ward Model

I can't really see any differences between the renderings below.

1 cd/m^2

1000 cd/m^2

10000 cd/m^2

Ray Casting (Project Update)

In addition to writing a ray tracer I've also been developing a ray casting program that creates Wolfenstein 3D like graphics by utilizing multi-core CPUs and the GPU texture processing to pipeline collision detection. Below is my first GPU pipelined rendering. Instead of using the traditional libraries for rendering, my engine is specifically optimized for this scenario. The GPU is given two textures as input. Traditionally textures are rasterized image that extend the geographic or shading properties of a 3D mesh. However, my engine utilizes textures entirely different.

The first texture handed to the GPU is the set of rays being cast out into the scene. The second texture is a map of the world into which the rays are being cast. Finally, a third texture, a set of doubles representing where the collisions occurred and how far away from the camera they are. This information is processed to create the final image.

In this style of ray casting, there are a few assumptions that can be made which I optimize for. Ray casting actually takes place in 2D space. All calculations up to the final drawing are 2D math. This means that our map is flat and more importantly, the center of every wall drawn is at the center of the image. I can use simple trigonometric properties to find walls distance from the camera (via the GPU) and then do some more operations to draw this portion of the wall.

Here is my first rendering done this way:

Checkpoint #7

In this checkpoint I implemented refraction and transparency into the rendering. Here is an image of my latest run.

Rendering with reflection and transparency

Checkpoint #5

For this checkpoint I implemented reflection into my ray tracer as well as a psuedo-BRDF functionality where each surface has a new value associated with it which represents the angle between a vector going straight through the center of a right cone and the face. By perturbing the reflection vector within that cone, surface roughness can be simulated as seen on the metal sphere. I used a low count of 5 rays distributed a the jitter b/c my scene is not very colorful and too many rays result in each pixel simply being supersampled. Also, I forgot to post this in the past but I have multiple lights working as well. Note: only the left sphere is reflecting and doing jittered reflections.

Click the images to see them full-size

No Jitter

Jitter .01 Radians

Jitter .1 Radians

Jitter .3 Radians

ALSO LIGHTS

3 colored lights + .3 Radians Jitter

Checkpoint #4

This weeks checkpoint was to implement procedural textures into the ray tracer. As you can see from my last post I have already done this. Any other week, I would have implemented a lot of extras. Unfortunately, my friend Ryan Phillips recently passed away and this week has been rather hectic and emotional for me. And so, to you, my dedicated and numerous readers, I apologize.

Ray Tracer Checkpoint #3

After refactoring a majority of my source code and working extra hard I now have a ray tracer which does proper Phong shading, runs in parallel, use procedural textures and can do reflections. For the purpose of this entry I'm simply focusing on the Phong shading. Below is an updated screenshot of my renderer with Phong shading enabled. The image may look different from the previous entry because I tweaked the image size and the locations of the spheres a bit.

Phong Shaded Rendering