A polygon mesh.

An unsigned int array that defines the number of sides per face. Arnold assumes all polygons have 3 sides (triangles) if the array is not explicitly given. 
An unsigned int array of indices to vertices.

An unsigned int array to create holes. For instance, {1, 0, 2, 0} specifies that faces 1 and 2 are holes in face 0. Multiple holes per face are supported. The winding of a face used as a hole does not need to be reversed. Also, note that polygonal holes are ignored when a mesh is subdivided.

Per-face data like shader indices ("shidxs") or user data also needs to be specified for faces tagged as polygon holes, even though that data will be not be used.

An unsigned int array of indices to normals.
An unsigned int array of indices to UV coords.
An unsigned int array of crease edges. An edge is defined here with the indices for its two vertices. Because of this crease_idxs always has an even number of elements. A creased vertex can be defined by repeating twice the same vertex. If crease_sharpness is not present then sharpness will always be considered to be infinite ("hard creases") for edges and vertices. As of Arnold 5.2.2, vertex normals are not properly computed for hard creases in adaptive mode, and will not show the expected discontinuity. This can be solved using the regular mode, or by increasing the subdivision level.

A float array of crease sharpness values. This has a half-length of "crease_idxs". If not present all creased edges and vertices will be considered "hard" or having infinite sharpness.

A byte array of shader indices. Arnold supports up to 256 different shaders per object.
A point array of vertices. Multiple keys are supported to obtain deformation motion blur.
A point array of vertex normals. Multiple keys are supported to obtain proper deformation motion blur.
A point2 array of UV coordinates.
This boolean defines if the normals will be faceted or smooth.

This enum. Defines the subdivision rule that will be applied to the polymesh at render time. Possible values are catclark (catmull clark) and linear.


Ignores any subdivision and renders the mesh as it is.


Linear subdivision puts vertices in the middle of each face.

The Catmull–Clark algorithm is used to create smooth surfaces by recursive subdivision surface modeling. The resulting surface will always consist of a mesh of quadrilateral faces.


The maximum number of subdivision rounds applied to the mesh. When subdiv_pixel_error is 0 the number of rounds will be exact instead of a maximum. 

Bear in mind that each subdivision iteration quadruples the number of polygons. If your object has 2 levels of subdivision iterations set and 4 additional iterations set in Arnold, that's 6 subdiv iterations total and therefore 426936 * 4^6 = 426936 * 4096 = 1.7 Billion polygons.

The maximum allowable difference for the chosen metric (subdiv_adaptive_metric) in the chosen space (subdiv_adaptive_space). The smaller the error, the closer to the limit surface a mesh will be and the less inter-frame "popping" when the subdivision level jumps, at the expense of using more polygons. A value of 0 disables adaptive subdivision, reverting to uniform subdivision, which can be more stable in animation.
  • a value of 1.0 with subdiv_adaptive_space set to "raster" and subdiv_adaptive_metric set to "edge_length" will subdivide until all edges are shorter than 1 pixel.
  • a value of 1.0 with subdiv_adaptive_space set to "object" and subdiv_adaptive_metric set to "flatness" will subdivide until the tessellation is closer than 1 unit in object space to the limit surface.

The metric used to determine the amount of error between a given subdivision level and the limit surface.  

  • edge_length: no final edge will be longer than subdiv_adaptive_error.
  • flatness: the distance to the limit surface will be smaller that subdiv_adaptive_error.
  • auto: in general, flatness will produce better approximation for the same number of tessellated triangles. But since subdivision tessellation does not take into account displacement, "flatness" might stop way too early and miss a lot of displacement detail (think of a displaced plane: a single quad will represent the plane exactly, but will not have enough vertices to show the displacement's detail). To avoid this issue "auto" uses the "edge_length" metric if the polymesh has a displacement shader assigned, otherwise, it will use the "flatness" metric.


Adaptive subdivision in raster space is problematic when instancing: A tessellation that is good for one instance will not be good for another further away. Using object space subdivision will ensure that all instances will subdivide to the proper level.

Corresponds to adaptive subdivision in raster space.  


This method corresponds to adaptive subdivision in object space. This is useful for instances or when adaptive tessellation is desirable regardless of a specific camera. Arnold will warn when raster-space tessellation is used on more than one visible instance.


Disables Subdivision frustum culling of the mesh.


The face-varying "limit" dPdu and dPdv vectors computed during subdivision are stored and used for shading instead of computing face-constant dPdu and dPdv vectors on the fly during shading. This can be useful for anisotropic shaders but has a storage cost. Choose between linear, pin borders, pin corners,  or smooth.


You may notice faceting appear in specular highlights when using anisotropy. It is possible to remove the faceted appearance by enabling smooth subdivision tangents (via Arnold subdiv_smooth_derivs parameter). Take into account this requires a subdivision iteration of at least one in the polymesh to work.

Below is an example consisting of a sphere with an anisotropic highlight. On the left image, polygon faceting is noticeable in the specular highlight. On the right image, the specular highlight is much smoother because Smooth Subdivision Tangents has been enabled for the mesh.

If enabled, it will compute smooth UV derivatives (dPdu and dPdv), which is the reason you need a UV map associated with the object).

When the option is disabled, these derivatives are constant per triangle, which results in a faceted appearance whenever dPdu and dPdv (like in the anisotropic computations from the Standard shader).

Enabling this option will have a memory overhead (roughly 100 extra bytes of data per vertex per keyframe).

An array of nodes pointing to the displacement shader or shaders in the case of per-face shader assignment (it will use the same assignations as shidxs).

Padding defines how much to extend the bounding box of the object so that it can include any additional displacement coming from the displacement shader. When the bounding box is hit first by a ray, the displacement will be computed, so an unnecessarily high value will decrease the rendering efficiency. On the other hand, a low value could result in a clipping of the displaced mesh.

A value used to scale the effect of the displacement shader applied to the mesh.
Offset applied to the displacement effect. This allows, for example, a texture-mapped displacement shader returning values in the 0 to 1 range to displace both inwards and outwards in a -0.5 to 0.5 range when set to 0.5.
Automatically converts any high-frequency detail in the displacement shader that could not be represented in the subdivided & displaced geometry into bump map detail that will at least affect the shading normal. When turned on this option will usually allow displaced meshes to use lower subdivision levels and still look virtually indistinguishable from higher subdivision levels with the option turned off.

You can selectively disable an object's visibility for the various types of rays in the renderer. By default, objects are visible to all types of rays. Camera - Camera (AA) rays (i.e., primary or view rays). Shadow - shadow rays fired in the direct lighting calculations. Specular - specular_reflection rays. Transmission - transmission rays. Diffuse - indirect_diffuse rays (i.e. global illumination or GI rays). Specular - indirect_specular rays (i.e. specular reflection rays).

To set the visibility, add up the values of the rays you want to "see" the object.

For example, if an object is visible to the camera (primary visibility), and to transmission (both diffuse and specular), then that’s visibility 13 (1 + 4 + 8).

Ray typeDecimal Value
Camera (Primary Visibility)1
Shadow (Casts Shadows)2
Diffuse transmission4
Specular transmission8
Diffuse reflection32
Specular reflection64
SSS (subsurface)128

You can selectively disable an object's bump mapping from autobump for the various types of rays in the renderer.  The ray types are the same as the 'visibility' parameter. This defaults to all rays except for rays that have undergone diffuse bounces. By disabling it for more ray types (like reflection, refraction, glossy), rendering can be made faster with little degradation in image quality.

Just like you can disable the visibility for specific ray types, you can also change an object's sidedness depending on the ray type. By default, objects are double-sided for all rays. By unclicking any of these checkboxes, the object will become single-sided, which means that those parts of the object whose normal vector points away from the incoming ray direction will not be rendered.


Determines whether or not the object picks up shadows from other objects.


Determines whether or not the object casts shadows on itself.


Invert normals (so that normals face inwards and not outwards).


Raytrace bias value specified for the object.


Transformation matrix. This can be either a single matrix or an array of matrices that define the SRT motion of the object for the current frame (the matrices define the motion for the full-frame, not just between the shutter open - close time).


An array of nodes pointing to the shader or shaders in the case of per-face shader assignment.


As of Arnold 5.3, this flag is set automatically by changing the opacity or transmission on a material.

Determines whether the object is considered opaque (transparent). By default, Arnold built-in shaders set the opaque flag automatically, based on whether or not the shader settings would require disabling the opaque flag on the object to render correctly. For example, it's no longer necessary to manually disable the opaque flag to get transparent shadows for a glass shader.

Exceptions are curves and points when min_pixel_width is in use, and OSL shaders.  


A boolean to enable selective light linking


An array of nodes pointing to the lights that will affect the node if use_light_group is enabled.


A boolean to enable selective shadow linking.


An array of nodes pointing to the lights that will not cast shadows on the polymesh, if use_shadow_group is enabled.


An array of strings each of which names a trace set. A custom shader must be used to make effective use of these strings via the AiShaderGlobalsSetTraceSet and the AiShaderGlobalsUnsetTraceSet API calls.

It is possible to tag objects to be part of one or many trace sets. The trace_set shader tags specific rays with an inclusive or exclusive trace set. Both geometry and rays can be tagged with trace sets:

  • A piece of geometry can have none or any number of trace set tags.
  • A ray can optionally have one trace set tag, and it can be exclusive or inclusive.

The way those two tags interact makes it possible to control visibility for specific rays:

  • A ray with no trace set will hit all geometry.
  • A ray tagged with an inclusive trace set will only hit geometry which has that trace set tag.
  • A ray tagged with an exclusive trace set will only see geometry that does NOT have that trace set tag.


Unique ID for a node in the Arnold scene. 


The time at which the first motion key of the shape is sampled. Other motion keys must be uniformly spaced within this range. Times can be absolute or relative as long as shutter and motion times use the same convention. By convention, the times are frame relative. For example, start and end times -0.5 to 0.5 indicate that two motion keys will be sampled midway between the previous and current frame, and the current frame and next frame. This is applied to cameras, lights, and shapes.


The time at which the last motion key of the shape is sampled. Other motion keys must be uniformly spaced within this range. Times can be absolute or relative as long as shutter and motion times use the same convention. By convention, the times are frame relative. For example, start and end times -0.5 to 0.5 indicate that two motion keys will be sampled midway between the previous and current frame, and the current frame and next frame. This is applied to cameras, lights, and shapes.


Specifies what type of motion the object has. Options are linearrotate_about_center, and rotate_about_originlinear corresponds to the linear interpolation between matrices. rotate_about_origin corresponds to curved_motionblur=true. Unlike, rotate_about_origin which sets the rotation pivot at the origin, rotate_about_center will rotate about the object's center. This is the default mode and is useful for wheels, propellers, and other objects which spin.


Sets the size for sampling inside the volume. It should be small enough to capture the smallest feature in the volume (aka the Nyquist limit). If the size is too large, aliasing, bias, or banding will appear. Smaller (and therefore more accurate) sizes will increase render times while larger sizes will render more quickly. 

Step_size basically controls the rate at which the volume shader gets called. The value indicates the average distance between adjacent volume shader samples along a given ray, in world space units. Generally, you will want this setting to be as large as possible before visibly noticeable artifacts occur, and in the case of voxelized volumes no smaller than about half the size of your voxels (in world space). A low step_size will increase render times. For example, when the step_size is 0.1 and the volume is 10 units big in world space, there are approximately 100 primary samples and therefore the volume shader is called 100 times.

The step_size has a fixed size, therefore, the larger the container the more steps will be taken and the longer it will take to render. Also, beware that if the step_size is too small your render times will increase. If you cannot see the rendered volume, you may need to reduce the step_size value.


Enlarge the volume by Padding. This is useful when displacing a volume with a noise for example. Note that this slack applies not only to the bounding box but also to the voxels used for ray extents inside the bounding box. When velocity motion blur is enabled, some extra padding is computed, based on the maximum value of the velocity field, and the maximum of the velocity padding and user padding is applied. When padding exceeds the bounding box maximum dimension, the ray extents acceleration makes little sense and is disabled, so you should set the padding as tightly as possible.

For best performance, this should be set as low as possible, while still covering the maximum displacement amount.

The amount of padding to add to the volume bounds for displacement

user attributes


The subdiv_face_iterations integer primitive attribute (uniform user data) controls the maximum amount of subdivisions per face when doing adaptive subdivision (i.e. when pixel_error > 0).

Example showing random values of subdiv_face_iterations in the [0-4] range on the faces of a grid


You can specify visibility per face on a mesh by using the built-in face_visibility uniform user data which is set as an array of AI_TYPE_BOOLEAN values.



  • No labels
Privacy settings / Do not sell my personal information / Privacy/Cookies