I've seen mention of tiled raytracing, but haven't been able to find much on google about it.
Can anyone explain what it is and how it works?
$\begingroup$
$\endgroup$
Add a comment
|
2 Answers
$\begingroup$
$\endgroup$
2
Tiled raytracing is a way of speeding up rendering. Instead of rendering pixels on a row-by-row basis down the entire image, you render them in 2D groups (say, 32x32 tiles). Since adjacent rays tend to intersect the same objects, this improves the cache hit rate at the CPU level.
At a smaller scale, tiling at the 2x2 level lets you use SSE/AVX/etc to compute four rays with a single CPU instruction, further speeding things up.
-
2$\begingroup$ Do you happen to have links to any more info about tiled raytracing? I'm guessing there are multiple ways that tiles can help, and probably different ways that people have exploited those benefits. Trying to get a toe hold on some info to look a bit deeper at existing techniques. $\endgroup$ Commented Aug 13, 2015 at 3:39
-
$\begingroup$ @AlanWolfe, nothing really useful. The 2x2 tiling was a paper I read several years ago and can't find now, while the larger tiles were just a passing mention on a webpage. $\endgroup$– MarkCommented Aug 13, 2015 at 5:20
$\begingroup$
$\endgroup$
I believe it's where you batch it and do a block of pixels at once, or a "tile".
This means calculating the final color for multiple pixels at a time. Imagine breaking up your window of pixels into squares containing the pixels, usually around 2x2 pixels per square. Then simply work through them.
This causes speed boosts for lots of different reasons, depending on your implementation and hardware. If you can, check out Ingo Wald's PhD thesis about real time raytracing, he makes a lot of references to batching to get speed using things like AVX (advanced vectoring extensions) in the processor. These provide speed boosts when you calculate the color for a certain amount of similar pixels. It's all cool and definitely worth looking into, and you can read more here: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions
Basically you represent similar data for similar pixels using a vector of floats and do the same calculations to all at once, saving cycles. Picture Bart Simpson writing out the same words on the chalkboard all at once instead of line-by-line in the Simpsons opening :)
Also when doing real time raytracing, you may be using the graphics card and sending all the data over the bus is a large bottleneck. You don't want to send all the data over to the card to calculate the value of only one pixel because of the bus overhead - so you want to send a reasonable amount of data to chew on while you work on getting the next chunk ready.
So, to me at least, "tiled" raytracing is just "batched" raytracing.
I hope this helps.
