Progressive Lightcuts for GPU (Phd students, Universität des Saarlandes / Intel):
[Lightcuts] http://www.graphics.cornell.edu/~bjw/lightcutSigTalk05.pdf
[Progressive lightcuts] http://dl.acm.org/citation.cfm?id=2343047

• Light cuts adaptively approximate complex global illumination through clusters of virtual point lights (VPLs): area light, sky light, indirect illumination, etc. Steps: convert illumination to VPLs, build a light tree, for each eye ray choose a cut that best approximates the illumination. (optimization to path tracing?)
• This work tries to “group” the contribution of lights that don’t contribute much to the final scene, e.g. are far away. (progressively averaging the lightcut images?)
• There’s issues with VPL’s too near the surface that cause spikes in the reflection intensity (very bright aliasing), they change the attenuation formula to clamp the intensity near the surface.

SGRT: Scalable Mobile GPU Architecture Based on Ray Tracing (Samsung)
http://dl.acm.org/citation.cfm?id=2343048

• Presented an architecture for real-time raytracing (based on recent papers from Samsung).
• Fixed-function hardware for traversal and intersection (T&I engine [Nah et al. 2011]) handles bounding volume hierarchy (split bounding volume, surface area heuristic, etc), ray-AABB intersection, and supports dynamic scenes.
• Samsung Reconfigurable Processor for shading [Lee et al. 2011], supports shaders written in C-like language with branches, allowing recursive ray-tracing.
• Uses Samsung multiplatform kernel and adaptive restart trail.

Point-Based Global Illumination Directional Importance Mapping (Dreamworks)

• Raytracing was not used at all in Madagascar 3, their solution was to use many point lights (convert area lights to points?) and they baked them (all of them?) to environment maps (or HDR env maps).
• They presented an importance sampling scheme to increase quality without paying the cost of handling all lights. The result video showed nice improvements on shadows, they mentioned quality similar to 4 hours of rendering in 1.5 hours with importance mapping.
• Showed some videos of things that would be difficult to render without ray-tracing (character walking on energy cables with energy rays, motorbike shadows).

Ill-Loom-inating Handmade Fabric in “Brave” (Pixar)

• Started presenting some early work they did to handle fabric in brave, as previous techniques were not good enough handling “frayed edges”, “holes”, etc.
• His early work looked a lot like Relief Mapping, he showed demos of animation fabric with small deformations, stretching, etc. It looked pretty good. They dropped this technique as it was difficult to apply to arbitrary surfaces due to silhouette issues (again, same flaws as Relief Mapping that were only addressed for quadric surfaces).
• Final work was based on render-man shaders that were used to generate/tessellate the surface on-the-fly.

Decoupling Algorithms From Schedules for Easy Optimization of Image-Processing Pipelines (MIT, Adobe, Stanford)
www.halide-lang.org

• Decouples algorithms from schedules, allowing you to easily code and try many different scheduling approaches. New language called Halide which provides a compiler to generate code for many different architectures.
• The scheduling is done mixing some of the available “modes”, 1 to 1 (fusion), 1 to N or N to 1. Also, the output must be in a grid. Other data structures, such as lists, trees, etc, are not supported yet.
• It’s also difficult to write custom functions, such as a Fourier transform, using the Halide language. To handle that they would enable the “import” of functions from external libraries (apparently not currently possible)
• Results were very good and they improved running time of a few algorithms (e.g. “Local laplacian filter”), and they did better than Intel tools (Intel TBB?)

Adaptive Manifolds for Real-Time High-Dimensional Filtering (UFRGS)

• They apply high-dimensional manifold filtering over many rendered images, for example, scenes rendered with path tracing.
• They talk about their algorithm being “aware of edges” and “temporal coherent”, so it might be possible to use for AA as well. The only issue is that for some of the results (in a video for example) they also use future frames.
• Linear cost: 70ms for a 10MP image, and 7ms for a 1MP image (still too much for real time).

High-Quality Image Deblurring With Panchromatic Pixels (Kodak)

• They talked about generation blur kernels, gathering it from images and handling invalid kernels. My understanding is that their algorithm uses two images from the same scene captured with different levels of exposure, and use it to calculate the blur kernel.
• They also said something about using infrared sensors not sure what. They also show that their algorithm fails when there’s too much blur.

Practical temporal Consistency for Image-Based Graphics Application (Disney Zurich)

• Talked about optical flow, temporal anti-aliasing and motion aware filtering. They compared their result with MPEG and show that it is better for their scenes.

From a Calm Puddle to a Stormy Ocean: Rendering Water in Uncharted (NaughtyDog)
http://dl.acm.org/citation.cfm?id=2343050

• They show the water simulation system created for Uncharted, which appears to be divided in a few parts to handle waves, ocean, etc.
• From what I get they can use Gerstner Waves or Point Particles to add displacement/deformation and simulate ripples and waves. They can control how much stretching is going-on.
• In the in-game indoor cinematics the water has so many particles on top of it that it looks much more impressive than the water itself.
• Many objects in the ocean are not attached to anything and move according to the water. For that they integrate all forces applied over each object (pretty cool).

What if the Earth Was Flat: The Globe UI System in SSX (EA)
http://dl.acm.org/citation.cfm?id=2343051

• This talk covered the development of the UI in the SSX game. I wasn’t really impressed by it and the problems they solved look quite old to me.
• Relaxed Cone Relief Mapping was used to render all the details in their globe, as I remember it, this accelerates the per-pixel ray-tracing by using a safe-cone (don’t intersect the geometry) and a relaxed code (intersects the geometry only once). The silhouettes in the zoom-in image look better than I expected.
• They shown how they fixed issues using perspective interpolation instead of just linear interpolation on the sphere…

Adaptive Level-of-Detail System for End of Nations (Petroglyph Games)
http://dl.acm.org/citation.cfm?id=2343052

• They presented a lod system that handles LOD in many different subsystems and has a nice level of scalability.
• Their LOD system would handle lod on meshes, materials, effects, screen resolution (need to confirm?), etc. They have an in-game menu where they would force an specific render time and the game would scale details to make it real-time again.
• The results were good, they would remove most of the particles (in a smart way), remove effects, and even do things like rendering a different subset of all objects per frame. Those changes were also fast enough that they wouldn’t introduce problems while “teleporting” to other maps of the map that were running smoothly.

Screen Space Decals in Warhammer 40,000: Space Marine (Relic)
http://dl.acm.org/citation.cfm?id=2343053

• They presented an algorithm to render decals by projecting a 3D box on top of their G-Buffer and rendering the decals in screen space.
• There were some issues presented when the projected box intersects the near clipping plane of the camera, or then the normal of the surface changes too heavily (corners) under the projected box.
• Final results were pretty impressive were this system was used to add a lot of details to many parts of the game.

Being curious about the character’s polygon count and texture maps, I decided to get some information about the game using PIX (Performance Investigator for DirectX), a tool that comes with the DirectX SDK. Using PIX, I ran the benchmark and when an interesting image appeared (shown in the screenshot below) I captured a Direct 3D frame, which contains all the API calls, data buffers (including vertices, textures and render targets) and shaders.

First I would like to say that every time I captured a Direct3D frame it came with thousands of API calls, making it difficult to find out where the interesting information really was. Also, I believe that because it is a benchmark the game is doing some repeated/unnecessary work. The following picture shows some of the rendering calls captured with PIX.

Next, I would like to investigate the rendering of the character who appears in the upper right part of the first picture. This character is draw inside the MultiScreenManager::Draw method as a set of parts/chunks. Note that in the previous picture the MultiScreenManager::Draw call was not expanded because it has lots of calls inside. The table below shows all the rendered parts/chunks of the investigated character.

As you can see, this character has almost 6K polygons divided into 10 chunks. All the chunks were drawn using an indexed triangle list with three DXT1 textures for diffuse color, normal map and specular map (or a mask, in some cases). I will not post any picture of the character textures but his face, for example, has three 128×256 textures.

The analyzed chunks have an average rate of one vertex per triangle, however, in a closed mesh with lots of triangles, each vertex is shared on average by 6 faces. Therefore, it might be possible to achieve a 0.5 vertex/triangle rate but I will leave this discussion for a future post.

The idea of his work, as I understand it, was to calculate the surface parametrization at the time the surface’s fragments are begin processed in the Pixel Shader. For that purpose, he uses ddx and ddy functions to differentiate the surface’s eye-space position received from the Vertex Shader inside each fragment processed. That way, for an arbitrary triangular mesh, he does not need to store the usual per-vertex UV, tangent or bitangent (also known as binormal) parametrization vectors.

One disadvantage of this technique is that it relies entirely on GPUs that support Shader Model 3 but I wonder if it would not be possible/viable to differentiate the surface in a deferred pass using the PS3 SPUs.

I implemented Mikkelsen’s Bump Mapping technique inside my old Detailed Surfaces Viewer project, making it easy for me to compare his technique with two others: Normal Mapping and Relief Mapping. My implementation differs from Mikkelsen because I still sample the surface’s height from a normal/height texture using an interpolated UV coordinate, and then use the ddx and ddy functions over it.

The first issue that I noticed in Mikkelsen technique was that I needed to scale the height map values to increase the normal displacement and make it looks like Normal Mapping. The following pictures show a flat surface rendered with Normal Mapping (left) and Relief Mapping (right) using the same normal/height RGBA texture/map.

The following pictures show the same flat surface rendered with Mikkelsen’s technique using the same normal/height texture. In these pictures the height values acquired from the normal/height texture were scaled using a different factor varying is ascending order between 1, 4, 16 and 32.

As you can see, the results obtained exhibits low displacement and low noise in the first pictures but better displacement and higher noise in the last ones. I would like to further analyze this noise issue to make sure I didn’t do anything wrong and to find out how to deal with it. Note that I’m using trilinear filtering here and that the height map is the same being used by the Relief Mapping technique.

The following pictures compare Mikkelsen’s Bump Mapping without parametrization (first line), Normal Mapping (second line) and Relief Mapping (third line) techniques using two other normal/height maps. Note that for the first technique a height scale factor of 16x was used for both maps.

I will update the Detailed Surfaces Viewer project as soon as I deal with the noise problem.

I was trying to update this website for a long time but after joining Tectoy Digital I could not find any free time to do that. Fortunately, I could find some time to work on this website again in the past weeks and after a lot of word it is finally ready! I tried to port all the content from my previous website to this new one but I decided to drop some old posts and projects leaving more space for the new stuff that is coming.

This new site was made using Wordpress and it has some features that I believe everyone will enjoy, such as commenting the posts or rating it. In the following weeks I will try to post some materials (projects and talks) that I worked in the past two years, as well as some interesting news. I hope you enjoy this new website!

Siggraph’s Student Volunteer is great program that provides students with a Full Conference Pass which allows you to go almost anywhere in the conference. As a volunteer you can apply for 18 or 30 hours of work, and if you apply for 30 hours you can also be awarded with housing. It was the second time that I applied for the volunteer program, and fortunately, I was accepted! =D

Are you attending to Siggraph this year? I would really like to meet you there. It will be my first time there and I would like to meet a lot of people.