Here is a summary of some of the new features and feature improvements in version 3.7 of mental ray. Please refer to the release notes for more details and for other changes which are not mentioned here.
mental ray now supports shaders written in MetaSL language to be used for software rendering. This is handled by integrated support for automatic compilation and/or linking on the target platform, see MetaSL shaders.
The shader code generation is performed by so-called MetaSL back-ends. mental ray currently provides two back-end alternatives :
The C++ back-end is currently the default.
The .NET back-end is optional, because it has several known limitations in the current implementation. It is using the .NET Framework from Microsoft, version 2.0 or higher, available for all modern Windows platforms.
For shading trees defined in mental ray scene files, mental ray
supports a first version of shading tree
flattening. This operation allows to generate a
single final shader from a source shading tree or phenomenon by
resolving all parameter connections and compilation to a composite
shader. This is possible for shading trees or phenomena which
consist only of MetaSL shaders, i.e. not mixed with C/C++ shaders.
The flattening can be enabled by setting the
{_MI_REG_METASL_FLATTEN} mental ray registry variable
to a non-empty value.
In the progressive rendering mode, the image is not rendered in tiles each at full sampling quality any more. Instead, few samples are placed sparsely over the full image initially and more samples are taken over time until a desired quality is reached. During rendering the image is available for display at any time which allows to implement interactive rendering applications with mental ray. This mode even works with the regular but slower DISP stream protocol that is used when connecting imf_disp to a running mental ray. Various options allow to tune either for faster response or better quality. The progressive rendering can be controlled to run endlessly until explicitly stopped by the user, or until a certain sampling quality or error threshold is reached.
This version of mental ray supports traditional mental ray shaders and the existing rendering algorithms like finalgathering (in particular, with progressive finalgather precomputation) and photon mapping. Future versions may provide further optimized and faster converging solutions fully based on importance sampling and BSDFs.
Progressive mode can be controlled from the command line and with scene options.
The final gathering algorithm has been improved to provide much faster early feedback which is progressively refining during the pre-computation phase, to support interactive rendering applications based on mental ray. The tile display ordering has been adjusted to match the tile order used during regular rendering, giving the impression of doing a single rendering that improves progressively. This mode can be combined with progressive rendering mode for best interactive behavior. It has no effect with "exact" final gathering.
The finalgather display during pre-computation gets enabled with
the -finalgather_display on command line option or
with the miRENDER_DISPLAY_FG bit in the rendering mode
mask. The pre-computation is now split into several passes, each
one refining the previous ones. Furthermore, it also respects the
order of tile computations specified with
mi_rc_set_taskorder() function call.
The number of FG precomputation passes can be specified with the
string option "finalgather passes", or with the
command line option -finalgather_passes <int>.
The default value is 3.
In the current implementation, the maximal value of finalgather passes is 8. Only 2 most recent one apply adaptivity in the raster sampling, the purpose of others is to provide progressive rendering report. I.e. for the number of passes larger or equal to 3 the final image does not change.
For compatibility with mental ray 3.7 and prior, the single pass
finalgather display can be enabled with the string option
"finalgather precomp legacy".
For final gathering, implemented a way to restrict finalgather map lookup to a specified subset of finalgather points. In particular, this feature may be used for rendering of objects with multiple semi-transparent surfaces where explicit separating of layers is more efficient than limiting interpolation distance or increasing the density of the finalgather map.
The miIrrad_options structure passed to
mi_compute_avg_radiance() function has been extended
with the integer field "id". The default value for id
is zero. The id is stored with each finalgather point. For
interpolation, the id passed to the interpolation call is taken
into account: if zero, all finalgather points are potentially
accepted. If non-zero, only finalgather points with the same id are
accepted.
Backwards and forwards binary compatibility of mental ray shaders and finalgather map files is maintained.
mental ray provides a built-in solution for image-based lighting (IBL) with optimized performance and quality. It works for regular scenes which have a camera environment shader installed, no matter if that shader takes color values from a texture image or generates them procedurally. mental ray is pre-sampling the environment and creating lookup acceleration data structures to support importance-driven adaptive sampling during the lighting computations in shaders. The illumination from the IBL is automatically added to all material shaders which perform regular light sampling.
The IBL mode can be controlled with scene options.
IBL can be used in progressive rendering mode.
This version adds a novel and alternative global illumination technique called Irradiance Particles (short: IP), which is in many cases superior to finalgather and/or photon mapping in terms of image quality, usability and performance. It is based on importons which are shot to the scene from the camera before rendering starts. Their hit positions with information on the amount of direct (and possibly indirect) illumination coming at their position (hence the name "irradiance particles") are combined into a map. Optionally, one or more passes of indirect illumination can be computed. By the nature of the algorithm, this computation is importance-driven. During rendering, Irradiance Particles are used to estimate the irradiance for every shading point: if just direct illumination was collected for irradiance particles, this is equivalent to one bounce of indirect lighting. Irradiance can also be interpolated from precomputed values found at nearby particle positions.
Support for built-in illumination models represented by a Bidirectional Scattering Distribution Function (BSDF, commonly known as BRDF for non-transmitting materials) has been added to mental ray. In the current version, mental ray provides the most common Lambert, Mirror, Phong and Ashikhmin BSDFs, as well as an Architectural BSDF to closely simulate the behavior of the respective advanced mental ray shader. More BRDF/BSDF standard models will follow in future versions.
With BSDF shaders, it is possible to omit photon shaders. For
materials with a BSDF shader but no photon shader specified mental
ray automatically uses the BSDF shader and use its
sample function to simulate photon shader behavior.
For the future version, this fallback into BSDF will be enabled for
other indirect illumination techniques.
BSDFs may be split into up to 6 components (reflection and
refraction, with diffuse, glossy, and specular components each).
The eval function evaluates all BSDF components, or a
subset thereof, for a pair of incoming and outgoing directions. The
Bsdf interface also provides a sample
function, which allows importance sampling of outgoing directions
for a given incoming direction. In addition, this function provides
information about the sampled component and the sample weight. The
latter can easily be combined with Russian roulette for absorption,
which could be used e.g. for writing photon shaders.
A BSDF shader may be attached as material shader into
miMaterial. In this case, mental ray takes care of
simulating a material shader based on the BSDF.
An instance of a BSDF shader with given parameters may be specified with the usual shader syntax. Input parameters of a BSDF shader can be specified as the result of other shaders, allowing conventional shading trees and phenomena to be used.
Initial support for generalized Map containers has been added. Maps are particle systems in N dimensional space. Each particle has a position and set data assigned.
mental ray provides functionality for creating, accessing and
editing of Maps, as well as loading them from files and saving them
to files. An efficient nearest neighbor lookup functionality is
implemented, utilizing either euclidean distance or arbitrary
distance functor provided by user. The distance functor may
implement rejections by returning the miHUGE_SCALAR
value.
Particle data may be any structure consisting of the common types including scalars, integers, vectors, colors and transforms. All particles in a single map have identical layout. The position of a particle is an N-dimensional float vector, where N varies in range from 1 to 6 in the current implementation.
In this version, Maps need to be created or loaded by applications or geometry shaders. Tutorials are added to mental ray releases.
Implemented adaptive tessellation for Catmull-Clark meshes. Each region can now have a different refinement level. t-vertices with neighbor regions having different refinement levels are fixed with triangle fans. Positions are always computed on the limit surface.
For the Catmull-Clark meshes, improved texture seams quality by implementing spline-rule evaluation.
Added approximation for hair. In addition to the old approximation syntax which directly specifies the number of approximating segments, it is now possible to specify adaptive length, distance, angle approximation including view-dependent approximations. Parametric approximations depending on the degree of the hair curves are supported as well.
Especially for curved hair and hair at higher viewing distance, the new approximation criterion allows to have high approximation resolution restricted to the area where needed. The lower number of hair segments result in reduced memory consumption and increase rendering speed.
In order to get benefit from curvature-dependent approximations, hair needs to be modelled appropriately with hair degree > 1.
For moving polygonal objects with displacement, added functionality to automatically control the quality of displacement according to the amount of visual motion. For fast moving objects, images with comparable visual quality may be achieved with fewer displacement tessellation details compared to static or slow moving objects. Though it is also possible to tweak displacement approximation on a per-object basis, this would require a lot of manual efforts and is rarely done in practice. Per-object granularity may also be not fine enough for object having different amount of motion in different parts. The new approximation motion factor provides an automatic way for adjusting the displacement quality according to the amount of motion for a given object part.
For view-dependent fine poly displacement the adaptive subdivision checks motion length in screen space. The measured motion length is used to modify the use of the approximation constant. Geometry is reduced only in areas of the object with strong motion.
A new option can be used to modify the amount of geometry reduction compared to static case. The feature is enabled by default at a rather conservative setting, which reduces displacement quality only for very fast moving objects.
For OpenEXR textures, added ability to use display window. If
the registry setting _MI_OPENEXR_WINDOW is set to
"display" (in contrast to "data"), then the OpenEXR display window
will be used. Note that display window is not compatible with
mipmap pyramids for filtered local textures.
The OpenEXR version as been updated to 1.6.1.
OpenEXR library is linked statically. On an attempt to link
mi_openexr.dll, a warning message is printed.
Added IPv6 support for mental ray multi-hosting rendering. In
the .rayhosts file, as well as on the command line,
IPv6 addresses may be specified. Host names and IPv4 addresses are
still supported. IPv6 addresses need to be put into the ][
] brackets following common URL convention. Note that if
slave host is specified on the command line, the [ ]
brackets may need encapsulation depending on the shell used.
mental ray master host tries to establish connections to slaves using either TCP or TCPv6 protocol, whatever is available and applicable to a slave host (if a slave host is given by name, both TCP and TCPv6 protocols are tried out, the order depends on operating system used and OS configuration).
Added IPv6 support for the socket layer of mental ray DISP
protocol (immediate display of tiles as they rendered). mental ray
would listen for connections done with either TCP or TCPv6 on the
same port id. The imf_disp tool would try to get the
connection with any of TCPv6 and TCP protocols.
The following changes were made in the .mi scene description syntax:
bsdf keyword,
allowing to specify the BSDF shader in the material. An instance of
a BSDF shader with given parameters may be specified with the usual
shader syntax. Input parameters of a BSDF shader can be specified
as the result of other shaders, allowing conventional shading trees
and phenomena to be used.
declare map "name"
[ dim int , ]
parameter1,
...
parameter
end declare
with each of parameters being one of
integer "parname"
scalar "parname"
vector "parname"
color "parname"
transform "parname"
array int integer "parname"
array int scalar "parname"
The allowed parameter types are 32-bit integers, single precision
floats, float 3d vectors, 4 component float colors and 4x4 float
matrices, as well as fixed size arrays of integers and
floats.
map "mapname" "layout" (
["mapfile1", ... "mapfileN"]
)
end map
map "mapname" "layout" (
{ <rec1field1>, ... , <rec1fieldM> },
....,
{ <recKfield1>, ... , <recKfieldM> }
)
end map
i.e., either a list of file names containing binary map data is
specified, or the list of fields for each particles in the map.
Each recSfieldT entry should consist of the proper number of
space separated float or integer values. The first record in each
row should be N floats corresponding to the position of a particle
in the N-dimensional map.map type has been added to the list of legal
shader parameter types, following usual conventions. However, a Map
cannot be an output of a shader.
approximate hair <curve_approx>
with <curve_approx> being any curve
approximation technique, for example:
approximate hair view length 3 distance 0.1 angle 5 0 7
"geom
displace motion factor" f used to modify the amount of
geometry reduction compared to static case. A factor of
f=0 turns off the feature. The factor f=1
is the current default to achieve a reasonable compromise between
quality and speed. Higher values of f give more
reduction. The current default value is rather conservative: the
simplification of geometry will have an effect for motion of
approximately 16 pixels. In order to get effect on slower motion,
higher values should be used. For example, the factor value of 8
would reduce geometry in areas of objects moving at the speed of 2
pixels per frame."importon emitted". If
specifies the total number of importons to emit and overrides the
"importon density" string option. The options are
similar, but "importon emitted" specifies the value
which is independent of the image resolution and thus is better for
tuning.
rename "target" "source"
This function may be used to rename existing scene entities. See
the related API function for further
details.triangle
estimate <int>" to the .mi syntax. This field may be
set by a translator or exporter and give approximate number of
triangles expected for the given object. CAD application frequently
would know the precise number, but even if it is know only up to an
order of magnitude it is advisable to provide it. In the future
versions, mental ray will use it as a hint for optimizing
performance and memory usage."fine shared", "fine
nosmoothing", and "fine shared nosmoothing".
The registry key _MI_REG_SHARED_DISPLACEMENT which
could be used to enabled the "shared" mode globally for all objects
is deprecated, but could be used in mental ray 3.7
for compatibility reasons.miMaterial structure has been extended with a
bsdf slot, which may specify an instance of an
optional BSDF shader.mi::shader::Access_bsdf class.
The API for interaction with BSDFs is declared in the new
shader_bsdf.h header file. It is described in the
doxygen documentation in the manual.builtin_bsdf_architectural and
builtin_bsdf_mirror BSDFs. The
builtin_bsdf_architectural is a simplification of the
architectural material, containing the parameters relevant for the
material properties. The builtin_bsdf_mirror is a
simple specular reflection, which multiplies the reflected color
with the reflection parameter.builtin_bsdf_architectural, but the declaration
follows those of the architectural material. This BSDF may be used
to minimize changes to the existing scenes and translators using
the architectural material.mi_api_map_* functions family.
mi_api_rename(char *target, char *source)
to rename existing scene entities without recreating them. In
particular this may be used by application interface to follow user
interaction. The function has following limitations:
miObject::tri_est, to
provide an estimate of triangulation counts. See scene syntax description for more
details.miAPPROX_STYLE_FINE_NO_SMOOTHING_CONT_DISP
value has been added to the miApprox_style
enumeration.mi_rc_run now returns to the application in one second
and does not wait until all rendering threads are blocked. The
rendering threads are still blocked on memory or database
operations, possibly after mi_rc_run returns. Previous
synchronous mode where mi_rc_run returned first after
all threads get blocked was less robust: threads blocked on
internal locks were not counted, which resulted in a possible
application freeze.mi_query
mode miQ_STAGE.miBoolean, which is typedefed to int.unsigned.miMaterial structure has been extended with bsdf
slot.miHair_list structure has been
extended with approximation. Unused integer approximation has been
removed.mi_shader_if.h header file now
include several partial header files according to the features if
the mi::shader::Interface class. Shader writers are
still supposed to include the mi_shader_if.h file into
the shader C++ files.mi::shader_v3 namespace. A namespace alias for
mi::shader is added, so that no changes to the shader
code are required. Shader writers are expected to continue to use
the mi::shader namespace. This fixes possible crashes
(mismatched symbol linkage) in debug shader libraries using
different versions of mi::shader::Access_fb or
Edit_fb classes from different versions in the same
rendering.mi::shader::Interface version has been
increased to 3. Shaders compiled for mental ray 3.7 alpha versions
need to be recompiled. Shaders compiled for mental ray 3.6/3.6+
keep the limited binary compatibility with mental ray 3.7 over the
mi::shader::Interface version 2.miGeoBox
structure.Copyright © 1986-2010 by mental images GmbH