hairSystem node

Go to: Related nodes. Attributes.

This node is used to dynamically simulate long hair motion with collision. This takes an array of start and rest positions from follicle nodes and computes an array of output hair positions(point arrays). When the current time input steps forward this computes a new position based on its current position. When the time is rewound to the start frame it sets the positions to the input start hair positions.

Node name	Parents	Classification	MFn type	Compatible function sets
hairSystem	shape	dynamics	kHairSystem	kBase kNamedObject kDependencyNode kDagNode kShape kHairSystem

Attributes (170)

Attribute quick index omitted (too many attributes to show them all).

Long name (short name) Type Default Flags

simulationMethod (sim) enum 3

This controls the simulation level. If Off is selected then there is no output. Static positions the output hair aways at the start position with no dynamics(totally stiff). Dynamic Follicles Only will avoid generating output for passive follicles(if any). This is useful for faster preview of complex hairsystems. All Follicles will compute the full simulation.

inputHair (ih) hairCurve NULL

Input hair

inputHairPin (ihp) hairPin NULL

Input hair pin constraints

collide (cld) bool true

If true then collide with connected objects.

collideStrength (clst) float 1.0

This controls the strength of the push used to resolve collisions. For most purposes the default of 1.0 is best. In some cases, like hairs trapped by being squished, lowering the collide strength may make the simulation smoother and more stable. For a value of zero there will be no collision and for values less than one collisions may fail. Values larger than one will result in strong bounces that while perhaps useful in some situations could result in instabilities. Negative values would impart a push through a surface instead of colliding.

collideOverSample (cos) integer 0

This allows one to adjust the quality collision sampling. larger values will help keep hairs from pushing through surfaces.

selfCollide (scd) bool false

If true then simulate hair/hair interaction.

collideGround (cdg) bool false

If true then collide with an infinite plane at the ground height. This collision does not impact the speed of the solution, unlike geometry collisions.

groundHeight (ghe) double 0.0

When collide ground is on, this determine the height of the ground plane.

collisionFlag (cofl) enum 1

Controls the components of the hair that collide. Thickness is added to the collisions, so if vertex is selected the collisions are with spheres around each vertex. If edge is use then collisions are with cylinders around the edges as well as with spheres at the vertices.

selfCollisionFlag (scfl) enum 1

Controls the components of the hair that self collide. Thickness is added to the collisions, so if vertex is selected the collisions are with spheres around each vertex. If edge is use then collisions are with cylinders around the edges as well as with spheres at the vertices. Note that if vertex is used then the self collision thickness needs to be greater than zero or there will be no self collision.

collisionLayer (cll) float 0.0

Layer for collision with other objects. Objects with the same layer value intercollide in a normal fashion, while if the layer values are different the object with the lower value will appear more massive for the purpose of the collision. If the difference is one or more then the object with the lower value will push but not be pushed. This works also with collisionLayerRange on the solver node, and can be used as a way of excluding collisions( in addition to exclusion constraints ).

evaluationOrder (evo) enum 1

This determines whether hair segments are evaluated in a cumulative or an order independant fashion. The sequential mode has a slight bias towards the root of the hair, but creates hair that is stiffer and less stretchy for a fixed number of iterations. Thus the sequential mode can allow for faster simulations because one can use lower iterations settings.

stretchResistance (stch) float 10.0

Defines the amount that the material will resist stretching when under tension. Large values generally require more computation, so they may result in longer simulation times. Also one may need to additionally make substeps on the solver higher to keep stretching low.

compressionResistance (comr) float 10.0

Defines the amount that the hair will resist compression along a segment.

restLengthScale (rlsc) float 1.0

This multiplies the rest length of the hair allowing it to expand or contract. To avoid sudden snapping at the start of the simulation key this to 1.0 at the first frame and vary gradually.

twistResistance (trs) double 0.0

The amount the hair can dynamically twist along its length. This is mainly noticable when the hair rest shape is not straight.

bendResistance (bnd) float 1.0

Defines the amount that the material will resist bending when under strain. Large values generally require more computation, so they may result in longer simulation times. Note that when the rest shape is not straight one will also need some twistResistance to preserve the rest shape.

extraBendLinks (ebdl) integer 0

This helps with bend and twist resistance when hairs have a lot of cvs. It creates extra bend links between vertices other than the nearest neigbor. It can create unnatural effects in some cases where the hair is stiffer at large scales than it is on small scales.

stiffness (sfn) double 0.15

The amount the hair can flex with regard to the rest position.

stiffnessScale (sts) compound n/a

Stiffness Scale affects the stiffness from root to tip of the hair. The left of the graph is the root and the right is the tip. Typically the root of a hair is thicker and thus stiffer than the tip. This attribute multiplies the stiffness parameter value, so a value of 1.0 will leave the stiffness unchanged. If the stiffness attribute is zero then this parameter will have no effect, as zero times a number is always zero.

stiffnessScale_Position (stsp) float 0.0

Position of ramp value on normalized 0-1 scale

stiffnessScale_FloatValue (stsfv) float 0.0

Ramp value at the sibling position

stiffnessScale_Interp (stsi) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

lengthFlex (lfx) double 0.0

The amount the hair can stretch along its length.

damp (dmp) double 0.0

This dampens the relative shape change of individual hairs. It affects how the hair bends and stretches.

stretchDamp (sdmp) float 0.1

Defines how much the velocity due to stretch along the internal connections will be damped. Increasing this value will allow the hair to stretch without bouncing.

drag (drg) double 0.05

This simulates friction with the air, in addition to helping to stabilize the simulation. When the damp is 1.0 the hair will behave as if it has no inertial motion or followthrough: it will move as if in a thick fluid.

tangentialDrag (tdrg) float 0.1

Defines the component of drag along the hair direction. With a value of zero a hair has no resistance to moving tangentially or along the direction of its shape. For high drag levels with low tangential drag the hair can behave a bit like a snake in water. When the tangentialDrag is 1 then the effect of drag is even in all directions. Thus for values of zero the behavior is like a slippery tube and for 1 is like a sphere.

friction (frc) double 0.5

This simulates friction with on contact with other surfaces.

stickiness (stck) float 0.0

Defines how well the hair will stick to other nThings If the total stickiness of the things interacting is 2.0 or more, they will stick and stay stuck. Stickiness will have the effect of increasing friction and reducing bounce.

bounce (boce) float 0.0

Defines the self-collision bounce for each input/output mesh

mass (mss) double 1.0

This controls the simulated mass of the hair cvs. This affects the the way it collides with other dynamic objects as well as the effect of air drag. Heavy hair will be more like a chain with less drag because it is much more massive than the air.

dynamicsWeight (dw) double 1.0

Scale factor for the effect of attached dynamic fields on the hair motion.

collideWidthOffset (wid) double 0.0

This value is added to clumpWidths before determining collisions. The amount is relative to the clump width. It can be used to handle situations where there is some interpenetration, or where one has passive hairs that are outside the boundaries of active clumps. In cases where the hairs collide too far off an object, one can use negative values to allow a little interpenetration of clumps.

selfCollideWidthScale (scws) float 1.0

Allows the thickness of hairs and clumps to be scaled for self collision. If it is 2.0 then hairs will have twice the width for self collision than for collision with other objects.

staticCling (stc) double 0.0

This value determines the amount of local attraction between self colliding hair clumps. It simulates static cling and friction between hair clumps. Self collide must be on for this to have an effect. Motion of masses of hair tend to be very damped due to the effects of self collision, friction and static. This can be helpful in achieving natural motion. Negative values can be used to make hairs repel from each other.

repulsion (rpl) double 0.5

This value determines the amount of repulsion when clumps are overlapping. When this is 1.0 clumps are pushed apart in a single timestep, although this may cause excessive motion in some cases, especially when clumps start out overlapping. Lowering this value can help damp such motion yet still preserve general body in the hair.

numCollideNeighbors (ncn) integer 4

This controls how many neighbor hairs to include in the self collision. Each hair clump with collide with the closest hairs( relative to the separation at the base of the hair on the start frame ). If this number is equal to the total number of clumps then all hairs will collide with all other hairs in the hair system, but the simulation will be slow.

maxSelfCollisionIterations (msci) integer 1

Maximum number of self collision iterations per subcycle.

iterations (itr) integer 4

This controls number of iterations per time step of the hair solver. This affects hair stiffness and length flex, as well as the accuracy of collisions. Large values are required for very high stiffness. Note that large value will also increase the time required by the solver

drawCollideWidth (dwd) bool false

If true then draw circles around each line representing its width used for collision.

widthDrawSkip (wds) integer 2

This allows one to adjust the quality of the tube collide width drawing. A value of zero will cause a circle to be draw for every segment of the tube, which may clutter the display for tube with many segments.

ignoreSolverGravity (igsg) bool 0

Turn off the effect of the gravity that is defined on the solver node.

ignoreSolverWind (igsw) bool 0

Turn off the effect of the wind that is defined on the solver node.

gravity (grv) double 0.98

A built in downward force in y simulating gravity.

turbulenceStrength (tst) double 0

Increasing this will increase the amount of force applied by the turbulence

turbulenceFrequency (tfr) double 0.2

Lowering this will make the turbulence vortices larger. This is a spacial scale factor on the turbulence function and has no effect if the turbulence strength is zero.

turbulenceSpeed (tbs) double .2

Rate at which turbulence pattern changes over time

attractionDamp (ad) double 0.0

Attraction to the start curve is done by altering the current velocity of the hair so that it will meet the start position. This control damps out this value. When this value is one, the motion towards the start curve is fully damped leaving simply the start position plus field forces. This is useful for applying fields on top of previously animated hairs. To acheive this affect, you should set attractionDamp = 1.0 and make the stiffness ramp all 1.0.

startCurveAttract (sct) double 0.0

This value determines the amount of attraction of the current hair position to the start position. Normally one would leave this at zero for long flowing hair. However for short hair it can be difficult to make hair stiff enough. This is good when the hair needs to be very stiff, and yet at the same time have some dynamic properties. At a value of one the hair position will be the start curve position( relative to the transformed follicle position ), only collisions and forces will still deflect the hair. Without startCurveAttract this could otherwise require a very high iteration count and damp value, especially if there are many cvs per hair.

attractionScale (ats) compound n/a

This value attenuates the startCurveAttract value along the length of the follicle. The left of the graph is the root and the right is the tip. If the startCurveAttract attribute is zero then this parameter will have no effect, as zero times a number is always zero.

attractionScale_Position (atsp) float 0.0

Position of ramp value on normalized 0-1 scale

attractionScale_FloatValue (atsfv) float 0.0

Ramp value at the sibling position

attractionScale_Interp (atsi) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

motionDrag (mdg) double 0.0

This value determines the amount the current hair is damped relative to the transform of the follicle. If this value is 1 then the hair will fully move with the follicle, but its shape can still be changed by other forces. Unlike startCurveAttract which makes the hair like a stiff spring this pushes the hair with the motion of the follicle, but allows it to change shape. It is as if there is a block of air or mud (depending on the motion damp intensity) that moves with the follicle and tends to drag the hair with it. The normal drag attribute instead drags relative to zero motion, rather than the motion of the follicle base. This is useful in making hair stiff with fewer iterations and it can simulate the combination of self collision of hairs along with friction and trapped air. The relative range of affect along the hairs for motion drag is scaled by the stiffness ramp. It looks most natural when there is more drag at the base.

displayQuality (dpq) double 100.0

percentage of hairs within clumps to display for interactive draw This corresponds to the display quality on paint effects strokes.

noStretch (nst) bool false

If true then fix the length of the output hairs to be constant. The internal dynamic hairs will still stretch, but the output hair will be locked to the base point. Care should be taken when using this attribute. If the lengthFlex is low or the iterations are low then the dynamic computed hair may protrude much beyond the end of the rendered hair, and the behavior could look unnatural.

subSegments (ssg) integer 0

This determines the number of smoothly interpolated segments at render time. The hermite interpolation smooths the shape of the line, in addition to providing more detail for curls and fine features. The added segments affect the rendered look only, and do not affect the dynamic simulation.

clumpWidth (cwd) double 0.3

This is the base or maximum width for the dynamic hair groups.

clumpWidthScale (cws) compound n/a

Clump Width Scale affects the width from root to tip of the hair clump. The left of the graph is the root and the right is the tip. Often one may wish the hairs within the clump to come to a tip at the end of the clump, in which case the right value should be smaller than the left. This attribute multiplies the clumpWidth parameter value, so a value of 1.0 will leave the clumpWidth unchanged. If the clumpWidth attribute is zero then this parameter will have no effect, as zero times a number is always zero.

clumpWidthScale_Position (cwsp) float 0.0

Position of ramp value on normalized 0-1 scale

clumpWidthScale_FloatValue (cwsfv) float 0.0

Ramp value at the sibling position

clumpWidthScale_Interp (cwsi) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

clumpTwist (ctw) double 0.0

This is the rotation of the clump group about the primary hair axis.

clumpCurl (clc) compound n/a

Clump Curl controls the rate of curling about the primary axis of each hair clump. The left of the graph is the root and the right is the tip. The mid value of the ramp(0.5) represents no twist while values greater than that will result in positive twisting while smaller values will cause twisting in the reverse direction.

clumpCurl_Position (clcp) float 0.0

Position of ramp value on normalized 0-1 scale

clumpCurl_FloatValue (clcfv) float 0.0

Ramp value at the sibling position

clumpCurl_Interp (clci) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

clumpFlatness (cfl) compound n/a

Clump Flatness affects the flatness of the clump group from root to tip. The left of the graph is the root and the right is the tip.

clumpFlatness_Position (cflp) float 0.0

Position of ramp value on normalized 0-1 scale

clumpFlatness_FloatValue (cflfv) float 0.0

Ramp value at the sibling position

clumpFlatness_Interp (cfli) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

bendFollow (bnf) double 1.0

This determines how much the rotation of the overall clump follows the primary hair axis. Short straight fur may work better with this value near zero, as the end of wide clumps will blend better when they twist. With this value at 1.0 the cross section of the hair clump will always be perpendicular to the tube direction, which can work well for long relatively thin clumps. When this value is zero the cross section is always perpendicular to the surface normal at the start of the hair clump.

hairWidth (hwd) double 0.01

This is the global width for hairs.

hairWidthScale (hws) compound n/a

Hair Width Scale affects the width from root to tip of the hairs. The left of the graph is the root and the right is the tip. This attribute multiplies the hairWidth parameter value, so a value of 1.0 will leave the hairWidth unchanged. If the hairWidth attribute is zero then this parameter will have no effect, as zero times a number is always zero.

hairWidthScale_Position (hwsp) float 0.0

Position of ramp value on normalized 0-1 scale

hairWidthScale_FloatValue (hwsfv) float 0.0

Ramp value at the sibling position

hairWidthScale_Interp (hwsi) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

baldnessMap (bmp) double 1.0

This reduces the hair density using a texture. The texture used must be a 2D texture.

opacity (opc) double 1.0

This controls the overall transparency of the hair. A value of 0 is fully transparent and 1 is fully opaque.

hairColor (hcl) float3

Base color for hairs. The final color used is determined after the hairColorScale and randomization parameters are applied. Also individual hair clumps may override the hairColor.

hairColorR (hcr) float 0.3

hair Red value

hairColorG (hcg) float 0.25

hair Green value

hairColorB (hcb) float 0.15

hair Blue value

hairColorScale (hcs) compound n/a

Hair Color defines the global color of the hairs from root to tip. The left of the graph is the root and the right is the tip.

hairColorScale_Position (hcsp) float 0.0

Position of ramp value on normalized 0-1 scale

hairColorScale_Color (hcsc) float3

Ramp color at the sibling position

hairColorScale_ColorR (hcscr) float 0.0

Ramp red channel value at the sibling position

hairColorScale_ColorG (hcscg) float 0.0

Ramp green channel value at the sibling position

hairColorScale_ColorB (hcscb) float 0.0

Ramp blue channel value at the sibling position

hairColorScale_Interp (hcsi) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

hairsPerClump (hpc) integer 10

This is the number of hairs rendered for each current position hair curve.

thinning (thn) double 0.0

This controls the proportion of shorter length hairs.

translucence (tlc) double 0.5

This allows light to filter through hair for a softer effect.

specularColor (spc) float3

input color for specular highlights

specularColorR (spr) float 0.35

specular Red value

specularColorG (spg) float 0.35

specular Green value

specularColorB (spb) float 0.3

specular Blue value

specularPower (spp) double 3.0

This allows light to filter through hair for a softer effect.

castShadows (csd) bool true

This causes the hair to cast shadows(depthmap only).

diffuseRand (dfr) double 0.2

a diffuse brightness randomization between hairs in a clump

specularRand (sra) double 0.4

a specular brightness randomization between hairs in a clump

hueRand (chr) double 0.0

random deviation in hue of hairs

satRand (csr) double 0.0

random deviation in color saturation of hairs

valRand (cvr) double 0.0

random deviation in brighness value of hairs

multiStreaks (mst) integer 0

Multi Streaks is the number of added sub hairs for each hair in a clump. These hairs will share the same shape and shading as the base hair they are derived from. They are created at render time and are simple duplicates, and thus do not take up any shape computation. This allows one to have a great number of tubes and yet render them in a reasonable amount of time.

multiStreakSpread1 (ms1) double 0.3

the maximum offset for added hairs relative to the clump width

multiStreakSpread2 (ms2) double 0.1

the maximum offset for added tubes relative to the clump width at the tube tip

lightEachHair (leh) bool false

Render times can be much faster if we share the same illumination for each hair in a multiStreak. If the multiStreak spread is relatively large or self shadowing between hairs within a multiStreak group is desired then lightEachHair should be enabled. Also enabling this could avoid popping artifacts in situations with moving hard edged shadows.

displacementScale (dsc) compound n/a

Displacement Scale affects the amount of displacment applied from root to tip of the hair clump. This affects curl, noise and subclumps. If the left side is zero then the effect will be gradually added such that the root position of the hair is not changed.

displacementScale_Position (dscp) float 0.0

Position of ramp value on normalized 0-1 scale

displacementScale_FloatValue (dscfv) float 0.0

Ramp value at the sibling position

displacementScale_Interp (dsci) enum 0

Ramp Interpolation controls the way the intermediate values are calculated. The values are:

None

Linear: The values are interpolated linearly in RGB color space.

Smooth: The values are interpolated along a bell curve, so that each color on the ramp dominates the region around it, then blends quickly to the next color.

Spline: The values are interpolated with a spline curve, taking neighboring indices into account for greater smoothness.

curl (crl) double 0.0

This is the amount of curl displacement applied to each hair. The amount of displacement is relative to the hair width. The clump curl creates large scale curls about the clump center, while this attribute creates curls about the direction of individual hairs.

curlFrequency (crf) double 10

This is the rate of curl. Larger values result in more curls

noiseMethod (nmt) enum 0

Random defines the noise as a wiggle for each hair with no relation to neighboring hairs. Surface UV defines the noise displacement volumetrically and is relative to the uv distribution of the hairs across the surface. The noise is a 3D volume with a scale in U and V across the surface with the 3rd dimension (W) mapped down the length of the hairs. Clump UV defines the noise relative to the clump, and while neighboring clumps have completely independant noises, the frequency of the noise is not affected by the surface parametric density. Random is good for fuzzy, kinky hair, while the other, smoother noise methods can provide natural shaping and sub structure to hair clumps.

noise (noi) double 0.0

This is the amount of perlin noise displacement of the hair. The amount of displacement is relative to the hair width when the noiseMethod is Random, otherwise it is relative to the clump width. This can create a knotted, kinky look to the hair.

detailNoise (dno) double 0.0

This is the amount of secondary high frequency noise added when smooth noise is used. It can add subtle detail on top of smooth undulations from the base noise. If non-zero a second noise offset calculation is performed so this can make evaluation of the hair slightly slower than the smooth noise with no detail noise.

noiseFrequency (nof) double 0.4

This is the spacial scale of the noise offset along hair. Increasing this value results in finer kinks in the hairs.

noiseFrequencyU (nfu) double 1.0

When smooth noise is used, this scales the noise frequency in the u parameter direction relative to the surface the hair is attached to.

noiseFrequencyV (nfv) double 1.0

When smooth noise is used, this scales the noise frequency in the v parameter direction relative to the surface the hair is attached to.

noiseFrequencyW (nfw) double 1.0

When smooth noise is used, this scales the noise frequency along the length of the hair.

subClumpMethod (scm) enum 0

This determines how sub clumps are defined in UV. If Surface UV is used the sub clumps are laid out relative to the overall surface uv space. Some follicles may thus share a clump with a neighbor follicle. The density of sub clumps with be affected by the parametric density of the surface the hair system is attached to. The total number of clumps across a surface will be the numUClumps times the numVClumps. If Clump UV is used then the number of subClumps for each clump will be the numUClumps times the numVClumps. All follicles, regardless of clump width, will have the same number of sub clumps and the width of the sub clumps will be relate to the clump width. With Surface UV the smaller clumps will have fewer sub clumps and the clump width would be relative to the parametric density of the surface.

subClumping (scp) double 0.0

This is the amount secondary clumps pull together. The sub clumping is useful for a wet look. The clumps are defined in a grid relative to the uv space of the surface the hair is attached to.

subClumpRand (scr) double 0.0

This randomizes the sub clumps with a noise function. The clumps will get smeared into irregular shapes with higher values.

numUClumps (nuc) double 15.0

This is the number of sub clumps in the u dimension of surface the hair system is attached to.

numVClumps (nvc) double 15.0

This is the number of sub clumps in the v dimension of surface the hair system is attached to.

clumpInterpolation (cin) double 0.0

This interpolates hairs between neighboring clumps Note that when this is not zero hairs are not contained within the clump boundaries, and thus collisions with a clump may not be correct.

interpolationRange (inr) double 8.0

This determines how far apart a clump may be and still interpolate with another clump. The distance is defined relative to the clump diameter, so a value of 1 would only interpolate clumps that just overlap.

currentTime (cti) time 0.0film

This is the current time used for the hair solution. By default, it is given an incoming connection from the main time node. This can be replaced with some other connection (e.g. from an expression or param curve), and then the solving is done based on that time value. There must be some incoming connection in order for the hairSystem object to play back.

startTime (sti) time 0.0film

The time after which the simulation will be run for this hair object. This is set from the startFrame attribute. Users should set startFrame instead of this attribute.

startFrame (stf) double 1.0

This is the frame after which the simulation will run. Nothing will play back for this object prior to startFrame.

lastEvalTime (lst) time -1.0film

This gets the value from currTime "copied" into it at the end of the solving process. This attribute affects no others so that requesting this attribute does not trigger any other evaluation. Because of the timing of when this attribute gets set, it should not be used by users as reliable data. It is for internal computation only.

inputForce (ifc) vectorArray empty

This is the input multi-attribute where any fields acting on this particle object are connected. These are accumulated in the computePlug() section for aForce, along with other forces like goals.

fieldData (fd) compound n/a

This is the compound that holds all of the default attribute for the fields to connect to. The contents are just sharing the data from the real attributes.

fieldDataPosition (fdp) vectorArray empty

This is the default place that the fields will get this particle object's position data from. It will share the data from aPosition.

fieldDataVelocity (fdv) vectorArray empty

This is the default place that the fields will get this particle object's velcoity data from. It will share the data from aVelocity.

fieldDataMass (fdm) doubleArray empty

This is the default place that the fields will get this particle object's mass data from. It will share the data from aMass.

fieldDataDeltaTime (fdt) time 0film

This is the default place that the fields will get this particle object's timeStep size from. It will share the data from aTimeStepSize.

usePre70ForceIntensity (upfi) bool false

Force evaluation changed in maya7.0 to match normal particle dynamics. Enabling this attribute will revert to the older behavior.

collisionData (cda) compound n/a

Parent attribute for all collision input data.

collisionGeometry (cge) sweptGeometry NULL

The swept geometry for the connected shape.

collisionResilience (crs) double 0.0

How much of the particle's velocity perpendicular to the surface is reflected

collisionFriction (cfr) double 0.0

The amount of a particle's velocity parallel to a surface that is lost in the collision

diskCache (dc) Message n/a

Connection for playback cache node

nextState (nxst) Generic n/a

Nsolver returns state for next step here

currentState (cust) Generic n/a

Geometry and material properties coverted to nData

startState (stst) Generic n/a

Geometry and material properties coverted to nData

nucleusId (nuid) Generic n/a

Internal Id that identifies a Nucleus object to other members of the Nsystem

active (actv) bool 0

Tell the solver whether or not to solve this object

attachObjectId (aoid) Generic n/a

This is the id of the nucleus object that to which the hair is attached.

disableFollicleAnim (dfam) bool false

If this is true then the simulation will not evaluate input follicle connections. For scenes with large numbers of follicles this can speed up simulation, especially if the hair is attached to a nucleus object (an nCloth or nRigid) and that object is deforming. Hiding the follicles will further avoid any computation of follicles during playback.

cacheableAttributes (caat) enum 0

This specifies which dynamic attributes will be included the cache file when this node is cached.

hairCounts (nhct) Generic n/a

Input for cached hair count data

vertexCounts (nvct) Generic n/a

Input for cached hair vertex count data

positions (poss) Generic n/a

Input for cached position data

velocities (vels) Generic n/a

Input for cached velocity data

internalState (inst) Generic n/a

Input for cached internal dynamic state data

playFromCache (pfc) bool false

When enabled, it reads back position from the vector array input

receiveShadows (rcsh) bool true

The flag to control if this object casts shadows.

visibleInReflections (vir) bool false

The flag to control if this object is visible in reflections.

visibleInRefractions (vif) bool false

The flag to control if this object is visible in refractions.

outputHair (oh) vectorArray empty

Output array of polylines (double point arrays) that represet the current position of the dynamically solved hairs.

outputRenderHairs (orh) hairRenderInfo NULL

Output of the hair system for paint effects rendering. This connection passes the positions and widths of all dynamically solved hairs in addition to shading attributes.

solverDisplay (svds) enum 0

Interactive display of internal solver info.

displayColor (dcl) float3

Color for interactive display of thickness.

displayColorR (dcr) float 1.0

display Red value

displayColorG (dcg) float 0.8

display Green value

displayColorB (dcb) float 0.0

display Blue value