polymesh

Class

Shape

Synopsis
A polygon mesh.

 


 

nsides
An unsigned int array that defines the number of sides per face.
vidxs
An unsigned int array of indices to vertices.
polygon_holes

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.

nidxs
An unsigned int array of indices to normals.
uvidxs
An unsigned int array of indices to UV coords.
crease_idxs
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.

Vertex normals can't be creased, so even though you can get a crease in the silhouettes, the shading normals will still "smooth" over the crease.

crease_sharpness

A float array of crease sharpness values. This has a half length of "crease_idxs".

shidxs
A byte array of shader indices. Arnold supports up to 256 different shaders per object.
vlist
A point array of vertices. Multiple keys are supported to obtain deformation motion blur.
nlist
A point array of vertex normals. Multiple keys are supported to obtain proper deformation motion blur.
uvlist
A point2 array of UV coordinates.
smoothing
This boolean defines if the normals will be faceted or smooth.
subdiv_type
This enum. Defines the subdivision rule that will be applied to the polymesh at render time. Possible values are catclark (catmull clark) and linear.

None

Ignores any subdivision and renders the mesh as it is.

Linear

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.


subdiv_iterations

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. 

subdiv_adaptive_error
The maximum allowable difference in pixels or object space (if subdiv_adaptive_space = object) between the adaptively chosen subdivision level and the "limit" subdivided surface. Either a "flatness" or "edge_length" metric can be used, depending on polymesh.subdiv_adaptive_metric. It refers to the acceptable tessellation error as seen from the camera, in pixels. If there's no displacement, then the pixel error represents the distance (in pixels) from the subdivided mesh to the "true" or "limit" surface -- sort of a "flatness" heuristic. 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. If displacement is enabled, then the pixel error represents the final size of the subdivided quads (again, in pixels). A value of 0 disables adaptive subdivision, reverting to uniform subdivision, which sometimes is more stable in animation.
subdiv_adaptive_metric
The metric used to determine the amount of error between a given subdivision level and the limit surface. Can be either "flatness" where the curvature of the mesh in pixels is the feature used to choose the adaptive subdivision level, "edge_length" where the length of the polygonal edges in pixels is used, or "auto" which uses "flatness" when no displacement map is applied and "edge_length" when a displacement map is applied to the polymesh.


subdiv_adaptive_space 

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.
Raster

Corresponds to adaptive subdivision in raster space.  

Object 

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.

subdiv_frustum_ignore

Disables Subdivision frustum culling of the mesh.

subdiv_uv_smoothing

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.

subdiv_smooth_derivs

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).

disp_map
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)
disp_padding

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.

disp_height
A value used to scale the effect of the displacement shader applied to the mesh.
disp_zero_value
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.
disp_autobump
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.
visibility

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).

autobump_visibility
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.
sidedness

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.

receive_shadows

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

self_shadows

Determines whether or not the object casts shadows on itself.


invert_normals

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

ray_bias

Raytrace bias value specified for the object.

matrix

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.)

shader

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

opaque

The opaqueness (transparency) of the object. By default, all objects are marked as opaque, because that speeds up the rendering considerably. Note that this flag is not set automatically by adding a transparent material to the object, it has to be set manually!

use_light_group

A boolean to enable selective light linking

light_group

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

use_shadow_group

A boolean to enable selective shadow linking.

shadow_group

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

trace_sets

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

id

Unique ID for a node in the Arnold scene. 

motion_start

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

motion_end

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

transform_type

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.

step_size

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. 

volume_padding

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 the displacement amount.

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

 


user attributes

 

subdiv_face_iterations

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

 

face_visibility

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.

pref

... 

 

 

 

  • No labels