History
Pixar's RenderMan software has its origins in the University of Utah during the 1970s, where Pixar founder Ed Catmull did his PHD work on rendering problems. From there, the scene shifted to George Lucas' Lucasfilm in California, where Catmull and few other graphics researchers were brought in to work on graphics software specifically for use in motion pictures (a part of Lucasfilm later became Pixar).
The researchers had the explicit goal of being able to create complex, high quality photorealistic imagery, which were by definition virtually indistinguishable from filmed live action images. They began to create a renderer to help them achieve this audacious goal. The renderer had an innovative architecture designed from scratch, incorporating technical knowledge gained from past research both at Utah and NYIT. Loren Carpenter implemented core pieces of the rendering system, and Rob Cook wrote the shading subsystem. Pat Hanrahan served as the lead architect for the entire project. The rendering algorithm was termed REYES;, a name with dual origins. It was inspired by Point Reyes, a picturesque spot on the California coastline which Carpenter loved to visit. To the rendering team the name was also an acronym for Render Everything You Ever Saw a convenient phrase to sum up their ambitious undertaking.
At the 1987 SIGGRAPH conference, Cook, Carpenter and Catmull presented a paper called The Reyes Rendering Architecture which explained how the renderer functioned. Later at the SIGGRAPH in 1990, the shading language was presented in a paper titled. A Language for Shading and Lighting Calculations by Hanrahan and Jim Lawson. In 1989 the software came to be known as RenderMan and began to be licensed to CG visual effects and animation companies. Also, the CG division of Lucasfilm was spun off into its own company, Pixar in 1983 and was purchased by Steve Jobs in 1986. The rest, as they say, is history..
Even though the public offering of RenderMan did not happen until 1989, the software was used internally at Lucasfilm/Pixar way before that, to create movie visual effects, animation shorts and television commercials.
In 1982, the Genesis Effect in the movie Star Trek II: The Wrath of Khan was created using an early version of RenderMan, as was the stained glass knight in the movie Young Sherlock Holmes released in 1985.
Today, leading animation and visual effects studios around the world routinely use Pixar's RenderMan thanks to its unsurpassed track record - it is fast, stable, efficient when it comes to handling large scenes with complex geometry, surface appearances and lighting. The output is high quality photoreal imagery, usable on its own (eg. in animated features) or ready for compositing with existing footage (eg. in live-action movies).
Saty Raghavachary - Dreamworks Animation
Spec
In the 'Origins' section above, we began by referring to 'Pixar's RenderMan'. This is because, strictly speaking, the word '!RenderMan' by itself denotes an interface description originated by Pixar, to provide a standard way for modeling/animation programs to communicate their scene descriptions to renderers. In other words, RenderMan is a formal specification. It is referred to as the 'RI Spec', where 'RI' stands for 'RenderMan Interface'. Pixar's own implementation of the specification was historically the very first one, so people loosely refer to it (the implementation) also as '!RenderMan'. The correct name for Pixar's version is 'PRMan' (short for Photorealistic RenderMan), and this is the name we will use for it from now on.
In a 3D graphics pipeline, rendering is the last step (after modeling, animation and lighting) that generates an image out of a scene description. Renderers are specialized, complex programs that embody a variety of algorithms which collectively lead to image synthesis. The RI Spec defines a clear separation (or boundary, or interface) between modeling and animation programs on one hand, and rendering programs on the other. The idea is that each side can focus on its own specialty, and formal 'handshake' protocol can lead to successful mixing and matching between the two. In practical terms, this means that if a piece of modeling/animation program were to output its scene description in an established format, that scene description should be able to serve as input to a variety of renderers that handle that format. All the renderers would produce pretty much the same output image from the scene description, regardless of how their internals are structured. This is because the interface specifies what to render (via geometry, lights, material and camera descriptions) but not how. The 'how' is up to the individual implementations to handle - they can freely employ scanline algorithms, ray-tracing, radiosity, point-based graphics or any other technique to render the output.
Here is a brief tour of the Spec, which is divided into two parts. Part I, 'The RenderMan Interface', begins by listing the core capabilities (required features) that all RenderMan-compliant renderers need to provide, such as a complete hierarchical graphics state, camera transformations, pixel filtering and antialiasing and the ability to do shading calculations via user-supplied shaders written in the RenderMan shading language. This is followed by a list of advanced/optional capabilities such as motion blur, depth of field and global illumination. The interface is then described in great detail, using procedural API calls in C/C++ and their corresponding RIB ( RenderMan Interface Bytestream) equivalents. RIB can be regarded as a scene description format meant for use by modelling programs to generate data for RenderMan-compliant renderers. Part II of the Spec, 'The RenderMan Shading Language' (RSL), describes a C-like language (with a rich set of shading-related function calls) for writing custom shading and lighting programs called shaders. This programmable shading aspect is one of the things that makes RenderMan enormously popular, since it gives users total control over lighting and appearances of surfaces and volumes in their scenes.
The latest version of the Spec is 3.2.1, revised in November 2005. You can find the 688K, 226 page document (which happens to make for enjoyable reading!) at Pixar's site: https://renderman.pixar.com/products/rispec/index.htm.
Be sure to get a good understanding of what is in the RI Spec - it will help you know what to expect in a typical RenderMan implementation (any renderer that calls itself '!RenderMan-compliant' will by definition be bound by the interface laid out in the Spec). In addition the Spec will serve as your reference for RIB and procedural API syntax and also for the large set of built-in functions of the RSL.
Saty Raghavachary - Dreamworks Animation
Tidak ada komentar:
Posting Komentar