Hybrid ray tracing and path tracing of bezier ... - IIIT Hyderabad

IIIT Hyderabad
HYBRID RAY TRACING AND
PATH TRACING OF BEZIER SURFACES
USING A MIXED HIERARCHY
Rohit Nigam, P. J. Narayanan
CVIT, IIIT Hyderabad, Hyderabad, India

IIIT Hyderabad
Bezier Surfaces
• Bezier Surfaces are the most basic form of parametric
surfaces
• A Bezier Surface can be described as:
Q(u,v) = [U][M][P][M] T [V] T
where [U] = [u 3 u 2 u 1] and [V] = [v 3 v 2 v 1], 0 ≤ u,v ≤ 1
[M] is the Bezier Basis Matrix
[P] is the set of 16 Control Points defining the patch

IIIT Hyderabad
Bezier Surface : Motivation
• Advantages
‣ Provide compact and effective representation.
‣ Remain curved and smooth at arbitrary level of zooming.
‣ Memory efficient, in comparison with triangular mesh.
• Rendering of Parametric Surfaces
– Eisenacher et al.(2009) : View Dependent Adaptive Subdivision
– Geimer et al.(2005) : Newton Iteration
– Pabst et al.(2006) : Bezier Clipping + Newton Iteration

IIIT Hyderabad
Previous work on Ray Tracing
of Bezier Surfaces
1
2 3
BVH Nodes
P1 P2 P3 P4 P5 P6 Subpatches at
Leaf
• Based on the flatness criteria, each patch is divided into
subpatches.
• BVH for given surfaces
– Bounding boxes of subpatches at leaf nodes.
• For each ray intersecting a subpatch
– Generate initial values for Newton Iteration

IIIT Hyderabad
Limitation of the Model for GPUs
• GPU Access time:
– High for global memory
– Comparatively less for shared memory and registers
When subdividing based on flatness criteria, we need to
– Store subpatches starting index
– Store total number of subpatches
– Store initial [u,v] pair for each potential intersection.
Thus more global memory operations result in lower
throughput.
• Need to check every subpatch at leaf node

IIIT Hyderabad
Our Approach
• Create a mixed hierarchy, consisting of two hierarchical
structures.
– Each Patch is divided into fixed size subpatches, hierarchically,
using De Casteljau algorithm.
– The top level BVH tree is constructed from the original patches.
– Leaf nodes represent the original Bezier Surfaces.
– Make subtree for each patch from the subdivided patches.

IIIT Hyderabad
BVH for
Patches
BVH Nodes
Patches
1 2 3 4
Subtree Nodes
Subpatch
Hierarchy
Sub-patches

IIIT Hyderabad
Mixed Hierarchy Structure
• Create the first level BVH using the Bounding Boxes of
the original surface patches.
• Create 2 nd level BVH by alternately subdividing along u
and v parameters.
– A subdivision depth of 6 was found empirically sufficient for our
scenes.
– Fixed depth makes it possible to store skip pointers, used for
traversing the subtree and subpatch numbers to get initial
values.
– A subtree at lower level leads to early termination at this stage,
reducing the (Ray, Bounding Box) intersections.
– Subdivision also leads to tighter bounds, which further reduces
the potential (Ray,Patch) intersections.

IIIT Hyderabad
GPU Traversal of
Mixed Hierarchy Structure
• A ‘traverse’ kernel traverses the first level of the BVH.
– Lists out Potential (Ray,Patch) intersections.
– We make use of atomic operations, to provide scalability.
• ‘Recheck’ kernel parallely processes the generated
(ray,patch) list.
– This leads to further pruning of the list with tighter subpatch
bounding boxes.
– We make use of ‘t’ values computed here, to not traverse
subpatch nodes with higher values.
– This leads to reduced computation and in cases of false
positive, a little less accurate initial values.
– Lists out the reduced potential (Ray,Patch) intersections.
– Generates the initial values for each intersection.

IIIT Hyderabad
Newton Iteration
• We represent a ray as intersection of two planes, (n 1 ,d 1 )
and (n 2 ,d 2 )
The ray patch intersection equation becomes
Q(u,v) represents the point on the patch.
• We use Newton Iteration to solve for (u,v)
Here J is the inverse Jacobian matrix of R.

IIIT Hyderabad
Hybrid Ray Tracing
Divide the Ray list between CPU and GPU
GPU algorithm comprises
of three kernels:
Traverse : Generate
Potential Ray-Patch
Intersections
Recheck : Further prune
intersections and get initial
values
Newton : Apply Newton
iteration to get hit-point
CPU stage comprises of:
1. Divide CPU Raylist into
2c threads, where c is
number of cores.
2. Intersect with main BVH
3. If intersects, intersect
with 2 nd level subtree.
4. Apply Newton iteration
to get hit-point

IIIT Hyderabad
Hybrid Ray Tracing

IIIT Hyderabad
Path Tracing
• We extend our ray tracing approach to Global
Illumination effects.
• We use Cook’s approach of Monte Carlo based
Stochastic Sampling, to sample the image at
appropriate non-uniformly spaced points.
• Each pixel is sampled for a user defined samples per
pixel
• We apply our data parallel approach to this massive ray
list to generate the desired effects.

IIIT Hyderabad
Path Tracing
Bigguy in a box: 10000 spp, 512x512 resolution
Rendered in 28.5 minutes

IIIT Hyderabad
Results (Primary Rays, 1024x1024)
Model
Patche
s
Ray-Patch
Intersections
Total Frame Time(ms)
CPU GPU Hybrid
Teapot 32 126589 74 8.71 8.01
Bigguy 3570 142779 110 14.59 13.18
Killeroo 11532 147116 193 22.38 20.43
2 Killeroos 23064 317494 356 42.29 38.58
9 Bigguys 32130 570136 2092 77.05 75.9

IIIT Hyderabad
Results (Primary +Secondary)
Model
Patche
s
Total Frame Time(ms)
CPU GPU Hybrid
Teapot 32 137 17.05 15.61
Bigguy 3570 232 39.45 34.92
Killeroo 11532 351 58.3 52.19
2 Killeroos 23064 726 106.03 94.55
9 Bigguys 32130 3107 196.79 191.81

IIIT Hyderabad
Conclusion
• A mixed hierarchy model is proposed to speed up Ray
Tracing process.
• GPU benefits greatly from fixed depth subtree.
• A hybrid model is proposed, to fully utilize compute
power of CPU and GPU.
• We demonstrate the capability of our method by
performing global illumination for Bezier patches.

IIIT Hyderabad
THANK YOU

IIIT Hyderabad

IIIT Hyderabad
Hybrid Ray Tracing
• Divide the Ray list between CPU and GPU
‣ Ratio decided based on compute capabilities
• GPU algorithm comprises of three kernels:
‣ Traverse : Generate Potential Ray-Patch Intersections
‣ Recheck : Further prune intersections and get initial values
‣ Newton : Apply Newton iteration to get hit-point
• CPU stage comprises of:
1. Divide CPU Raylist into 2c threads, where c is number of cores.
2. Intersection with main BVH
3. If intersects, further intersection with 2 nd level subtree.
4. Finally, apply Newton iteration and generate hit-point
• CPU benefits from early ray termination.