Work Journal 9/29

I embedded the light under 1 unit along the normal direction under the surface. The outcome should be several disk light sources embedded under the mesh.

[To Do]

1. Control the scattering and absorption and the intensity of the light.

2. Fix the brain mesh.

3. Test several light sources

Work Journal 9/27

I have tried several ways to make to media glows from the inside but not too transparent. However, if I set the scattering and absorption rate too high, the light can't come out.

[Bunny Model]

[Brain Model with External Lighting]

[Brain Model with Internal Lighting]

[To do Next]
*a bug when I place the square light inside. (Didn't occur when using the bunny model.)

* Find out a proper parameter to see as a light in fog.

Work Journal 9/26

[Might be problematic]
BVH (if too many triangles or the objects are scattered everywhere, it might be a problem)
Photon mapping (due to the limit of the memory, if too many photons are used, it will crash)

[Finish Today]
The "Media" object now is fully controllable.
High scattering, high absorption will result in close to diffuse objects.
Low scattering, low absorption will give more translucency.

[Next goal]
Multiple light sources inside the object.
I'm not sure how it will look like. I will set the scattering and absorption low to make the light from inside can go out.
No clue if it will look like the wax object in the reference picture.

One more thing, set the reflection to white might be working without global tone mapping.

[Parallel Computing] Sorting

I adopted the odd even sort for sorting on GPU. I use NVIDIA GeForece 9400M, which has the spec (only list related):
CUDA capability 1.1:
1. Max number of threads per block: 512
2. Max blocks in x direction of a grid: 512
3. Shared memory size: 16K
4. Global memory size: 256M

For my application:
Each item in the list: 16 bytes
Usually the size of the list is larger than 1024.

In my implementation, a thread is assigned with two elements in the list. A block containing maximum number of threads (512) can manage 1024 items. In my implementation, the whole list doesn't fit in one block, and inside a block, the elements don't fit in the shared memory. Therefore, I had to use multiple blocks (usually 30~60 blocks) to accomodate the list. Unfortunately, CUDA only provides with us thread synchronization within a block. For interblock synchronization, I have no choice to relaunch the kernel multiple times.


Result:
Sorting 438270 items
CPU version: 86s (This version is not optimized, just want to verify the correctness of GPU version)
GPU version: 504ms

[Parallel Computing] Indexing tricks

When making device kernels (shaders,) how to assign threads to some tasks is very important.

Since the GPU has really little support of recursion, how to turn your recursive program into a non-recursive one becomes very important as well.

I saw this approach when I was working on GPU sorting.

The original Odd Even Merge Sort is described here

I'm not gonna describe the iterative version in detail but mention some tricks to accustom your code to the GPU kernel.

1. When your code has the thread assignment with a circular pattern:

For example:

8 Threads:

Thread Id 0 1 2 3 4 5 6 7

Activate/no n n y y n n y y

Solution:

Here we have a circular pattern with a period of 4.

Of course we can use something like if(Idx.x==xxx), but if the case is making an iterative execution, there will be too many cases to be considered.

A better way is to use (Idx & (period-1)) and set a threshold.

In our example, we can use (Idx&3) and set a threshold equal to 2.

So the values become:

Thread Id 0 1 2 3 4 5 6 7

Activate/no n n y y n n y y

Value 0 1 2 3 0 1 2 3

Thresholded n n y y n n y y

So it's exactly what we want for our program.

[Feature]Photon Mapping

I use photon mapping to do the indirect illumination. Indeed, it's way faster than path tracing.Following image is rendered with global photon map and caustic photon map.

[Cornell Box]

Parameters:1000 samples direct lighting
10000 photons
1000 photons for irradiance estimation

Parameters:1000 samples direct lighting
10000 photons
1000 photons for irradiance estimation

Parameters:
2000 samples direct lighting
1500x1500 HDR image as background
10000 photons
1000 photons for irradiance estimation

[Path Tracing]Environment Mapping

After adding environment mapping, everything looks good ^^.

Path tracing isn't a good method to do caustic, so it's noisy for the caustic even though I use comparably more samples.

Parameters:

700 samples path tracing

1500x1500 HDR image as background

Image based Lighting

Parameters:

700 samples path tracing

50 samples image based lighting

1500x1500 HDR image as background

Image based Lighting

Parameters:

1500 samples path tracing

50 samples image based lighting

1500x1500 HDR image as background