|
|
|
This is a summary of key technical features of
mental ray 3.x. Features that have been introduced in mental ray 3.1
(released in Q1 2002) are marked with 3.1, and mental ray 3.2 features
are marked with 3.2. (This page used to use colored bullets, which were
not shown correctly by Internet Explorer.)
Please refer to the mental ray handbook series for detailed information.
1. Rendering
| 1.1. Algorithms and architecture |
| |
automatic fast scanline rendering
|
| |
optional OpenGL accelerated rendering
|
| |
ray tracing, used automatically and transparently where necessary for refraction, reflection, raytraced shadows, etc.
|
| |
automatic ray tracing acceleration using the BSP algorithm
|
| 3.1 |
automatic ray tracing acceleration using a hierarchical grid algorithm
|
| |
contour rendering: cartoon animation, fine
control over contour placement, overlaps, width, color, transparency,
and other user-definable criteria
|
| |
full dataflow architecture that maintains a
scene/data cache to store only the data that is currently needed,
creating data on demand wherever possible. This allows mental ray to
render scenes with great complexity with limited memory.
|
| |
incremental changes: when rendering an
animation, it is sufficient to define the differences from one frame to
the next, instead of redefining the entire scene for every frame.
Intermediate frame data that is not changed, such as tessellations, is
cached.
|
| 3.2 |
incremental scene echo allows streaming of
scene data in .mi format such that only differences between successive
frames are sent.
|
| 3.1 |
full support for IES and Eulumdat light
profile data with accurate illumination estimation. (Light profiles for
commercial light fixtures are available from the light vendors to
describe accurate lighting parameters of their products.)
|
| 3.1 |
multipass rendering allows collecting sample
data from multiple render passes, including user-defined data. Pass
data can be merged into the final image with a custom merging function.
|
| 1.2. Sampling quality |
| |
adaptive recursive oversampling (multiple samples per pixel until a contrast quality criterion is met) |
| |
adaptive recursive undersampling (fewer than one sample per pixel taken initially, automatically refined where necessary) |
| |
automatic
anti-aliasing of all features such as transparency, refractions,
reflections, shadows, area lights, textures, caustics and volume
caustics, and global illumination and multiple volume scattering |
| |
edge
following (if over/undersampling misses a feature, mental ray detects
edges and adaptively follows and renders it to avoid intermittent gaps
and "roping'') |
| |
low-discrepancy jittering to avoid "staircasing'' at sharp edges |
| |
dithering avoids color banding due to limited output image color resolution |
| |
full Quasi
Monte Carlo low-discrepancy sampling avoids "random noise'' and ensures
faster convergence to the correct solution. Algorithms are completely
deterministic (no animation flickering due to randomness; re-rendering
a frame produces exactly the same result). |
| 1.3. Texturing |
| |
textures are interpolated and anti-aliased adaptively at rendering
time without requiring manual intervention or adjustment before
rendering begins
|
| |
reflection maps for fast and simple distant environments such as sky cloud images
|
| |
nonlinear texture projection
|
| |
pyramid textures (a generalization of mip-map textures for fast and smooth texture interpolation)
|
| |
memory-mapped textures and memory-mapped pyramid textures (only the
pieces of the texture that are actually required are loaded/unloaded on
demand from disk to memory)
|
| |
fully procedural textures using shader graphs and Phenomena™
|
| 1.4. Shadows |
| |
area lights create shadows with
variable and accurate softness: spheres, discs, rectangles, and
cylinders (flourescent lights); no fixed manual blurring of shadow maps
required |
| 3.1 |
geometric area lights emit light from arbitrarily shaped objects |
| |
effects such as colored shadows cast by stained glass using shadow shader graphs or Phenomena |
| |
raytraced shadows for correct shadows, including transparency |
| |
shadow maps for fast and simple
shadows and soft shadows for those light sources where the accuracy of
raytraced shadows and area light sources is not required |
| |
all shadows are visible in reflections and refractions |
| |
self-shadowing: objects automatically cast shadows on themselves as well as other objects |
| 1.5. Volume rendering |
| |
volume shaders implement nongeometric volume effects such as fire or smoke, in both scanline and full raytracing modes |
| |
ray marching (sampling space iteratively or recursively, for example to render visible light cones) |
| |
volumes cast shadows (for example, smoke that casts an accurate shadow) |
| |
volume self-shadowing |
| |
global illumination and caustics in volumes (volume scattering) |
| 1.6. Motion and depth blurring |
| |
accurate motion blur by distributed ray tracing |
| 3.1 |
optional coherent 4D motion sampling extension for very fast, accurate, and smooth motion blur |
| |
object motion blur |
| |
vertex motion blur |
| 3.1 |
multi-segment vertex motion blur for curved motion blur, up to 15 segments per vector |
| 3.1 |
full camera shutter control for shutter-open and shutter-close time |
| |
motion blur is visible in reflections and refractions |
| |
motion-blurred light sources that generate blurred highlights |
| |
shadows of moving objects or moving lights are correctly motion-blurred |
| |
caustics and global illumination cast by moving objects or moving lights are correctly motion-blurred |
| |
depth of field (works with all other features such as shadows, motion, caustics, global illumination, etc.) |
| |
collects motion and depth information for alternative postprocessing motion blur and/or depth of field |
| 1.7. Global Illumination |
| |
global illumination permits
physically correct light simulation, which combines forward and
backward ray tracing to simulate all possible light paths and light
interaction from light sources to the camera, including indirect
lighting, light focusing, translucency, glossy reflectors, and
radiosity, without the need to manually prepare and combine each effect
separately |
| |
caustics (light patterns caused by
refraction or reflection of light, such as bright spots caused by
lenses or bottles, and underwater light patterns) |
| |
algorithms for global illumination and caustic simulation is independent of geometric scene complexity |
| |
volume caustics: focused light made visible as a beam in fog or other diffuse media in volumes |
| |
multiple volume scattering: light
interreflecting diffusely in fog or other media, such as the
backscattering glare of headlights in fog, or light transport in
clouds, or halos around bright light sources in fog |
| |
full camera shutter control for shutter-open and shutter-close time |
| |
fast two-phase final gathering algorithm speeds up global illumination by an order of magnitude compared to mental ray 2.1 |
| |
motion blurred caustics and global illumination cast by moving objects or moving lights |
| 1.8. Frame buffers |
| In addition to the
standard rendered color image, mental ray supports up to 12 frame
buffers recording various data about each pixel: |
| |
RGBA (4*8, 4*16, or 4*32 (float) bits per pixel) |
| 3.1 |
RGBE (4*8 bits per pixel in High Dynamic Range (HDR) format) |
| |
depth |
| |
motion vectors |
| |
normal vectors |
| |
labels (of objects by default; under shader control) |
| |
pixel coverage maps describing the percentage of each pixel covered by the dominant object |
| |
shader maps for incremental preview rendering |
| |
user-defined: eight frame buffers
with selectable types: RGB, RGBA (8/16/32 bits per component), *RGBE,
alpha, intensity, depth (scalar), integer, vector, bit, compressed
basis vectors |
| 3.1 |
all frame buffers are stored in multipass rendering files for laster user-defined merging |
| 1.9. Image file formats |
| There are 36 built-in image file formats with automatic content-based type and subtype recognition and conversion when reading: |
| |
Wavefront RLA and RLB |
| |
Softimage PIC and Zpic |
| |
Alias image |
| |
Dassault Systèmes CATIA picture |
| |
SGI RGB and RGBA; 8 bits and 16 bits |
| |
JPEG/JFIF |
| |
9 TIFF formats for RGB, RGBA; 8 bits, 16 bits, and floating-point |
| |
RGBA Targa |
| |
Solidworks texture |
| 3.1 |
Radiance RGBE image |
| 3.1 |
option to store RGBE data in traditional RGBA formats such as RLA, RLB, PIC, SGI RGBA, TIFF RGBA, Targa, etc. |
| |
Quantel/Abekas, 576x720 (PAL) and 486x720 (NTSC) |
| |
portable pixmaps (PPM) |
| |
13 uncompressed texture formats for all data types |
| |
high-speed memory-mapped raw and pyramid images for all data types |
| |
Microsoft BMP 32-bit uncompressed |
| |
PostScript and Encapsulated PostScript pixmap images |
| |
PostScript line drawings for contours |
| |
16 user-defined pluggable image file formats |
2. Geometry
| 2.1. Scene definition |
| |
on-demand loading of object files
and on-demand procedural object creation using geometry shaders:
geometry is not created until it is needed, the geometry cache
maintains only objects currently or recently in use to reduce rendering
times and concurrent memory requirements |
| |
simple, efficient, and
full-featured hierarchical scene description language, fully text-based
with optional binary vector data for increased performance |
| |
C language API for the entire scene
description language, accessible to geometry shaders at runtime for
procedural scene elements. The yacc grammar source code for the scene
language is published. |
| |
multilevel scene graph architecture |
| |
multiple instancing of objects and light sources (for example, place a single wheel object in four locations and orientations) |
| |
multilevel material inheritance: different instances of an object may have any number of separate material assignments |
| |
multilevel customizable parameter inheritance: arbitrary data can be passed down the scene graph to instances |
| |
reflect/visible/shadow/caustic/global
illumination objects: for example, there may be different versions of
an object for beauty passes, reflection passes, and shadow passes; even
within a single rendering operation |
| 2.2. Curve and surface geometry |
| |
free-form suface bases:
Bézier, B-spline (including NURBS), Cardinal, and arbitrary basis
matrix, Taylor; rational and non-rational |
| |
any number of trimming
curves, hole curves, and special curves and points (that control
tessellation) can be applied to free-form surfaces |
| |
maximum free-form curve and surface degree of 21 |
| |
adjacency detection (automatic detection and merging of neighboring surfaces) |
| |
edge merging (cracks in inaccurate models are "healed'') |
| |
curve approximation: |
| |
|
two parametric modes |
| |
|
edge length limit |
| |
|
analytical distance limit |
| |
|
angle limit |
| |
|
view-dependent: closer objects are tessellated with more detail |
| |
surface approximations: |
| |
|
two parametric modes |
| |
|
edge length limit |
| |
|
analytical distance limit |
| |
|
angle limit |
| |
|
view-dependent: closer objects are tessellated with more detail |
| |
|
Delaunay (can be combined with the above modes) |
| |
|
graded Delaunay (can be combined with the above modes) |
| |
subdivision surfaces (separate product: mental matter®): |
| |
|
quads (Catmull-Clark scheme) |
| |
|
triangles (Loop scheme) |
| |
|
wavelet-based multiresolution editing and data compression/LOD |
| |
|
local refinement (per-face precision assignment) |
| |
|
texturing |
| |
|
sharp features: creases and points |
| |
|
conversion from and to NURBS |
| |
|
C++ modeling API |
| |
displacement mapping: |
| |
|
separate refinement approximations: parametric, edge length, distance, angle; view dependency |
| 3.1 |
|
new very precise sub-pixel
displacement that resolves even the finest detail of the displacement
map, without excessive memory consumption and with very easy-to-use
quality control settings, using mental ray 3's dataflow mechanism. |
| 2.3. Hair geometry |
| 3.1 |
Very efficient storage and
rendering of hair. Hair is defined as 1D, 2D, or 3D Bézier curves, and
is defined by optimized hair primitives instead of triangles. |
| 3.1 |
Works in conjunction with ray tracing, shadows, motion, etc. |
| 3.1 |
Allows attachment of texture spaces of up to 255 dimensions total, per hair and/or per vertex. |
3. Programmability and shaders
| |
shading language: C and
C++; any existing development environments (compilers and debuggers)
including their optimization features can be used |
| |
C language API for entire scene description language and other features, such as API calls for support of parallelism in shaders |
| |
shading language extensibility with shared libraries |
| |
run-time compilation |
| |
run-time linking |
| |
shaders have full read
access to the scene graph, and may extend the scene graph at runtime
(for example, to build procedural geometry or perform on-demand
creation of geometry) |
| |
shade trees and graphs:
shaders can be linked into graphs such that one or more outputs of a
shader feeds one or more inputs of another shader |
| |
encapsulated shader
graphs (Phenomena) that package one or more shader graphs and scene
insertion points into an easy-to-use "black box'' with simple external
parameters, hiding internal complexity without the need to write a
program or plug-in |
| |
shader types: |
| |
|
material (direct surface illumination properties) |
| |
|
photon (indirect surface illumination properties) |
| |
|
volume (direct volume illumination properties) |
| |
|
photon volume (indirect volume illumination properties) |
| |
|
light (direct light emission) |
| |
|
photon emitter (indirect light emission) |
| |
|
texture |
| |
|
shadow |
| |
|
atmosphere |
| |
|
camera lens |
| |
|
environment |
| |
|
displacement |
| |
|
output (full-image postprocessing) |
| |
|
contour |
| |
|
geometry (for building procedural geometry or scene subgraphs; can be parameterized with other shaders and scene fragments) |
| |
|
inheritance |
| 3.1 |
|
multipass rendering merging |
| |
|
base (provide services for other shaders in a shader graph) |
| 3.1 |
|
thread-local storage facilities for shaders |
4. Software architecture and parallelism
| |
network parallelism: multiple hosts
on a network contribute to tessellation and rendering using an adaptive
load-balancing algorithm |
| |
thread parallelism makes optimal use of machines with multiple processors (up to 256 processors per machine) |
| |
3.1 the controlling master host can
be excluded from rendering and to serve as a controller only, to keep
the master load low for interactive applications |
| |
on systems that support it (SGI, Alpha, Itanium, etc), mental ray works in full 64-bit mode, even on mixed networks |
| |
different systems work together on
a network regardless of operating system, byte order, and word size (32
or 64 bits) differences |
| |
3.1 systems can be added to the network or withdrawn from the network at any time |
| |
optionally, mental ray is available in library form for integration into OEM products (requires an agreement with mental images) |
| |
translators and plugins are available for a variety of front-end applications |
|
|
|
|