renderer procedural - Arnold for Katana

The renderer procedural location is used to invoke Arnold procedural plugins.

Standard attributes it searches for:

• rendererProcedural.procedural: string path to a .ass file, or to an Arnold procedural plugin DSO. In KtoA 1.1 / Arnold 4.2, this attribute is required, but in KtoA 2.0 / Arnold 5.0, this is optional if the plugin is found via other means, such as setting procedural_searchpath on the ArnoldGlobalSettings node or the environment variable ARNOLD_PLUGIN_PATH.
• rendererProcedural.node: string for the Arnold node entry for the plugin DSO.  In KtoA 1.1 / Arnold 4.2, this field has no effect; in KtoA 2.0 / Arnold 5.0, this is required. The plugin DSO itself will supply a new Arnold node type, and this must match that type. Note that for .ass procedurals (AKA standins or archives), the node type is simply procedural.
• rendererProcedural.useInfiniteBounds: boolean (int attribute of value zero or one) indicating whether Arnold should load this procedural immediately, or if it should wait until a ray intersects the bounds of the procedural to begin loading it. There are performance advantages and disadvantages either way, depending on the scene and the contents of the procedural. Only applies in Arnold 4.x (KtoA 1.x); in newer versions, procedurals are always expanded on startup.
• bounds: double-precision float attribute with six values indicating the expected bounding box of the procedural contents, in order of xmin, xmax, ymin, ymax, zmin, zmax. Note that if this is missing, Arnold will force the procedural to load immediately, and the bounds will also be ignored if rendererProcedural.useInfiniteBounds is turned on.
• rendererProcedural.args.__outputStyle: this string indicates the way procedural arguments are passed along to the procedural in Arnold.
  • With the classic style, it will send a single parameter named data as a string with space-separated names and values of arguments to the procedural, e.g., "arg1 0.0 arg2 somestring ...".  Note that very few Arnold procedurals use or understand this style, and most use the typedArguments style instead.
  • With the scenegraphAttr style, it will look for the various rendererProcedural.args.* parameters, but it will stick them into the data parameter as in the classic style.  Note that very few Arnold procedurals use or understand this style, and most use the typedArguments style instead.
  • With the typedArguments style, it will look for the various rendererProcedural.args.* parameters and translate them directly as typed parameters for the Arnold procedural. E.g., if rendererProcedural.args.myValue is an integer attribute, it will be translated as an Arnold INT parameter on the procedural.
• rendererProcedural.args.__skipBuiltins: this integer attribute indicates that built-in arguments to the procedural that Katana normally emits should be skipped.  These parameters are: frame, shutter, cropwindow, and katanaFullName.
• rendererProcedural.args.* attributes: these are translated into Arnold parameters on the procedural node. Please see rendererProcedural.args.__output_style and rendererProcedural.args.arnold_hint__* for more information on how they are interpreted.
• rendererProcedural.args.arnold_hint__* attributes: Because there is not always a one-to-one correspondence between Katana attribute types and Arnold parameter types, these hints can be used to guide parameter translation to fit specific requirements of a procedural.  Parameters are of the form arnold_hint__ *paramname* where paramname matches rendererProcedural.args. *paramname*.  Each hint consists of an array of two strings, the first indicating the hint name and the second the value of the hint:
  • type: value is one of boolean, byte, uint, pointer (for integer attributes), or rgb, rgba, vector, vector2, matrix (for float attributes), or pointer (for string attributes).  Note that in KtoA 1.1 / Arnold 4.2, float attributes can be set to type point, point2, but not vector2 since that is an Arnold 5.0 type.  As an example. a katana attribute rendererProcedural.args.myValue with a value of 10 would normally be translated as an Arnold INT parameter, but with 'type' 'byte' it would be translated instead as an Arnold BYTE parameter instead.
  • array: value of true or false to force the attribute to be an array even if it only has one value or element. E.g., a Katana attribute rendererProcedural.args.myValue with an integer value of 10 will become an Arnold array of size 1 (with a single 10 value) with this on, otherwise it would just be translated as an Arnold INT parameter, not as an array.
  • key_array: value of true or false to force the attribute elements to be motion-blur keys instead of single-time arrays. E.g., a katana float attribute rendererProcedural.args.myvalue with floating point values 1.0 and 2.1 will become an Arnold parameter myValue 1 2 FLOAT 1.0 2.1 instead of myValue 2 1 FLOAT 1.0 2.1.
  • clone : value of paramname where paramname is the name of another attribute.  This will instruct KtoA to copy the value of another attribute into this one, ignoring the original value of this attribute.  This is useful to copy an existing parameter into one that the procedural expects (but is named differently). E.g., this is used by the ArnoldXGen implementation to copy from the usual shader attribute that gets filled out by Katana's MaterialAssign node to the xgen_shader parameter, as the xgen_procedural plugin expects.
  • rename : value of *newname* where newname is the new name of the parameter.  This is useful if the parameter conflicts with a built-in name, such as frame, and you skip builtins and need to set the name after using an alternate (to avoid a conflict).
• rendererProcedural.libraries: a string array attribute listing paths to dynamically-linked libraries to load before the procedural plugin is loaded (Linux only). This is useful if your procedural plugin needs to have other libraries loaded first, but you do not want to pollute the environment variable LD_LIBRARY_PATH with them prior to launching Katana. E.g., this is used by the ArnoldXGen implementation to pre-load libraries from Maya and MtoA as required for the xgen_procedural plugin.
• rendererProcedural.libpaths: a string array attribute listing paths to directories with dynamically-linked libraries needed by a procedural plugin before it is loaded (Windows only).  This is useful if your procedural plugin needs to have other libraries loaded first, but you do not want to pollute the environment variable PATH with them prior to launching Katana. E.g., this is used by the ArnoldXGen implementation to pre-load libraries from Maya and MtoA as required for the xgen_procedural plugin.
• geometry.arbitrary.*: these attribute groups will be translated per the usual arbitrary user data rules, with one exception: only primitive (Arnold constant ) scope data will be included because the other scopes don't make sense for procedurals.
• instance.ID: procedurals with this string present (that have the same string value) will automatically become instances of each other.