Ray Tracing

Reflection

Cast a reflection ray of a given color and merge the result with an input color. This can be used to add a reflection effect to a base shader that provides illumination, possibly in conjunction with refractions or transparency added by other base shaders. If no reflection ray can be cast (because the trace depth has been exceeded, or the reflection ray caused a shader to be called that failed, or the notrace parameter is set), sample the environment if there is one.

mib_reflect

color "mib_reflect" (
    color           "input",
    color           "reflect",
    boolean         "notrace")

input: is the color to composite the reflection onto.
reflect: is an RGBA color that blends the reflection onto the input. Transparent black returns the input color without casting a reflected ray; opaque white returns the reflection color without evaluating the input color.
notrace: if set to true, prevents the shader from casting a reflection ray and samples the environment instead.

Refraction

Cast a refraction ray of a given color with an index of refraction, and merge the result with an input color. The indices of refraction can be computed with another base shader, such as mib_refraction_index, which is also stored back into the appropriate state variables. This can be used to add a refraction effect to a base shader that provides illumination.

mib_refract

color "mib_refract" (
    color           "input",
    color           "refract",
    scalar          "ior")

input: is the color to composite the refraction onto.
refract: is an RGBA color that blends the refraction onto the input. Transparent black returns the input color without casting a refracted ray; opaque white returns the refraction color without evaluating the input color.
ior: is the ratio of the indices of refractions; the index of the object being entered divided by the index of the object being exited. This controls the outgoing ray direction. If it is 0, 1 is used, which reduces refractivity to transparency.

Transparency

Cast a transparency ray of a given color and merge the result with an input color. This is like the previous function assuming an index of refraction of 1.

mib_transparency

color "mib_transparency" (
    color           "input",
    color           "transp")

input: is the color to composite the refraction onto.
transp: is an RGBA color that blends the transmission onto the input. Transparent black returns the input color without casting a transparency ray; opaque white returns the transparency color without evaluating the input color.

Continue

Continue a ray of a given color and merge the result with an input color. The purpose is to continue a ray as if the current intersection did not exist. Trace depth, ray type and distance for volume computations are not modified. A typical use is for walls of a showroom where the camera sits outside, so that the room walls must be ignored.

mib_continue

color "mib_continue" (
    color           "input",
    color           "transp")

input: is the color to composite the continued ray onto.
transp: is an RGBA color that blends the transmission onto the input. Transparent black returns the input color without casting a ray; opaque white returns the transparency color without evaluating the input color.

Opacity

Cast a transparency ray of a given intensity and merge the result with an input color. This is like the previous function, except that the opacity is given instead of the transparency. Opacity is defined as 1.0 - transparency.

mib_opacity

color "mib_opacity" (
    color           "input",
    color           "opacity")

input: is the color to composite the refraction onto.
opacity: is an RGBA color that blends the transmission onto the input. Opaque white returns the input color without casting a transparency ray; transparent black returns the transparency color without evaluating the input color.

Dielectric

Another variation of refraction, with the addition of specularity (Snell's law). This shader does only the refraction part of a dielectric material; highlights are left to other illumination nodes.

mib_dielectric

color "mib_dielectric" (
    color           "input",
    color           "absorb",
    scalar          "refract",
    scalar          "ior")

input: is the color to composite the refraction onto.
absorb: specifies the outside absorption coefficients of the surface.
refract: blends the refraction onto the input. A value of 0.0 returns the input color without casting a refracted ray; a value of 1.0 returns the refraction color without evaluating the input color.
ior: is the ratio of the indices of refractions; the index of the object being entered divided by the index of the object being exited. This controls the outgoing ray direction. If it is 0.0, 1.0 is used, which reduces refractivity to transparency.

Volume Fog

This is a simple fog shader. The shader operates on the result color provided by a previously running shader, typically from a material shader at the far end of the ray, and fades it toward a fog color based on ray length. Fading occurs within a maximum distance, otherwise the fog color is considered solid. The fog color is allowed to have an alpha value which limits the maximum opacity of the fog. Attaching the fog color to a texture shader, for example, allows transparent volume effects such as smoke or fire (set max to 0 to avoid fading).

mib_volume

color "mib_volume" (
    color           "color",
    scalar          "max",
    boolean         "lightrays")

color: the fog color. The resulting color of the shader is faded towards this color based on the travelled ray length.
max: is the maximum internal space distance where fading should occur. Beyond this distance the fog is considered solid.
lightrays: if true the shader also applies to light rays, otherwise it does no operation on light rays. This option should be enabled for correct results but is expensive if the number of light rays is very large.

Ray Marcher

The ray marcher casts light rays from points on a given ray, and approximates the volumetric contribution from light sources sending light through the volume. Instead of using shader interface functions like mi_sample_light, it calls a shader given as an input parameter of type shader. Ray marching consists of calling the shader for regular points between the start point and end point of the ray, and adaptively subdividing each of these intervals until a given subdivision limit is reached if the color returned by two adjacent shader calls is smaller than a given contrast threshold. The total weighted sum is returned.

mib_ray_marcher

color "mib_ray_marcher" (
    shader          "shader",
    scalar          "distance",
    integer         "num",
    integer         "subdiv",
    color           "contrast")

shader: is the shader to call at every sampling point. Its returned color is added to the returned total unless the shader fails (returns false).
distance: is the maximum internal space distance between two initial sample points. If the distance is 0, no maximum distance is enforced.
num: is the initial number of samples in the given distance. If this number is 0, no initial number is given, and the ray marcher relies on the minimum distance instead. If both are 0, the default number is 4. If the number is not 0, it must be at least 2 (one at each ray end point).
subdiv: specifies the number of recursive subdivisions of the initial sample density. A value of 0 (the default) does not subdivide, so the ray marcher is restricted to the initial sample points. Values of 1 or larger make the sampling adaptive; each level of subdivision divides a distance by two. The maximum is 16.
contrast: if exceeded by the absolute difference between two adjacent samples, causes another sample to be taken in the middle. The process then repeats recursively for both sub-segments until the contrast is sufficiently low or the subdivision limit is reached.

Two-Sided

Choose one or the other input color, depending on which side of the geometry was hit. This is commonly used as a multiplexing material shader, with two other material shaders assigned to the front and back parameters.

mib_twosided

color "mib_twosided" (
    color           "front",
    color           "back")

front: is returned if the front side was hit.
back: is returned if the back side was hit.

Refraction Index

Decide whether the ray is entering or leaving the object it has hit, based on a scan of parent rays (not based on the normal vector; this can be unreliable if the scene contains dubious geometry such as cones with only one axis-aligned normal at the tip). The index of refraction ratio (outgoing divided by incoming) is returned. As a side effect, both incoming and outgoing indices of refraction are stored in the state (ior_in and ior, respectively), and the current volume shader becomes the refraction volume if the ray is entering.

mib_refraction_index

struct {
    scalar          "ior",
    boolean         "enter"
} "mib_refraction_index" (
    scalar          "mtl_ior")

ior: is the returned refraction index ratio, ready for use by refracting or dielectric base shaders.
enter: is true if the ray is entering the object. Most shaders do not need to know this but it makes this base shader more versatile.
mtl_ior: is the index of refraction of the material that the ray has hit. It describes the optical properties of the object the ray is entering or leaving, and is returned as the new index of refraction if the ray is found to be entering the object.

Glossiness

The shaders described in this section are a way to generate glossy (blurred) reflections and refractions. The following points illustrate the performance and usability differences between these shaders and the physics DGS shaders:

Multi-sampled glossiness (vs. single samples)
Distance-bounded reflections/refractions
Undersampling of environment
Anisotropy without need for explicit UV vectors (vs. derivative vectors required)
Normal-vector perturbing (vs. direction-vector-perturbing).
Fresnel effect
Chromatic abberations

Multi-sampled glossiness

The DGS shaders shoot a single glossy ray for reflection and refraction, relying on the oversampling of the entire image (with the associated performance penalty) to average out the samples for an attractive blur. Every ray is a new independent sample.

In contrast, the mib_glossy_* shaders take multiple glossy ray samples, causing oversampling only on the glossy surfaces rather than the whole image. Samples are created using mental ray's strictly deterministic sampling engine and is hence able to create a more attractive sample pattern yielding a "better looking" blur with the same number of samples.

DGS (left) vs. mib_glossy_reflection (right)

The image above is rendered with samples 0 1 and one can clearly see the grainy result on the left. To get a smooth result one would need to increase the sampling of the entire image. In contrast, mib_glossy_* handles it's own oversampling (in the example, 8 samples) and applies it only on the glossy surfaces themselves.

Distance bounded reflections/refractions

While strictly non-physical in the case of reflections, the mib_glossy_* shaders allow one to limit the reach of both reflected and refracted rays. This helps eliminate image noise caused by distant reflected/refracted objects, and can vastly improve performance.

Unlimited reflections (left) vs. distance limited (right)

Undersampling of environment

One of the goals of the mib_glossy_* shaders is to avoid distant image noise by filtering out distant objects and replacing with a material (in the case of refraction) or the environment (in the case of reflection). But to avoid excessive noise from sampling said environment, the reflection shader can intentionally single-sample the environment (and can even be passed an explicit pre-blurred environment) to remove noise.

Anisotropy without need for explicit UV vectors

The shaders can use explicitly-passed UV vectors for anisotropic glossy reflections/refractions, but will attempt to calculate sensible vectors themselves if these are missing (set to 0,0,0).

Normal vector perturbing

The DGS shaders calculate a specular reflected or refracted direction, and then perturb this direction within the range determined by the shiny parameter. In contrast, the mib_glossy_* shaders simulate glossiness as if the microfaceting is in the surface before the reflection or refraction.. This means the reflected and refracted directions are calculated by actually perturbing the normal vector (simulating a rough surface on a microscopic level), and calculating the new reflected or refracted direction based on the changed normal.

It is notable that this yields different results and makes the glossiness view direction dependent. As an example, the glossiness pattern of reflections in a floor will be stretched vertically. This is the same effect one can see at a sunset over water, when the reflection of the sun seems stretched vertically into a long streak of sunlight.

DGS shader (left) vs. mib_glossy_reflection (right)

Fresnel effect

Most reflective materials reflect more at glancing angles, and transparent materials transmit more at facing angles. This re-balancing between reflectance and transmittance is known as a "fresnel effect". These shaders allow different weights to be set for "edges" (glancing angles) and "base" (facing angles) to emulate this effect. In the mib_glossy_* shaders, this effect is calculated per sample instead of as a global weighting of the entire reflection for greater realism.

No fresnel effect (left) vs. Exaggerated fresnel effect (right)

Notice how the edges (surfaces at a glancing angle) in the right image reflect more than in the left image.

Chromatic aberration

The mib_glossy_* shaders have a dispersion parameter, which sets the amount of "faux chromatic aberration". The effect is not physically correct and only an emulation of the real phenomena.

Glossy Reflection

This is the shader for glossy reflection. It adds glossy reflection to a base material connected to the shader.

mib_glossy_reflection

color "mib_glossy_reflection" (
    shader          "base_material",
    color           "reflection_color",
    scalar          "max_distance",
    scalar          "falloff"                default 2.0,
    color           "environment_color",
    scalar          "reflection_base_weight" default 0.2,
    scalar          "reflection_edge_weight" default 1.0,
    scalar          "edge_factor"            default 5.0,
    shader          "environment",
    boolean         "single_env_sample"      default true,
    integer         "samples"                default 16,
    scalar          "u_spread"               default 0.5,
    scalar          "v_spread"               default 0.5,
    vector          "u_axis",
    vector          "v_axis",
    scalar          "dispersion"             default 0.0,
    array color     "spectrum"
)
apply material, texture
version 3

base_material: is the base surface onto which the reflections are added. One can, for example, apply mib_illum_phong, or any other surface shader, here.
reflection_color: defines the reflection strength (and coloration). The calculated reflections are simply multiplied by this value.
max_distance: if set to zero, the reach of the reflection rays are infinite. For values greater than zero, the reach of the reflection rays are limited to this distance (with a huge performance gain), and the color of the reflection is faded toward the environment color as the length of the ray approaches this distance. Use this parameter to improve performance and to avoid excessive noise due to distant high-contrast objects.
fallof: sets the rate for fading into the environment, which is a power function. The default of 2.0 means the falloff is by distance squared; 3.0 means distance cubed, and so on. This parameter has no effect if max_distance is zero.
environment_color: is the multiplier for when the ray misses any object and hits the environment. For physical accuracy, this should be exactly the same as the reflection_color, but is provided separately to give greater control in balancing the brightness between reflection of objects and reflection of the environment.
reflection_base_weight: is a scalar multiplier for the reflection at surfaces facing the camera, and reflection_edge_weight at surfaces perpendicular to the camera (i.e. edges), and edge_factor the narrowness of this "edge". Generally there are more reflections at edges (glancing angles) than on facing surfaces, known as a "fresnel effect".
environment: parameter allows passing an explicit environment shader that only applies to this shader. If none is passed, the material's environment shader is used, with the global camera environment as a fallback. This allows the use of a specially prepared pre-blurred environment map for environment reflections.; If the environment map is already sufficiently blurry, it may be wasteful (performance wise), and it may also introduce unnecessary sampling noise when sampling the environment multiple times. When single_env_sample is off, an environment sample is made for each reflection ray that misses an object or needs to be mixed with the environment due to the use of max_distance. When on, the environment is sampled only once for these reflection rays.
samples: sets the number of samples used, and is ideally a power of two. If zero, the shader reverts to single sample mirror reflection only.
u_spread v_spread: is the amount of normal vector perturbation performed in the U and V direction. If these values are identical, isotropic glossy reflection is generated. Upon any difference between the two values, the anisotropic mode is enabled.
u_axis v_axis: are optional parameters for specifying the directions of anisotropy. These only apply in anisotropic mode. If u_axis is 0,0,0 the shader attempts to generate a default vector based on the first derivative vector of the surface, and if such is missing, based on object-space X axis. If u_axis is given a value it is utilized as the U direction of anisotropy. If v_axis is also specified it is used as the V direction, but if left unspecified the V direction is calculated as the cross product of the original surface normal and the U direction.
dispersion: reaches from 0.0 (no chromatic aberration) to 1.0 (full spectrum chromatic abberation).
spectrum: is an array of colors defining the "rainbow" into which colors are broken when the dispersion parameter is nonzero. It defaults to a default red-yellow-white-cyan-blue-indigo colors but can be anything.

Glossy Refraction

This shader is very similar to mib_glossy_reflection but has a few differences. Since it deals with refraction, it has a "deep material" rather than an environment.

Fading towards a gray-ish "deep material"

mib_glossy_refraction

color "mib_glossy_refraction" (
    shader          "top_material",
    shader          "deep_material",
    shader          "back_material",
    boolean         "render_reverse_of_back_material",
    color           "refraction_color",
    scalar          "max_distance",
    scalar          "falloff"                default 2.0,
    scalar          "refraction_base_weight" default 1.0,
    scalar          "refraction_edge_weight" default 0.2,
    scalar          "edge_factor"            default 5.0,
    scalar          "ior"                    default 1.0,
    integer         "samples"                default 16,
    scalar          "u_spread"               default 0.5,
    scalar          "v_spread"               default 0.5,
    vector          "u_axis",
    vector          "v_axis",
    scalar          "dispersion"             default 0.0,
    array color     "spectrum"
)
apply material, texture
version 2

top_material: is the surface characteristics of the very top layer. Like the base_material in the reflection version of this shader, this is simply added to the result. An example use would be mib_illum_phong with only specularity and very little to no diffuse component.
deep_material: is only used if max_distance is nonzero. It is the surface characteristics of the "interior" of the object, and the color to which refractions fade as they reach the max_distance. While the color is still calculated at the surface, it will "appear" to be behind any refraction of internal objects. For interesting pseudo-volumetric simulations one can suggest using the misss_fast_* subsurface scattering shader here.
back_material: is the material used for rays that hit the inside of the object from within (i.e. any ray that hits the object from the back as defined by the geometry normal). It defines what the "inside" of the object looks like, and should just like the preceeding parameters be assigned to a surface shader, e.g. mib_illum_phong or similar. By default mental ray flips the normal to the side of the incoming ray, which would render the inside of the objects surface. But sometimes it is desirable to simulate a translucency effect by letting the light hitting the outside of the object define its shading. This is accomplished by turning render_reverse_of_back_material on, which causes the shader to use the original direction of the surface normal when evaluating back_material.

Simulating translucency by intentionally flipping the normal vectors of the back material.
refraction_color: is simply a multiplier for the refracted rays.
max_distance: limits the reach of refracted rays, and fades them toward the deep_material as their length approaches the max_distance. This gives the appearance of a semi-transparent material into which one can only see so far.
falloff: sets the rate for fading into the deep_material, which is a power function. The default of 2.0 means the falloff is by distance squared; 3.0 means distance cubed, and so on. This parameter has no effect if max_distance is zero.
refraction_base_weight: is a scalar multiplier for the refraction at surfaces facing the camera, and refraction_edge_weight, at surfaces perpendicular to the camera (i.e. edges). edge_factor is the narrowness of this "edge". Generally, there is less refraction at edges (glancing angles) than there is on facing surfaces. This is known as a "fresnel effect".
ior: is the index of refraction. Since the perturbation of refraction is calculated based on a perturbed normal vector, it is very important that this value defines a sensible index of refraction... otherwise an index of 1.0 causes no change in the ray direction, generating no blurriness whatsoever! As a special case, one may set ior to 0.0 which will switch to a "direction perturbing mode" rather than a "normal perturbing mode".
samples: sets the number of samples used, and is ideally a power of two. If zero, the shader reverts to single sample refraction only.
u_spread v_spread: is the amount of normal vector perturbation performed in the U and V direction. If these values are identical, isotropic glossy refraction is generated. Upon any difference between the two values, the anisotropic mode is enabled.
u_axis v_axis: are optional parameters for specifying the directions of anisotropy. These only apply in anisotropic mode. If u_axis is 0,0,0 the shader attempts to generate a default vector based on the first derivative vector of the surface, and if such is missing, based on object-space X axis. If u_axis is given a value it is utilized as the U direction of anisotropy. If v_axis is also specified it is used as the V direction, but if left unspecified the V direction is calculated as the cross product of the original surface normal and the U direction.
dispersion: parameter reaches from 0.0 (no chromatic aberration) to 1.0 (full spectrum chromatic abberation).
spectrum: is an array of colors defining the "rainbow" into which colors are broken when the dispersion parameter is nonzero. It defaults to a default red-yellow-white-cyan-blue-indigo colors but can be anything.