Class

options

Synopsis

This node is used to set various global attributes that control the rendering of the scene.



AA_samples

Called Camera (AA) Samples in the plugins.

Supersampling control over the number of rays per pixel that will be traced from the camera. The higher the number of samples, the better the anti-aliasing quality, and the longer the render times. The exact number of rays per pixel is the square of this value. For example, a Camera (AA) samples value of 3 means 3x3 = 9-pixel samples. In practice, you may consider using a value of 4 for medium quality, 8 for high quality, and (rarely) 16 for super-high quality. This control acts as a global multiplier of all the different rays, multiplying the number of diffuse and specular rays. Motion blur and depth of field quality can only be improved by increasing Camera (AA) samples.

Camera (AA) samples multiply diffuse, specular, and light samples after being squared. For example, 6 Camera (AA) samples and 6 specular samples = 62 x 62 = 1296 rays per pixel for the diffuse, and another 1296 rays per pixel for the indirect specular. Therefore when you increase the Camera (AA) samples to get better geometric anti-aliasing, you should decrease the others to compensate.


AA_seed

The AA_seed by default is set to the current frame number, so the noise changes at every frame, like film grain. This can be locked so that the sampling noise won't change.

AA_sample_clamp

If enabled, this control will clamp pixel samples to this specified maximum value. This can make it easier to anti-alias certain high-dynamic-range effects such as bright motion-blurred specular streaks (at the cost of reduced contrast). What is clamped is the resulting output value of the renderer computations of each pixel sample. Example: If the max_clamp_value is set to 2, no pixels will have an RGB value greater than 2.0, 2.0, 2.0


AA_sample_clamp_affects_aovs

With this control enabled the pixel samples of the AOVs will also be clamped. AOV clamping will affect every RGB and RGBA (except the A component) AOV. Currently, there is no way to tell Arnold which AOV's to clamp and which ones to preserve.

threads

The number of threads used for rendering. Set it to zero to autodetect and use as many threads as cores in the system. Negative values indicate how many cores not to use, so that -3, for instance, will use 29 threads on a 32 logical core machine. Negative values are useful when you want to reserve some of the CPU for non-Arnold tasks.

thread_priority

Adjusts the priority of the render threads.

pin_threads

Arnold can pin threads on Linux, so they don't jump between multiple processors. This can improve scalability in modern machines, multiple processors. It can be set to off, on, or auto. By default is set to auto, meaning that if the number of threads is more than half the number of logical cores on the machine, Arnold will pin the threads.

If client code, for instance, a custom shader, spawn their own threads manually (with pthread_create or similar), these threads will inherit the same thread affinity, which totally breaks the point of spawning threads; in these situations, they can either set options.pin_threads to off, or they can create their threads with the Arnold API AiThreadCreate() which will un-pin the created thread.


abort_on_error

Rendering will abort as soon as an error is detected. This is the recommended setting. In general, you should not ignore important error messages, or you'll risk crashes, rendering artifacts, and undefined behavior.

abort_on_license_fail

If set, rendering will stop if the license is not detected when the render begins.

skip_license_check

Switch this on to avoid taking an Arnold license from the license server. This will always render your image with a watermark.

error_color_bad_texture

The color to display if there is an error reading a texture or it doesn't exist.

error_color_bad_pixel

The color to display if the pixel returned to the render is a NaN (Not a Number).

error_color_bad_shader

The color to display if there is a problem with the assigned shader or no shader is assigned.

outputs

A string array that associates AOVs (Arbitrary Output Variables) with corresponding output drivers and filters. The syntax for an output line is the following:

  • "[camera] AOV_name AOV_type filter driver [layer_name] [HALF]" # for a regular driver
  • "[camera] driver" # for a raw driver

Where:

  • camera: camera the AOV will be rendered from (optional).
  • AOV_name: the name of the registered AOV that will be output.
  • AOV_type: the Arnold type for the AOV (RGBA, FLOAT, etc).
  • filter: the filter node that will be applied to the AOV samples to generate pixel values.
  • driver: the driver node that the AOV will be piped to. EXR drivers can support multiple outputs.
  • layer_name: an optional layer name that will be used to output the AOV. This is useful when the same AOV is filtered with different filters, and you need both versions in the output file.
  • HALF: an optional tag to use half float in the output layer.

light_path_expressions

The string array of light path expressions (LPEs), to be used as AOVs in the outputs array. Each string should contain the name of the LPE followed by the expression.

 

aov_shaders

A list of shaders can be defined that will be evaluated after the regular surface shader. With this, it's possible to add shaders to set specific AOVs without modifying the original shader tree. Shaders intended for this purpose should add a booleanmetadata named aov_shader on the node itself, as a user-interface hint. If options.atmosphere or options.background are set, these global AOV shaders will also be run for atmosphere and background contexts.


xres

The horizontal resolution of the rendered image.

yres

The vertical resolution of the rendered image.

region_min_x, region_min_y, region_max_x, region_max_y 

These define the crop region that will be rendered. The default values will render the full resolution, or the region (0, 0) to (xres - 1, yres - 1). You can use this attribute to crop the render region or force the render to render additional pixels (overscan)

pixel_aspect_ratio

This sets the pixel aspect ratio defined as pixel height divided by pixel width. Note that this is the inverse of the way it is defined for Nuke, OpenEXR, and other applications.


bucket_size

The size of the image buckets. The default size is 64x64 pixels, which is a good compromise; bigger buckets use more memory, while smaller buckets may perform redundant computations and filtering and thus render slower but give initial faster feedback.

bucket_scanning

Specifies the spatial order in which the image buckets (i.e. threads) will be processed. By default, buckets start in the center of the image and proceed outwards in a spiral pattern. 


buckets

Specifies a list of buckets to use when bucket_scanning is set to list. Each element in the array corresponds to any 2d point inside the bucket you want to render next.

ignore_textures

Ignore all textures when rendering.

ignore_shaders

Ignore all shaders when rendering, Arnold will render with a simple n_dot_eye shader instead.


ignore_atmosphere

Ignore atmospheric shaders. 


ignore_lights

Ignore all light sources.


ignore_shadows

Don't perform shadow calculations.


ignore_subdivision

No objects will be subdivided. This parameter is not interactive.


ignore_displacement

Displacements will be ignored. This parameter is not interactive.


ignore_bump

Ignore bump mapping.


ignore_motion

This can be useful for debugging problematic scenes with motion blur. When ignore motion is enabled, Arnold will use the geometry state defined by the reference_time parameter (located in the options node as well and in the range of 0-1). 


 

ignore_motion_blur

Ignores all motion keys.

ignore_dof

Ignore depth of field computation.


ignore_smoothing

Polygon normals will not be smoothed, resulting in a faceted appearance. This parameter is not interactive.


ignore_sss

Ignore subsurface scattering.


ignore_operators

Ignore operators.

 

ignore_imagers


ignore_list

Nodes in this list are ignored. For example, the following would skip creation of Lambert, Standard Surface and curves shaders:

ignore_list 3 1 STRING lambert standard_surface curves

 

auto_transparency_depth 

The number of allowed transparency hits. With 0 objects will be treated as opaque. The example below consists of six glass cubes that are sitting on top of each other. Arnold returns black when there is an insufficient number of rays due to the limit imposed by the transparency_depth. Increasing this value allows more rays to pass through transparent surfaces. In this case, a transparency_depth of 12 is enough to get a good result.

 

texture_max_open_files 

The maximum number of files that the texture system keeps open at any given time to avoid excessive closing and re-opening of files when caching individual texture tiles. Increasing this number may result in slightly better texture caching performance. On the other hand, if this value is higher than the maximum number of concurrently open files supported by the operating system (e.g. Linux vs Windows), some texture lookups may fail and return red. This is set by default to 0, which means that the maximum number of texture files that can be simultaneously opened is automatically computed by Arnold using a heuristic that tries to guess what the optimal number would be for each particular machine. We expect that the majority of users will be able to leave this at 0 and get the best performance.

 

texture_max_memory_MB 

The maximum amount of memory to be used for texture caching. Arnold uses a tile-based cache with an LRU (Least Recently Used) type algorithm, where the least recently used tiles are discarded when the texture cache is full.

 texture_per_file_stats 

Enables useful per texture statistics, with time spent on textures queries, the amount of texture data read, memory consumption, etc.

 texture_searchpath 

Defines a location to search for textures.

 texture_automip 

If a texture map file is not natively mipmapped (e.g. a JPEG file), enabling this option will trigger the generation of a mipmap on demand. The output will be stored in memory and put in the global texture cache. This mipmap generation increases render time, especially for scenes with many high-resolution textures. To avoid this performance slowdown, it is recommended to use texture file formats that natively support mipmapping (such as TIFF and EXR), where the mipmaps are preprocessed before the render and stored in the file. This preprocessing can be done with the maketx utility.

Disabling 'options.texture_automip' will result in unfiltered non-mipmapped textures.

 texture_autotile 

If a texture map file is stored in scanline mode (e.g. a JPEG file), enabling this option will trigger the generation of tiles on demand. The output will be stored in memory and put in the global texture cache. This process increases render time, especially for scenes with many high-resolution textures. To avoid this performance slowdown, it is recommended to use texture file formats that natively support tile mode (such as TIFF and EXR). You can create tile textures with the maketx utility.

 texture_accept_untiled 

High-resolution untiled texture maps are very inefficient to render because they must be loaded entirely into memory as soon as the renderer needs to access the first texel. When this flag is disabled, any attempt at loading an untiled file will produce an error and abort the renderer.

 texture_accept_unmipped 

High-resolution unmipped texture maps are very inefficient to render because the highest resolution level must be loaded into memory regardless of the distance rather than a lower resolution level. When this flag is disabled, any attempt at loading an unmipped file will produce an error and abort the renderer.

 texture_failure_retries 

When opening or reading a tile from a texture fails, Arnold's texture system will pause and try again, up to the texture_failure_retries value before returning a failure. This is meant to address spooky disk or network failures. The default is zero, meaning that failures of open or tile reading will immediately return as a failure.

 texture_conservative_lookups 

Determines the texture filter width policy. It will err on the side of softer texture look-up

 texture_max_sharpen 

texture_max_sharpen is used to improve the quality of textures so that they do not appear blurry. As texture_max_sharpen is increased, textures lookups occur from higher-res mipmap levels. The theoretical optimal value of texture_max_sharpen is to set it to AtOptions::AA_samples. The reason we do not have it set to this by default is that querying the higher-res mipmap levels also results in an increase in texture data that must be read into Arnold. This can be an issue when there are GBs of textures being read in. Instead, we allow the tradeoff for slightly blurrier textures to be used in exchange for substantial savings in texture data read. The default setting of texture_max_sharpen=1 will often appear slightly blurry. Setting it to around 1.5 will result in significantly sharper textures which in most cases are almost indistinguishable from the optimal setting. In some situations, even higher quality textures might be required and so higher values should be used. Since using a value larger than AtOptions::AA_samples is not a good idea since aliasing will occur, we clamp values larger than this to AA_samples. This can be used to your advantage if you always want the highest quality settings to be used; just set texture_max_sharpen to an extremely large value, such as 9999, so that it will always end up being clamped down to AA_samples.

 camera 

The name of the camera to be used for rendering.

 subdiv_dicing_camera 

The camera to use when determining subdivision levels of patches during adaptive subdivision. When enabled, the user provides a specific camera that will be used as a reference for all dicing (subdivision) calculations during Adaptive Subdivision (in other words, the tessellation of the object will not vary as the main camera is moved). This can be useful to fix objectionable flickering introduced by Adaptive Tessellation with certain moves of the main camera. If you set a static dicing camera, you will still get the benefits from Adaptive Subdivision (higher polygon detail closer to the dicing camera) while getting a tessellation that does not change from frame to frame. By default, this is disabled, and should only be used when necessary, and with a carefully chosen position for the dicing camera.

Polygon plane rendered with dicing camera (Catclark subdivision with 10 iterations)


 

subdiv_frustum_culling 

Subdivision patches outside the view or dicing camera frustum will not be subdivided. This is useful for any extended surface that is only partially visible as only the directly visible part will be subdivided. Similarly, no subdivision work will happen if a mesh is not directly visible. This can be turned on globally by setting options.subdiv_frustum_culling true and can be turned off for specific meshes with polymesh.subdiv_frustum_ignore true.


 

subdiv_frustum_padding 

Adds a world space padding to the frustum that can be increased as needed to minimize artifacts from out-of-view objects in cast shadows, reflections, etc. Note that motion blur is not yet taken into account and moving objects might require some additional padding.

 background 

The name of the shader to be evaluated as background for rays that don't hit any geometry.

 background_visibility 

Defines the background visibility mask.

 atmosphere 

The name of the shader to be evaluated for the global atmosphere evaluation.

shader_override

Global shader override which allows you to override the shader for all objects in the scene.

color_manager

Connects a color manager node such as OCIO.

operator

The operator graph is evaluated from the operator node defined here, denoted as the target operator.

scene_units_in_meters


When scene_units_in_meters is written to .ass files as metadata, Arnold will automatically scale the .ass data it is read in when the units differ from the current scene units. A vector of length 1.0 in the scene will be this many meters long. E.g. for centimeters scene_units_in_meters = 0.1 and scene_units_name = "cm".

Float, vector, vector2 and matrix parameters tagged with units_autoscale metadata (with a value of length or inverse_length) will be subject to the automatic scaling. 

scene_units_name

Specify the size of one unit in the scene relative to one real-world meter. The unit's name is for informational purposes only but can be set to e.g. "cm" when the units in meters is 0.1.

indirect_specular_blur

Sets indirect specular blurring to reduce caustic noise. Setting to zero gives the most accurate but also noisy renders, while higher values blur caustics to reduce noise.

luminaire_bias

Sets a distance offset for shadow rays to prevent a light becomes an occluder itself.

low_light_threshold

Raising this value can speed up rendering by allowing Arnold to ignore tracing a shadow ray for light samples whose light contribution is below a certain value. The point of low_light_threshold is to save casting shadow rays when Arnold knows that the error from not casting that ray is below a certain amount. This makes sense because below a certain threshold there will be no perceptible difference between shadowed and unshadowed areas.

Roughly, what is taken into account to discard a shadow ray is its maximum possible incoming irradiance, which is linearly related to the light's intensity and decreases with distance. The specific number will vary depending on your exposure and light intensity values, but the default value is reasonable for the default exposure/light intensity values. This will typically help more in scenes with lots of lights with a finite area of influence, like a cityscape for example. It will help much less with a single strong source of light.

You should never be able to see the boundary when this optimization kicks in. If you can see it, you need to make the threshold lower. The aim is to prune shadow rays that don't contribute to the final image


In the example below, increasing the low_light_threshold to 0.1 shows a good speedup in render time (in this case, more than twice as fast) with little noticeable difference in the image.

A slightly higher threshold can offer significant rendering speed increases without noticeably darkening the image (rollover image).

 

However, increasing the low_light_threshold value too much can have an adverse effect on the lighting:

The Utility shader's nlights color mode can be used to see how many lights are influencing a shading point when adjusting the low_light_threshold. 

low_light_threshold: 0 to 1. Red = all lights, blue = low values, black = no lights.

skip_background_atmosphere

It doesn't apply the atmosphere shader in the background.

sss_use_autobump

If enabled, autobump is visible in SSS. Enabling this option will take into account the effect that displacement_autobump has on the ray-traced BSSRDF's result. This helps capture the high-frequency details of the surface more accurately when using autobump.

Beware that enabling this option will triple shader evaluations with SSS, resulting in much longer render times.

max_subdivisions

A global override for the maximum polymesh.subdiv_iterations.

curves_rr_start_depth

Russian roulette control for curves (experimental). Increasing curves_rr_start_depth from 0 to 1 and setting curves_rr_aggressive to false will cause curve shapes to be sampled in a manner that is similar to non-curve surfaces, which may bring the rendering quality per AA more in line with other surface types at the expense of increased render time.

curves_rr_aggressive

Russian roulette control for curves (experimental). Increasing curves_rr_start_depth from 0 to 1 and setting curves_rr_aggressive to false will cause curve shapes to be sampled in a manner that is similar to non-curve surfaces, which may bring the rendering quality per AA more in line with other surface types at the expense of increased render time.  

reference_time

When disabling motion blur with ignore_motion_blur, the time specified by reference_time will be used instead of the shutter open time. This time is mapped on [0,1] with 0 being shutter open and 1 the shutter closed.

 

frame 

The active frame when this scene was exported (default is 0). 

fps 

The frame rate in units of frames per second when this scene was exported (default is 24). 

osl_includepath

Allows additional include search paths to be provided to OSL when compiling shaders. This option is a single string that can contain multiple search paths separated by a colon (:) or a semi-colon (;).

procedural_searchpath 

Defines a location to search for procedural nodes that load ass files (or obj or ply files).

 

plugin_searchpath 

Defines a location to search for plugins such as shaders, procedural plugins that create new node types, and volume plugins. 

For example, if you load ass files from a different plugin, you may need to set the plugin_searchpath to load plugin-specific shaders (such as mtoa_shaders).

 

enable_procedural_cache 

Enables automatic instancing of .ass procedurals.

 

parallel_node_init 

Enables parallel initialization of all scene nodes.

 

enable_new_quad_light_sampler 

Enables projected solid angle quad light sampler.

 

enable_new_point_light_sampler 

Enables projected solid angle point light sampler.


GI_sss_samples

This value controls the number of lighting samples (direct and indirect) that will be taken to estimate lighting within a radius of the point being shaded to compute sub-surface scattering. Higher values produce a cleaner solution but will take longer to render.

Some additional noise in indirect specular and diffuse GI originating from an object with SSS is expected, in particular, if diffuse samples is set lower than the SSS samples setting. To combat this type of noise you can try using higher Camera (AA) settings and lower specular, diffuse, and SSS sampling rates or increase the diffuse/specular samples. Increasing the SSS samples will only make the subsurface effect have less noise in-camera, specular reflection, and transmission rays.

In the images below you can see that there is noise in the darker areas of the eye socket. Increasing the diffuse samples will reduce this type of noise.

GI_volume_samples

Controls the number of sample rays that get fired to compute indirect lighting of the volume. Like the other sampling rate controls (Camera (AA), light samples, diffuse samples, etc.), the number of actual samples is squared, so a setting of 3 fires 3x3=9 rays. Setting it to 0 turns off the indirect lighting of the volume. Note that indirect volume lighting is tied to the 'Volume' ray depth render option, and therefore there must be at least 1 volume bounce for indirect lighting to be computed.

GI_diffuse_depth

Defines the maximum ray diffuse depth bounces. Zero diffuse is equal to disabling diffuse illumination. Increasing the depth will add more bounced light to the scene, which can be especially noticeable in interiors. You may notice subtle differences when increasing the diffuse bounces incrementally. For example, the top of the cube has no light on it with the diffuse set to 1, whereas it is visible with the diffuse set to 2.

Below is an example showing the dramatic difference that diffuse ray depth can have in an interior scene. Note the effect of the bounced light on the floor behind the door when rendering with ray depth 2 compared to ray depth 1 and 0.

We can see a difference in the appearance (and render time) when increasing the ray depth in the production scenes below: 

Diffuse ray depth: 1 (default). Roll over image to view 3.


The current Arnold code will only take one random sample after a split has happened in the ray tree, causing the regions behind transmission/specular reflections and diffuse to have much fewer shadow samples than those that are viewed directly by the camera. Splitting occurs after the first bounce.

Diagram showing how diffuse rays are propagated in an Arnold render.

You can see the effect that increasing the diffuse ray depth has on the number of rays per pixel and how that impacts render time by checking the render log. 

Rendering using the 'raycount' AOV shows the total number of rays that are created/traced to compute a certain pixel (diffuse, specular and shadow rays are shown). 

Images rendered using the 'builtin' raycount AOV

GI_specular_depth

Defines the maximum number of times a ray can be specularly reflected. Scenes with many specular surfaces may require higher values to look correct. A minimum value of 1 is necessary to get any specular reflections. 

GI_transmission_depth

The maximum number of times a ray can be refracted. Scenes with many refractive surfaces may require higher values to look correct. 

Glass surface with double-sided thickness.


GI_total_depth

Specifies the total maximum recursion depth of any ray in the scene (diffuse + transmission + specular <= Total).

GI_volume_depth

This parameter sets the number of multiple scattering bounces within a volume (defaults to 0). This is useful when rendering volumes such as clouds for which multiple scattering has a large influence on their appearance.


GI_diffuse_samples

Called Diffuse Samples in the plugins.

Controls the number of rays fired when computing the reflected indirect-radiance integrated over the hemisphere. The exact number of hemispherical rays is the square of this value. Increase this number to reduce the indirect diffuse noise. Remember that the diffuse sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and diffuse samples will tend to result in slow renders.

When diffuse samples are more than zero, camera rays intersecting with diffuse surfaces fire indirect diffuse rays. The rays are fired in random directions within a hemispherical spread. Noise is introduced when there are insufficient rays to resolve the range of values from the environment.

Increasing the number of diffuse samples will increase the number of diffuse rays fired from a point: 

Indirect Diffuse Ray sampling & Indirect Diffuse Noise


The table below shows the effect of increasing the number of diffuse samples (GI_diffuse_samples) to resolve indirect diffuse noise:

Diffuse samples (GI_diffuse_samples): 1 2 4 6. Render time: 131 156 271 427

This shows the performance impact when increasing the number of diffuse samples (GI_diffuse_samples). Because indirect diffuse rays are so prevalent, this can get expensive. In this example, the performance hit from 1 to 6 samples was over 320%.  

Indirect diffuse noise

This is one of the most common causes of noise and can have a number of different sources. It manifests as granularity in the scene, usually in shadowed areas. 

There are a couple of different methods to determine indirect diffuse noise. If you've rendered AOV's you can check the indirect diffuse AOV; if noise is present in this AOV only, you can be quite certain this ray type is responsible. You can check if an area of noise is created by indirect diffuse noise by turning diffuse samples to zero; this will effectively turn off indirect diffuse. If this ray type is responsible, then the noise will disappear. If the image darkens with the indirect diffuse gone, but the noise is still present, indirect diffuse rays are not responsible for the noise.

In the example below a directional light is pointing into an enclosed space. With diffuse samples set to 0, no light can bounce off of the surfaces, and therefore there is no indirect light in the scene. Increasing the diffuse samples to 1 allows diffuse rays to bounce around the scene. However, it produces a noisy result, especially in the corners of the scene. Increasing the diffuse samples to 3 gives an improved result. It is good practice to use this value sparingly. Increase it incrementally and see if you notice any difference in the quality of the indirect diffuse component.

Remember that the diffuse sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and diffuse samples will tend to result in slow renders.

Diffuse Surfaces Through Reflections

In scenes where you have both directly visible diffuse (bath) and diffuse visible through reflections/refractions (chrome reflection), increasing the diffuse samples will only help to improve the directly visible diffuse noise. Whereas increasing the Camera (AA) samples will improve everything uniformly (the entire image).

Diffuse samples only affect directly visible diffuse surfaces and nothing else

GI_specular_samples

Controls the number of rays fired when computing the reflected indirect-radiance integrated over the hemisphere weighted by a specular BRDF. The exact number of rays is the square of this value. Increase this number to reduce the indirect specular noise (soft/blurry reflections). Remember that the specular sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and specular samples will tend to result in slow renders.

Diagram showing how specular reflection rays are propagated in an Arnold render


In the example below the mirrored surface has a high specular_weight and specular_roughness values. In the image on the left, you can see that there are not enough GI_specular_samples and therefore there is noise in the mirror. Increasing the GI_specular_samples gives a better result.

If you reduce the number of GI_specular_samples to zero and the specular_ray_depth to zero and the noise disappears, then the noise is due to specular reflections.

GI_transmission_samples

Controls the number of samples used to simulate the microfacet-based transmission evaluations. Increase this value to resolve any noise in the transmission. If you switch this parameter to zero, the GI_transmission_depth to zero, and the noise disappears, you will know that the noise is due to transmission.

Diagram showing how transmission rays are propagated in an Arnold render


Specular Ray Sampling and Transmission Noise

While it is normally a straightforward matter to determine whether it is a specular reflection or transmission causing the noise, we need to confirm that specular rays are responsible for a given type of noise: If you've rendered AOV's you can check the indirect diffuse AOV; if noise is present in this AOV only, you can be quite certain this ray type is responsible. Also, you can switch the GI_specular_samples and GI_transmission_samples and specular_ray_depth types to zero in the Arnold render settings. Again, this essentially turns off specular rays. If the specular rays are responsible, the noise will disappear with this test. If the specular component disappears but the noise is still there, specular rays are not responsible.

preserve_scene_data

Keeps original scene data after rendering and saving .ass file. By default some node data is discarded after conversion and compression to internal data structures, to reduce memory usage. Enabling this option disables that optimization, for applications that need to access or save this data.

enable_dither2d

Enables 2D dithered sampling.

indirect_sample_clamp

The threshold to clamp away fireflies from indirect light samples and reduce noise. This works similarly to AA_sample_clamp but preserves specular highlights from direct lighting. Lower values result in more aggressive noise reduction, possibly at the expense of dynamic range.


This can also help with diffuse scenes when a light is very close to the ceiling/walls.


enable_adaptive_sampling

This option can be used to enable/disable the effect that the AA_samples_max and adaptive_threshold render options might have on the rendered image.

enable_dependency_graph

... 

enable_microfacet_multiscatter

Accounts for multiple scattering between the micro facets of the surface (for both conductors and dielectrics), which is more physically-correct and reduces energy loss on reflection, especially at higher roughness settings.

Here are renders of 4 different metals (gold, copper, silver, and nickel) with roughness increasing from left to right, and multi-scatter on/off in successive rows.


 

dielectric_priorities 

Enables the "nested dielectrics" system for IOR tracking in scenes with adjacent dielectrics. Defaults to on. 

enable_fast_ipr 

... 

AA_samples_max

Sets the maximum amount of supersampling. It controls the per-pixel maximum sampling rate and is equivalent to the units used by AA_samples. Adaptive sampling is enabled when AA_samples_max > Camera (AA) samples and Camera (AA) samples >= 2. Scenes with a large amount of depth of field or motion blur may require higher Max. Camera (AA) values. This parameter can also help with 'buzzing' speculars and hair shading as well.

20 (default). Rollover images to view 100. Interior noise (left), motion blur noise (right).

Setting AA_samples to 1 or lower does not yet allow Arnold to calculate the measures needed for adaptive thresholding, and setting AA_samples_max to AA_samples or lower does not leave a margin for any adaptive AA samples.

Variance filter showing effect of Max. Camera (AA)

AA_adaptive_threshold

The threshold which triggers/terminates adaptive-AA. This value controls how sensitive to noise the adaptive sampling algorithm gets. Lower numbers will detect more noise. The default value (0.015) should work well for most scenes.

Variance filter showing effect of AA Adaptive Threshold


progressive_render

Completes the render call in multiple passes. During each of the intermediate passes, drivers that do not output to a file will be invoked after each tile has completed, which allows for display drivers to show a result whose noise progressively converges towards the result at the final Camera (AA) sample settings.

Note that this option slows down render times and increases memory usage, which is why it's only supported during interactive renders for fast preview.

 
Disabled (default)
Enabled

render_device

...

render_device_fallback

...

gpu_default_names

...

gpu_default_min_memory_MB

...

gpu_max_texture_resolution

Maximum mipmap resolution that will be loaded. Applied to tx files that are mipmapped EXRs.

min_optix_denoiser_sample

...



Enables the "nested dielectrics" system for IOR tracking in scenes with adjacent dielectrics
  • No labels