Disney's Hyperion Renderer
disneyanimation.com
disneyanimation.com
From the start the art team on Big Hero 6 wanted to make a really big movie. They envisioned those big sweeping shots of San Fransokyo that made the technical folks shudder. They have a massive rendering farm at their disposal but still probably wouldn't be able to render all the shots in time for the release; for one reason, because the art folks kept making changes, and for another, because they contain so many entities. A handful of folks on the rendering team built a proof-of-concept renderer with support for the global-illumination look they wanted while also being able to handle the massive scale.
As the linked article mentions, the solution was to optimize a massively-parallel algorithm by finding coherent rays that can be efficiently calculated together. It's a batch method: start casting a bunch of rays, identify similar rays and group them, calculate collisions for each group, cast reflected rays, identify similar rays and group them, etc. What I like about it conceptually is that in a way it treats light as a field rather than as individual directed rays.
Their initial tests were rendering an infinite plane of generated buildings. The dystopian metropolis was mesmerizing, and I think Disney would be wise to come up with some dark plot line to set there. Anyway, someone way at the top (the director or art director I think) saw the proof-of-concept renderings and decided that it was the perfect tool to attain their vision of this movie, which, by the way, has a hard release date something like three months away.
So they proceeded to turn the proof-of-concept into a production-grade renderer in time to render all the frames and save the movie. And somehow they pulled it off, they released a really beautiful movie, and they wrote a paper about it, too.
How does this differ from "coherent ray tracing" and "ray packets", like people have been doing the last 15 years?
(e.g. "Interactive Rendering with Coherent Ray-Tracing" by Wald et al.: http://www.sci.utah.edu/~wald/Publications/2001/CRT/CRT.pdf)
Just noticed it also has the proof-of-concept city scene I mentioned on the last page.
[1] https://disney-animation.s3.amazonaws.com/uploads/production...
[2] http://www.sci.utah.edu/~wald/Publications/2011/singleray_hy...
[3] http://fileadmin.cs.lth.se/graphics/research/papers/2014/drs...
Here's the paper that explains some of the renderers details:
https://disney-animation.s3.amazonaws.com/uploads/production...
Tracing batch rays, sorting them for better coherency and sorting the shading for coherency are not new ideas, but they are long over due to be used heavily in offline, cpu, ray traced rendering situations.
Large amounts of geometry have been done in movies for a long time, so Disney didn't really do anything that couldn't have been done before. All the same tracing a path of light one at a time while interlacing the shading is terrible for performance so it is great that Disney was able to reap the benefits. It is something that should have been obvious to anyone who understood cache performance in CPUs, but now at least people have something non-academic to point to.
From an engineering standpoint I think that Hyperion is an amazing renderer and I'd love to dig into its source code. From an academic standpoint however I think that their paper on it wasn't very interesting. I don't mind reading about the details of a production renderer, as there is a whole lot of info on writing production renderers. But I don't think that it should have been published at EGSR. There were no real new ideas in that paper that were worth publishing. The paper could have had some merit if they provided a good comparison between their architecture and other architectures, but sadly they decided to compare their renderer with other off the shelf renderers. Very little is known about the architectures of those renderers and as they all have their own implementations of acceleration structures, texturing and other shared components, they aren't comparable at all. It would have been much nicer if they implemented their algorithm in a framework such as Mitsuba, so that it could be compared with other algorithms.
I do think you should give them more credit on the engineering side though. Using large amounts of geometry has been done before, but renderers such as RenderMan and Arnold require that all geometry fits in the memory at once. Tracing large batches of rays at the same time allows you to load in or subdivide geometry on demand, which makes the size of the harddrive and the size of the individual meshes the limit, instead of the memory being the limit. Their scheme also allows for creating good ray packets, which clearly is needed if we want to reap the benefits of Moore's law, as those extra transistors mostly translate to wider SIMD vectors instead of higher clockspeeds and simply increasing the amount of children of a BVH node won't scale well. Reordering the rays allows you to create coherent packets out of incoherent rays and it allows you to efficiently handle motion blur, as all rays in a packet need to be in the same time interval, which allows you to efficiently make use of those wider SIMD vectors.
I'm certain they could have produced Big Hero 6 without Hyperion, but Hyperion gave their artists a lot of freedom by removing some of the technical limitations.
The real world speed improvements from specific methods are the significant part. There are many ideas floating around, not all of them work out once you discover all the comparisons and data omitted from an academic paper.
>I do think you should give them more credit on the engineering side though. Using large amounts of geometry has been done before, but renderers such as RenderMan and Arnold require that all geometry fits in the memory at once.
This is out of core tracing and is great that they implemented it, but neither out of core tracing and sorting rays are feats of engineering.
It has actually been done many times in both academics and commercial renderers from at least a decade ago. SIMD is also used to various extents in any decent renderer to varying degrees of success. Sorting into packets isn't the only way to use SIMD, or even the only way to use to scale SIMD use to wider lanes. Interestingly Skylake should have fast gather/scatter operations which will change the effectiveness of various techniques.
Basically good design choices and some practical knowledge from trial and error has been heavily exaggerated by marketing. I would guess that the actual render programmers would say the same. This isn't a breakthrough, it is a refinement and that's good enough. I love what they did, but to carry the torch that the impossible was made possible is disingenuous.
Presumably this statement based on your having shipped a production renderer that does these things?
> It has actually been done many times in both academics and commercial renderers from at least a decade ago
Academics, yes. Commercial--citation please? The only one I'm aware of is Weta's PantaRay, which is from only ~5 years ago (https://research.nvidia.com/publication/pantaray-fast-ray-tr...).
I'm actually more surprised that you would think of sorting and batching of rays as a feat of engineering, I can't imagine it seems all that difficult to you after all your experience.
Those ideas have indeed been around for a long time; the paper nicely cites all of the related research work. (Including among many others, a SIGGRAPH paper I wrote on the topic 18 years ago.)
I think the paper is excellent. First, there's a big gap between academic papers on a topic and the experience of actually building a real system that works for real movies. It's unusual for people in industry to take the time to write up their experiences building these systems, so I salute their making this contribution to general knowledge about rendering systems.
It's easy to carp about "all could have been done before"; that seems like an argument that could be applied to try to dismiss just about anything.
> I think the paper is excellent. First, there's a big gap between academic papers on a topic and the experience of actually building a real system that works for real movies. It's unusual for people in industry to take the time to write up their experiences building these systems, so I salute their making this contribution to general knowledge about rendering systems.
I'm %100 with you. I love seeing the results of cache coherency used in a real scenario. I was only trying to say that the actual imagery could have been done in other renderers, albeit with more pain and I would guess more attention to level of detail.
So I'm not trying to downplay anything except for the idea that the actual movie itself couldn't have been done without cache coherent batch ray tracing, when in reality it is a big optimization that came from a bit of a leap of faith, which I think is significant enough to pay attention to.
The question though is whether or not this paper should have been published at EGSR. Personally I think that an EGSR paper should either propose a novel idea or should provide a good survey of the field. I don't think this paper succeeds at either of those. Their method is 'simply' a combination of already published ideas and I don't think that they do a very good job at comparing those existing ideas.
Personally, I think this paper would have been better suited as a talk at SIGGRAPH, a publication at JCGT or a technical report (like Pixar). So: great paper, wrong venue.
Every paper I read now I am looking for all the things that were left out, how the comparisons have been changed for each scene to make that particular algorithm look good etc.
It answered a big question lingering in my mind that I haven't been able to actually try out.
I'd never heard of path tracing before now and the video makes it sound the same as ray tracing/casting, but what I've read implies otherwise (but I'm not sure how). Clearly it's different to photon mapping, but what ever happened to that: Was it too computationally expensive for the pay-off?
Practically speaking path tracing is going to give you a more real to life image at the expense of a slower rendering process.
>The “begetted” eightness as the system-limit number of the nuclear uniqueness of self-regenerative symmetrical growth may well account for the fundamental octave of unique interpermutative integer effects identified as plus one, plus two, plus three, plus four, as the interpermuted effects of the integers one, two, three, and four, respectively; and as minus four, minus three, minus two, minus one, characterizing the integers five, six, seven, and eight, respectively [3].
[1] http://www.ecse.rpi.edu/~wrf/Teaching/graphics-s2005/heckber...
[2] https://wattsupwiththat.files.wordpress.com/2012/01/bg-equat...
[3] Fuller. R.B. Synergetics. MacMillan, New York, 1975,~. 125.
When someone says 'ray tracing' to me today, before they elaborate on what they mean, I assume they're talking about using straight line segment visibility tests probably to make some kind of picture, probably using Monte Carlo techniques, probably for global illumination. So, they might mean path tracing, or one of the (many) other ways to simulate lighting, or my assumption might be wrong, but that's okay because language is fun, and vague, overridden and imperfect terms allow us to have longer conversations. :)
Ray tracing is used in photon mapping and path tracing.
With photon mapping you trace a ray from a light source and store the light energy for the area where the light hits an object.
With path tracing you ray trace a ray from the camera and every time you hit an object you check if you can see a light source from that spot. If true you return all the gathered energy back to the camera (pixel).
Kajiya introduced the rendering equation, a mathematical formulation of global illumination (takes diffuse, secular into account). It's a multidimensional integral equation. Unidirectional path tracing is an algorithm he introduced to solve the rendering equation. It uses several rays traced from pixels in the camera bouncing randomly through the scene. It's a Monte Carlo integration algorithm for solving the nasty integrals.
Photon mapping involves a pass algorithm tracing light from light sources into the scene, then a pass (like path tracing) gathering that light back at the camera. It better handles more complex light effects like caustics.
I wouldn't say better. I would say it provides an approximation to the rendering equation more quickly than path tracing does. However, photon mapping is a biased algorithm, which means that if you average many independent renderings together, they won't converge on the correct (exact) image. Path tracing methods (bi-directional, Metropolis, etc.) converge on the exact solution, regardless of how noisy each individual rendering is. (However, it may be the case that an unwieldy number of samples is required for tricky caustics, so in practice, path tracing may fail to produce a correct result because of high variance.)
[1] http://cgg.unibe.ch/publications/2011/progressive-photon-map...
When people talk about ray tracing as something different than path tracing, they usually mean the first form of ray tracing that only did direct diffuse lighting, point light sources, simplistic materials, and multiple bounces of perfect specular reflections. (Aka recursive ray tracing.)
Note that not everyone makes a distinction between path tracing and ray tracing, you can easily find lots of examples of people referring to ray tracing and talking about GI and Monte Carlo techniques. "Ray tracing" is evolving to incorporate modern developments.
Here is a better source for papers (SIGGRAPH, Eurographics and EGSR have the best papers on rendering):
http://kesen.realtimerendering.com/
The Hyperion renderer was made by Disney, not Pixar by the way. Pixar only uses their own RenderMan renderer. Disney uses a mix of Hyperion and RenderMan, as Hyperion is not useable for test renders, as it can take up to 15 minutes until a pixel will appear on the screen, as they trace millions of rays at the same time.
None of the things you claim in this sentence are true. Disney does not use PRman at all anymore.
[1] http://www.fxguide.com/featured/disneys-new-production-rende...
The RSL shading language was also causing a rather large overhead of shading time as it was an interpreted language that could no longer amortise its runtime cost over a shading grid of points using SSE - in path tracing, you generally shade one point at a time per ray vertex, although you can batch them up in some cases (but without significant ray re-ordering and deferring, after the first bounce this becomes less and less useful).
Disney also use Ptex for texturing, which doesn't really like incoherent shading points, so that was another reason to put effort into doing large scale re-ordering of rays and batching them up.
The main problem with RenderMan before version 19 was that it didn't have a good acceleration structure and that you basically had to implement a path tracer in RSL on your own. Pixar wrote a path tracer in RSL for Monster's University, so Disney could have just used that. I doubt that they would write their own renderer if they could have just asked Pixar to implement a better acceleration structure in PRMan, so there were obviously different reasons too.
I think Ptex was an important reason for them to write their own renderer, as they seem to put a lot of focus on textures in their paper on the architecture of Hyperion [2]. Hyperion's architecture also allows them to use packet tracing and to load and subdivide geometry on demand, which is also really great.
[1] http://www.realtimerendering.com/resources/RTNews/html/rtnv1...
[2] https://disney-animation.s3.amazonaws.com/uploads/production...
Even so, they could have made it with renderman. Presentations saying 'this wouldn't have been possible' are more marketing than reality. It was more likely to be a combination of the right time to pitch creating a new ray tracer to see how much could be gained through batching while also having a renderer they could control and make sure was modern.
[1] https://en.wikipedia.org/wiki/Radiosity_%28computer_graphics...
This has its advantages and disadvantages, the biggest advantage being that it's "view independent." Since there's no specular reflection, a surface looks equally bright from any direction, and you don't need to recalculate anything if you move the camera. The big disadvantage is there's no soecular reflection, so light bounces wrong off anything that should have been glossy.
I'm not aware of any attempts to do it "backward," and I can't think of how that would work. The camera in radiosity is essentially an afterthought; you can calculate the entire scene without even having one, and the view you get afterward is more of a data visualization of that result than anything that involved the camera in a fundamental way.