RenderMan traces ray streams of a few thousands rays (at least not millions like Disney's Hyperion), right? Does that really help that much with reducing the shading costs? It probably makes a large difference for shading the initial hit point, but nowadays it's not uncommon to trace paths of more than 10 bounces. It seems very unlikely to me that it gives a significant speed-up with that level of incoherence and the high complexity of production scenes.
Some context: During a panel on production renderers at SIGGRAPH [0] it was mentioned that most rendering research was not really usable for production rendering, as those algorithms are unable to handle the complexity of production scenes. Matt Pharr (one of the authors of pbrt [1]) asked the panelists to release production datasets for research purposes. Walt Disney Animation Studios is now following up on his request by releasing these two datasets. Yining Karl Li of Disney [2] and the readme for the Moana dataset [3] have some more info.
It's absolutely amazing that Disney is doing this, especially as the license is quite permissive and also allows the usage for non-research purposes.
The per-thread caches are not strictly necessary, but you don't want threads to block because they can't stream in geometry to memory. You want some upper bound on the amount of memory each thread needs for geometry (each thread could try to ray intersect a different mesh). Dividing geometry into fixed sized chunks gives you this upper bound (max N chunks per thread).
Ray re-ordering is indeed a nightmare, but sorting very large ray batches (millions of rays) into coherent ray streams is less of a hassle, and it should enable coherent geometry access (which amortizes the cost of those reads, not sure to what extent).
Yup, I meant paging geometry. The problem with just doing a two level BVH is that some models can be very large, while others may be much smaller, which makes it hard to reserve memory for the geometry cache (even if it just fits one model per thread). Which means that you can store fewer rays in memory, and I'm not really a fan of constantly writing rays to disk. I was thinking of just cutting off subtrees of the BVH and storing those on disk, which makes it possible to assign just a few megabytes of memory to each thread for caching geometry. Not sure how efficient that would be though, probably a bit faster than rebuilding part of the BVH every time (especially when using high quality BVHs with spatial splits). Shouldn't be too bad with large ray batches, sorting and ray streams.
They do mention some tests with "out-of-core rendering of scenes with massive amounts of geometry" in the paper, but there isn't much info on it. AFAIK their patents mention streaming in geometry too.
I know that buying more RAM is probably easier, but it would be interesting to render very large scenes on commodity hardware. I guess paging in geometry is just too much of a hassle, you constantly have to stream in geometry to memory; to compute surface derivates, to do subsurface scattering, to sample arbitrary geometry lights, etc.
There's very little info in the Disney paper on geomapping, do you have any ideas on how they do it?
I guess that you don't want to page in full models (as you either need a very large amount of memory per thread, which means smaller ray batches, or you need to have a shared cache, which means waiting on other threads). So you'll probably need something similar to Toro (as described by Pharr et al.), which just doesn't seem very efficient to me (as grids have improved little compared to BVHs).
They gave Yelp two options: either disable crawling in robots.txt, which means that Yelp won't show up in Google's results at all, or accept that Google will copy Yelp reviews without linking back. This is quite similar to what Microsoft was doing in my opinion.
The same can be said about Windows, yet both the European Union and the United States accused Microsoft of abusing their monopoly by bundling Internet Explorer with Windows. This antitrust against Google is really similar.
Google has a search engine monopoly (at least in Europe), this gives them the obligation not to abuse this. If they're using their monopoly to promote other services (such as when directly show Maps in the results, without offering other providers of maps the same option) or if they're scraping content without linking back (such as with Yelp), they're abusing this monopoly.
I think this is aimed at middle/high school students. It probably can be interesting for adults, but I'd really recommend picking up a book such as Fundamentals of Computer Graphics by Shirley and Marschner [1].
Yeah it was a great learning tool. pbrt is a good learning tool, but sadly it already implements most of the basics. Courses at Cornell and ETH Zürich used a small rendering framework called Nori [1], which is a pretty good learning tool. Shadertoy is nice, but perhaps a bit annoying to work in (as it involves a lot of tricks). I guess the best way to learn is to write your own ray tracer, but that takes a lot of time.
The current edition of Physically Based Rendering still uses literate programming, but most of the maths are separated from the code, so you can skip over most of the code. Even if you can't stand I can really recommend reading it, as it's a great book. Shirley's Realistic Ray Tracing is still very useful these days, but obviously it's lacking the state of the art. If you really want to avoid any code you should read Veach's PhD thesis [2] and then some papers on BSDFs [3], shapes [4] and ray tracing acceleration [5].
I guess I didn't fully understand your post then, I thought you meant that the Reyes algorithm is an "inferior estimation" and that it might be beneficial to add it to a renderer, but neither is the case. But it isn't an inferior estimation (just a different way of computing things) and you don't want to use the Reyes algorithm in practice as scenes either barely fit in memory or they don't fit in memory at all (and in that case you want your memory usage to be as efficient as possible to avoid reading from the disk as much as possible).
The CG by UC Berkeley on EdX is a great starting point. One of the exercises involves building a simple ray tracer. A slightly more advanced source on ray tracing is http://www.scratchapixel.com/. Of course the best way to learn about ray tracing is by reading Physically Based Rendering: From Theory to Implementation by Pharr and Humphreys.
Pixar has ditched RSL in favor of BSDFs written in C++, so there is no real reason for learning RSL anymore. Open Shading Language (OSL) is a new shading language which is getting more and more use in the industry, but it's completely different by design.
The REYES algorithm is an algorithm that can very quickly produce batches of shading points (with the required information to shade them such as the viewing direction). It's not really a hack and you can still use path tracing (with BSDFs) to correctly shade these points. In fact this is what Pixar did for Monster's University; they used the REYES algorithm to determine shading points visible from the camera and then shaded those using BSDFs and path tracing. The problem with this is that you basically have to store the scene twice: once for rasterization and once for ray tracing.
It's a bit unfair to compare the speed of Mitsuba with the speed of Renderman. Mitsuba only has a simple KD-Tree (although highly optimized), while RenderMan most likely has a state of the art BVH, which utilizes SIMD instructions. RenderMan also has a lot of sampling controls, while Mitsuba's path tracer has always traces one light and one BSDF sample on each intersection. There are multiple software engineers at Pixar that solely focus on optimizing RenderMan, while most of Mitsuba is implemented by a single person, who is a full-time researcher.
Mitsuba lacks a lot of features that are necessary for production: there is no proper support for hair (Mitsuba only has a simple Kajiya-Kay shader and no specialized acceleration structure for ray intersections), there is no support of subdivision surfaces, no support for displacement mapping, etc. All of these features are necessary in production.
Mitsuba is great for research though. It has support for a lot of experimental rendering algorithms (such as Metropolis Light Transport), which are not supported in production renderers. Due to Mitsuba's modular structure it's also incredibly easy to implement new algorithms, which makes Mitsuba a great framework for comparing rendering algorithms. A lot of papers use Mitsuba to compare their new algorithm to other algorithms.
Most production renderers use CPUs (just like Mitsuba). GPUs are incredibly powerful and some benchmarks show 400% speed improvements over CPU-based renderers. The problem is though is that GPU-based renderers struggle with the scenes that are used in production. Typical production scenes contain over 250GB of textures and over 10s of GBs of geometry (pre-tessellation). This isn't going to fit the in the memory of a GPU and the GPU will spend most of the time loading assets from the hard drive (or network).
Most courses offer just the syllabus without any slides or notes on the ACM digital library. There were many other great courses, but most sadly haven't posted their slides and notes yet.
http://kesen.realtimerendering.com/sig2018.html