What it is, what it's not
Kristinka Hair is mainly a hair styling system. It works exclusively with Softimage ICE strands. All nodes/compounds are designed to be compatible with all nodes inside the system, also with low-level factory nodes (math nodes, modulators by weight-map or null, conditionals, setters, getters). It's *not* compatible with factory strand nodes, it's *not* compatible with another ICE hair systems - even it's possible to allow the compatibility. Nodes from version 3.0 generally aren't compatible with nodes from previous versions.

'No compatible' exactly means no-compatibility of nodes/compounds inside the same ICE tree, or connected ICE trees. What is on another, independent Point Cloud in the same scene, this doesn't matter. It's harmless to use the work created with different versions, all in the same SI scene - as long as ICE trees aren't connected.

How the system works, this can be compared with rigging system. Sometimes, nodes/compounds from system can be 'misused' for another purposes, but generally, misusing means a huge overhaul.

Basic knowledge of ICE is required (how to connect the nodes, what is un-simulated ICE tree, what is Cutoff distance ...) - as well as basic knowledge about transformations (what is Up Vector, what is Reference pose...). Also, basic knowledge about NURBS (where is X boundary, what is re-parametrization).

Installation and basic usage
Copy the all ICE compounds to folder recognized by Softimage, for example, users/...Softimage/...data/Compounds. Restart Softimage. In ICE preset manager, task called "k Hair3" should appear. All compounds have a "kH3" prefix, no one has a name of existing factory compounds.

Create an empty Point Cloud, create un-simulated ICE tree, bring "kH Emit From NURBS" or "KH Emit from PolyMesh" node to ICE tree.
If emitter is poly mesh: frozen, non-overlapped UV property should exist on mesh. Also, ICE tree on mesh, with kH Initialize Mesh Emitter node. For some nodes, such as kH Fur or kH In Between Curves, tangent property should go on mesh as well.
- Point Cloud should always stay on world origin (Scale 1, 1, 1 Rotate 0, 0, 0 Translate 1, 1, 1).
- In case of animated/deformed hair, emitter should stay on world origin too - for transformations/deformations of entire Point Cloud, use kH Deform Hair node at the end of ICE tree (nut before 'hair filler'), together with transformed/deformed copy of emitter.

- Sample model called 'stick_to_mt_extrusion' has a setup for 'sticking' the strands to mesh extrusions.

- Geometry used for styling, generally is *not* supposed to be animated, because of live calculations of distances, between geometry and hair roots/points. Here is a short list, which part of geometry is used by 'form' nodes (so is not supposed to move in animation):

kH Follow NURBS: 'filtering' NURBS surface, inside area of limits.
kH Follow NURBS Lite: input NURBS surface, inside area of limits.
kH Cross Sections: 'filtering' NURBS surface, inside area of limits.
kH Follow Curve: first point on curve.
kH In Between Curves: first point on curve.
kH Fur: nothing.
kH Offset By NURBS, kH Offset By NURBS Lite: entire NURBS surface.
- - - - - - -    Important nodes    - - - - - - -
kH Emit from NURBS
Basic emitting node. Creates points and strands on NURBS surface. Only single NURBS surface (without sub surfaces) is tested. Only one kH Emit From NURBS node per point cloud is allowed. Node should resides in un-simulated ICE tree.
Also, node creates basic point and strand attributes, such as point color, point and strand size, count of strand segments. Initially, strands are aligned to point normal of NURBS surface. Particle shape type is set to segment. All attributes can be changed later, except one: count of strand segments, which is the same for all points in point cloud, all the time. Even hair filler node will re-use this value.

Important parameters:
- Emission mode: 'Guides and Filler' creates a virtual grid of triangles, one point is created on each corner of virtual triangle. Three strands on each triangle are used later by filler, in order to create a final hair for rendering.
'Random' is a random distribution along NURBS surface. In this mode, filler is automatically disabled, even if there is active filler node in ICE tree.
- Chunks Rate: Number of virtual triangles.
- Fit Border, Turbulence, Frequency: parameters for distribution, explained in image bellow.
- XY Ratio: In case of  'Guides and Filler' mode, this parameter can change distribution, more point along X, less along Y, and reverse.
- Seed: It's the same for both emission types.
- Final Rate: In case of  'Guides and Filler' mode, this tells to filler how many points to emit, in case of 'Random' mode, that's a count created by kH Emit From NURBS node.

- Segments: Count of strand segments.
- Size: Particle size. This is for all strand segments too. Variable strand size can not be set with this parameter.
- Initial Length: Initial strand's length. Usually this overridden by styling nodes. However, it always supplies a valid strand for rendering.
- First Segment: Relative position of first strand segment, at zero it's close to point/hair root, but never on the same position.
- Density: Sliders for adjusting the emission density, along X/U and Y/V of emitter.

kH Emit from PolyMesh
Basic emitting node, behaves in the same way as kH Emit from NURBS, but uses poly mesh instead of NURBS surface. Only one kH Emit From PolyMesh node per point cloud is allowed. Node should resides in un-simulated ICE tree.

Important parameters:
- Emission mode: 'Guides and Filler from Triangles' creates a point is  on each corner of poly mesh triangle.
In  'Guides and Filler' mode, emitter mesh should be 'triangulated', for proper emission.
'Random' is a random distribution along poly mesh, using a  factory 'Generate Sample Set' node. In this mode, filler is automatically disabled, even if there is active filler node in ICE tree. 'Random' emission works properly from any kind of polygon mesh.
- Seed: It's the same for  both emission types.
- Final Rate: In case of  'Guides and Filler' mode, this tells to filler how many points to emit, in case of 'Random' mode, this is a count created by node itself.

- Segments: Count of strand segments.
- Size: Particle size. This is for all strand segments too. 
- Initial Length: Initial strand's length.
- First Segment: Relative position of first strand segment, at zero it's close to point/hair root, but never on the same position.

- Reference to texture projection: should point to 'UVs' attribute.

Picture: suitable mesh for 'Guides and Filler' emission mode has as much even distributed triangles. Non-overlapped, well unfolded UV projection is required too. This one is created  from high-res subdivision, using a SI 'Filter Points' operator, also a bit of cleaning by hand.

kH Initialize PolyMesh Emitter
Is for initializing the attributes on poly mesh emitter. Usually it resides in animation region, to allow editing of mesh, including topology. In case the mesh is frozen, it's enough to apply the ICE tree again.
kH Hair Filler
Creates a final emission, by cloning the points and interpolating the strands in between three 'guides'. For performance reason, it's good idea to apply it after all 'form' nodes, as well as most of modifiers. It takes a 'final rate' parameter from kH emit from NURBS or kH Emit Form PolyMesh.

Optional NURBS surface input: in case emitter is NURBS, it can be plugged here, to enable points/hair root to "stick" to emitter, instead of linear interpolation in between of three points.

- Density: rate multiplier, 'Modulate by weight map' factory node can go there.
- Seed: seed for random distribution
- Distribution: see image bellow

kH Emit Hair Filler
It works in similar way as kH Hair Filler, but this time filler is separate Point Cloud. It has own final rate and size parameters. However, it is active only in 'guides and filler' mode on master point cloud.
kH Splay Hair
Creates clones of hairs, then distribute the clones in around original hair root. It's supposed to use after kH Fur or kH In Between Curves.

Important parameters:
- Nb to clone: number of cloned points. It's the same number for all original points.
- Splay : factor of moving in SI units.
- Clump: moves strand back to original positions.
'Form' nodes are creators of basic hair flow. Almost all of them utilizes additional NURBS surfaces or curves. In analogy with mesh creation in Softimage, these nodes acts like Deform By Surface operator. Position of point/hair root, as well as count of strand segments, stays the same, but shape is modified. A new 'form' node overrides the previous one, in area of influence.
kH Follow NURBS
Is a main hair styling node. Node is designed primarily for tiny layers of hairs. Firstly, node searches for closest locations on additional NURBS surface, then it aligns the strands along NURBS surface's X length. Flow always starts from X, 'red' boundary. According to order of closest locations along X of NURBS surface, strands are
distributed along normals, or in between two NURBS. There is a 'blending area' for creating smooth interpolation from point positions (hair roots), to flow.
Two functions (filtering the closest location, and 'shaping source') can be assigned to different NURBS surfaces. 

Filtering NURBS surface need to be *close* to points/hair roots, inside cutoff distance.

Important parameters:
- Mode: 'Interpolate' is the same function as a former kH Follow NURBS 2 - strands are interpolated in between 'filtering' and 'shaping' NURBS surface. "Push from Shaping" and "Negative Push From Shaping" is distribution along normals of 'shaping' NURBS.
- Blend End: end of 'blending area', along relative strand length ( X of NURBS surface).
- Blend Type: 0 is exponent, 1 is smooth step.
- Ab End : End of 'vertical' interpolation along X of NURBS surface.
- Length: End of strands, along X of NURBS surface.
- Width Y parameters: Scale and center of scaling, along Y of NURBS surface.
- Push: Scaling of strand's flow, along surface normal. Too high values, together with highly curved NURBS, can produce artifacts. In case of "interpolate" mode, parameter has no effect.
- Shift: It moves whole flow along surface normal's. Too high values, together with highly curved NURBS, can produce artifacts. In case of "interpolate" mode, parameter has no effect.

- Set Parting Line > Sample Offset: in case X boundary of 'filtering NURBS' is close to itself, there is a chance for finding the locations on wrong side.  'Sample Offset" virtually moves searching positions along X of NURBS, in two steps: midpoint of chunks defines the correct side for moving, sampled poisitions are moved. Increase slowly this parameter to avoid the wrong interpolation.

- Limits: Outside these limits, node has no effect. In case of overlapped influences of multiple kH Follow NURBS nodes, the last one has a precedence.
- Cutoff Distance is a maximum distance from points/hair roots to locations on NURBS surface.
- X min an X max, Y min and Y max: outside these limits, locations are ignored. Usually NURBS surface is 'aligned' to emitter. Ignoring the locations outside these limits, removes the points/hair roots which aren't "bellow" the filtering NURBS. It's good idea to keep values different than min 0 or max 1, for better interpolation.
- Split On Y - this is only if kH Grouping node is applied after. Creates a two separate interpolation groups.

- Alternative Strand Array: Additional input for modifying the flow. Input is only for 'kH Offset by NURBS ...' nodes.

kH Follow NURBS Lite
Simplified version of kH Follow NURBS, for working with multiple inputs. Node can accept many NURBS surfaces, each one acts as 'filter' and 'shaper' in same time. There is no "sample offset" feature, so one NURBS surface shouldn't have a X boundary too close to itself.
kH Offset by NURBS
Is for re-mapping the flow of kH Follow NURBS. It can use many of NURBS surfaces which acts as a 'follow NURBS for follow NURBS'. Surface should reside inside the local  0-1 XY space of 'offset null'.  Parallel flow along X has no effect, anything else is deformation. Moving along Z, changes the push/interpolation of 'main' kH Follow NURBS. Node has a similar parameters to kH Follow NURBS. Output is 'alternative array' which can be connected only to appropriate port of kH Folllow NURBS.

- 'Offset Null' input is for null (or anything else which has SRT), which serves for defining the virtual UV space. It's good idea to parent the NURBS surfaces under this null, so you'll be able to move-scale-rotate everything at once.

Important parameters:
- Clump and Locks: node is able to create procedural interpolation. Count of  stripes is relative to distance between Y boundaries, at zero X.

Picture shows how a null local space defines the UV and "Z" space of "main" kH Follow NURBS.

kH Offset by NURBS Lite
Version of kH Offset By NURBS, without internal 'clump and locks' option. It's faster than kH Offset by NURBS.
kH Cross Sections
It's designed as an opposite to kH Follow NURBS. UV locations , filtered by 'Filter NURBS' are projected to additional NURBS surfaces, then strand are interpolated as 3 point, quadratic Bezier curves, using locations on NURBS surfaces as control points. Node will adapts automatically to used NURBS surfaces.

Filtering NURBS surface need to be *close* to points/hair roots, inside cutoff distance.

For getting correct vectors for later deformations, it's good idea to keep NURBS surfaces as much perpendicular to flow - at least in areas where deformations should be applied. For correct effect of modifiers that are used later, NURBS cross sections should be at equal distances - except first and last segment, that should be two times shorter.

Important parameters:
- Cut Last: removes some of last NURBS surfaces from calculation.
- Length: End of curve creation.
- Cutoff Distance: Maximum distance to 'filtering NURBS'.
- Mid Point: if it's enabled, node will add additional point between hair root and location on first NURBS surface. 'Position' is relative in-between position. 'Push' is a relative scaling along point normal of emitter,'Shift' is moving along point normal.

kH Follow Curve
Forces strand to follow one or many curves. First point on curve is used as reference position. This node also has a 'blending area', from hair root to position on curve.
In case of multiple curve inputs, later one overrides the previous, in area of influence

Important parameters:
- Distance: Distance for limit the effect, in SI units.
- Clump: moves the strands closer to curve.

kH Fur
It creates fur-like strand shape. Orientation is taken from emitter's surface. If emitter is poly mesh, tangent map on mesh is required too.
Important parameters:
- Scale: Scaling of whole fur profile.
- Fill: Scaling along profile.
- Bend: bends the profile
- Rotation: Around point normal, and X axis of UV space of NURBS emitter.

- UV direction: for polygon meshes, Y is 'vertical' looking from UV space.

- Reference to tangent map property, in case od poly mesh emitter: should point at 'Colors' attribute.
kH in Between Curves
Interpolates strands in between at least three curves. Even the node can accept (theoretically) unlimited number of inputs, it's good idea to keep less than about 10, together with lower count of strand segments - because the 'concatenated' array of all inputs is used.

Important parameters:
- Interpolate around: if is enabled, samples are virtually aligned on UV planar space, interpolated and aligned back to original orientation.

- Reference to UV property, in case od poly mesh emitter: should point at 'UVs' attribute.
- Two references to tangent map property, in case od poly mesh emitter: should point at 'Colors' attribute.

Are general purpose nodes, which can be used for additional deformations - or just for providing parameters, used by another modifiers.
kH Bend
Rotates hair tips, according to strand up vector and tangent, provided by 'form' nodes, or previous kH Bend node. For better look, node creates 'linear' strand in area of influence, then it do deformation. 'Linear' part of strand is actually extension of strand tangent at start of deformation. So, in deformed area, previous strand shape is ignored. However, later modifiers in stack, including another kH Bend, will consider the deformation.

For calculations, node is using exact strand positions, instead of interpolations in between - when tweaking parameters, or modifying the count of strand segments, that will produce effect of 'jumping'. But once the deformation is set, effect of node should stay stable.

Important parameters:
- On Length: Starting position of effect, relative to strand length.
- Scale: Scale of whole effect.
- Bend Angle: Maximum angle of rotation. It's limited to -360 + 360 degree.
- Roll: Rotates a whole deformation, using the first strand tangent of deformation, as an axis.
- Circle profile function curve - it can deform the circle.
- Distribution: In case of "Align To Follow NURBS",  adjusts the starting point of influence, so even hair roots aren't aligned, starting positions of modifier's effect *are* aligned. Effect is visible if kH Follow NURBS is used before.
kH Clump and Locks
 Changes the way, how guides are interpolated. Similar to options in old kH Emit Hair node. Now it's a separate modifier. It has effect only in 'guides and filler' mode.

Important parameters:
Locks: guides are aligned in stripes of the same width.  If 'Fixed Lock Size' is active, that's a width In SI units, otherwise that's a width at origin.
Clump: moves the guides to average position of emitting triangle.
Crossover start, crossover length: similar to options in default SI hair shader, but crossover length is added to crossover start.

kH Cut by Geometry Volume
 Cut the hairs outside of volume of external geometry. External geometry should be 'closed'. It should penetrate with strand only once.

kH Curls
Creates hair curls. Actually, two sinus functions with different inputs are used - that's allow a 'half of effect' of waves only in one direction, if is desired.

Important parameters:
- Weight: 'radius' in SI units.
- Shift XY: it's in SI units. Whole effect is moved, this is mainly for avoiding penetrations with model's body.
- Factor XY: multipler of radius for local X and Y direction.
- Nb Curls: Number of circles. It's per point value, so it can be randomized only per point, not along strand length.
- Exponent: At more than one, rotation is stronger at hair tips. Less than one is reverse.
- Add Nb: Moving the curls along relative strand length.
- Distribution: In case of "Align To Follow NURBS",  adjusts the starting point of influence, so even hair roots aren't aligned, starting positions of modifier's effect *are* aligned. Effect is visible if kH Follow NURBS is used before.

kH Grouping
Creates groups of strands. Firstly, it creates a grid of points along UV of emitter, then it aligns the strand in groups, according to UV distance to sampled points.
For aligning, it's using the same 'Clump' and 'Locks' rules, as kH Emit Hair does. Important parameters:
- Count: Number of groups. It's approximation, it can be slightly different than input.
- XY Ratio: This parameter can change distribution, more groups along X, less along Y, and reverse.
- Randomize: Proportional randomizing of diagonal grid.
- Clump, Locks, Crossovers: the same as is in other modifiers.
- Set What: In case of 'Group ID', node sets only ID for each group. ID can be used later with 'kH Random Value' node.
kH Grouping by Polygons
Creates groups of strands, following the topology of external polygon mesh. Group is created above the center of polygons, so it's good idea to keep the convex polygons on external geometry.
- Clump, Locks, Crossovers: the same as is in other modifiers.
- Set What: In case of 'Group ID', node sets only ID for each group. ID can be used later with 'kH Random Value' node.
kH Fur Vector by Null, kH Fur Vector by Curve
Main purpose of these nodes is to change the initial orientation of hairs/strands of kH Fur node, but they can be used as modulators of scalar-per-point values too. Nulls acts similar to SI factory Modulate By Null node, but it's possible to use multiple nulls from group. Influence is modulated by distance to points/hair roots - but here, nulls affects only orientation. Influence of each null/curve is added to previous, then normalized inside 0 - 1 range. By default, positive Y axis of null is used as orientation vector of hairs - for curve, tangent is used. This orientation vector is parallel to emitter's surface - node won't work properly if positive Y axis of nulls, or tangent of curve, is parallel to emitter normal. Also, it won't blend nicely at high angles, near to 180 degree.

Important parameters:
- Type: Direction taken from null's Y axis, look at null, circle around null. For curves, direction is curve's tangent.
- Negate: inverts direction.
- Distance: multiplier of distance in SI units. Inside this distance, weight is 1.
- Falloff: Fallof, added to distance.
- Project To Surface: it does 'Point To Plane Projection', that forces strands/hairs to keep the original direction along emitter, instead of taking from null.
kH Push
Moves strands in three directions. X is a cross-product of strand tangent and up vector created by 'form' nodes (internally, it's called 'kH_StrandUpVector'). Y is a strand up vector itself, Z is a strand tangent. This modifier is more a container for strand array modifiers, such as kH Strand fCurve or kH Local Turbulence. For example, it's possible to create a custom effect of curls, by using two kH Strand fCurve nodes, plugged into X and Y.

Important parameters:
- XYZ weight: it's in SI units.
- Blend End - position on strand, relative to strand length, where modifier has a full effect. At hair root, there is no any effect.
kH Randomize
Version of kh Push. For convenience reason, it has built in, per point randomizing of 'push' effect. This time, strand are moved only along 'XY'. Usually, modifier is used for creating the effect of a few strands, that don't follow hair flow completely.

Important parameters:
- every Nth: limits the effect every nth point/strand array in point cloud.
- Blend End: reaches the full weight, according to relative strand length

kH Strand fCurve
Strand Array modifier, for modulating a lot of parameters related to strand array:  weight of modifiers along strand length, weight of  clump or locks effect, and more. It can be used instead of built-in 'crossovers'. For this purpose, set both Crossover and Crossover length to zero, put kH Strand fCurve into 'weight'.

kH Turbulence Local
Strand Array modifier. Instead of function curve, turbulence is used. Base positions for turbulence are linked to strands in a way, that global transformation of strands will not affect calculation. Effect stays the same, regardless of movement. Base positions are: UV emit locations as X and Y, relative strand length as Z.

Important parameters:
- Shift Center: moves the turbulence effect along relative strand length.
- Randomize: Adds random value to UV values from emit location, providing a 'total' random effect, per point. Keep it at zero for aligned turbulence.
- Scale UV: this will virtually scale UV values from emit location, providing a different turbulence frequency per point, but still continuous. Scaling of this value will exaggerate 'random per point' effect. Keep it at zero for aligned turbulence.
- Distribution: In case of "Align To Follow NURBS",  adjusts the starting point of influence, so even hair roots aren't aligned, starting positions of modifier's effect *are* aligned. Effect is visible if kH Follow NURBS is used before.

kH Turbulence Global
It's a global turbulence, similar to factory 'Turbulize Around Value' node, but this time, strand position is used as reference. Main purpose of this node is animated effect of wind through the hairs.

Important parameters:
- Randomize: additional, per point random effect, for creating a 'total' random effect, per point
kH Hair Length
Scales the strands/hairs, exactly along original strand shape.

Important parameters:
- Factor: scaling factor, along relative strand length.

kH Subdivide Strands
Smoothly subdivides strands, getting a similar look to XSI 'geometry approximation' property. Node is using 3 point, quadratic Bezier curve, the same one which is used for kH Cross Sections node. Interpolation won't go exactly through strand positions, but it's fast.

Node can be used anywhere.

Important parameters:
Factor: Multiplies the count of strand segments. Here, kH Subdivide Strands behave differently than XSI geometry approximation. For example, with factor 3 and original count of 21, result is 63. With factor 5, result is 105, and so on.
kH UV fCurve
Takes UV values from emit location, or provided by modifiers, then do re-mapping to scalar value per point. There is a lot of tasks for this node. It can be used instead of painting weight maps on NURBS emitter, as a more convenient way. Also it seems to be easier to get smooth gradients by using this node, instead of painting.

Important parameters:
Type: 'Emit Location' is UV value from NURBS emitter.
'By Modifiers' is UV value provided by 'form' nodes - for example, UV value from 'Closest NURBS' used by kH Follow NURBS.
kH Hair Tips
For performance reasons, this modifier won't create Up Vectors and Tangents after, so it's good idea to use it as a last deformation in stack.
Modifier is trying to create effect of 'lost' hair tips. In fact, it's a mix of kH Bend, kH Hair Length, and kH Strand Turbulence modifiers.
kH Point Color
Applies per-point color to points and strands. Color is modulated by turbulence. As a base position for turbulence, UV values from emit location are used. Result can be used in render tree, but main purpose is to get better feedback for styling.

Important parameters:
- Multiply: multiplies color by scalar value. This can be used to display useful information for styling - for example, kH UV fCurve can be plugged into this input.
- Alpha: if gradient color is used, it seems that is impossible to get alpha on point color, in view ports. So, node will re-build color internally, and apply a new alpha.
- Turbulence frequency, complexity, seed: common parameters of factory Turbulence node.
- XY Ratio: Scales the underlying UV values.
kH Strand Size
Applies variable strand size for rendering. First member of strand array sets point/hair root size too.

Important parameters:
- Function Curve
kH Strand Screen Size In SI Units
Applies approximate strand size in SI units, even if strand screen size is used. In order to work properly, rendering camera should be connected to 'Camera In Name' port. Also, horizontal size of rendered image need to be entered manually.

Important parameters:
- Screen Resolution: Horizontal pixel resolution of rendered image
- SI Size: Desired strand size in SI units. It's strand array, so kH Strand fCurve node can be plugged here.
- Minimal Screen Size: for avoiding anti-aliasing artifacts, node is able to keep minimal screen size to entered value.
kH Delete Points
Node is designed for deleting points, by painting weight maps on emitter. It should be plugged into 'Execute On Emit' port of kH Emit Guides, or kH emit Hair.
Built in Random Value is for smooth weighting of deleting effect, that follows weight map values.
kH Deform Hair
Deform a whole hair, using a copy of emitter (that is, copy should have the same topology, in case of poly mesh emitter). It's possible to modulate the weight, along strand length.
kH Point Dynamics Init Sim
'Point Dynamics' is a simple dynamics, applied only to points/hair roots . Simulated positions are converted to rotations of whole strands. This simulation type is designed only for short hair or fur. There is no any built-in collision - but it is possible to add a node that just prevent penetration with model's body.

kH Point Dynamics Init Sim node is for creating initial attributes. Typically, it should go at the end of ICE tree, which begin with kH Emit Guides.

Important parameters:
On Length: position on strand, used for creating direction. 1 is end of strand.
kH Point Dynamics
Applies spring dynamics to points on point cloud. Node should reside in simulated ICE tree.

Important parameters:
- Angular: factor of angular spring force.
- Linear: factor of angular spring force.
- Drag: simplified variance of factory Drag Force node. It slows down the effect.
kH Point Dynamics 2Strands
Transfers point simulation to strands. Simulated point positions are used as a target for deformation.

Suggested caching procedure:
- Select third ICE tree, in post-simulation region, RMB and 'disable from here'
- Select point cloud, go to Animate>Plot>Write Geometry Cache
- - - Be sure to cache *only* point positions and point velocity - - -
- Duplicate and hide the point cloud
- Load cache on duplicated point cloud
- Enable all ICE trees on duplicated point cloud

Important parameters:
- Weight function curve: Modulates effect of rotation along strand length.
- Weight: global, per point weight of effect.
- Compensate Length : Gradually scales the strands when they are rotated, for correct bending.
- Do nothing First Frames: first frames of local simulation time, where node prevents unwanted effects, by blocking any effect of simulation.
- Simple Emitter Collision: It just prevents the strands to move 'on other side' of plane, defined by emitter's point normal. It's not accurate for long strands.
kH Disable Styling By Volume
Display utility, forces strand to align to emitter's normal, as well as short length, inside the volume of external geometry.
External geometry should be 'closed'.
kH Filter By Distance To Geometry

Outputs Boolean value per 'chunk' (three guides at triangle corners), or by point/hair root, in case of  simple random emission - according to distance to external geometry.

kH Filter By Volume

Outputs Boolean value per 'chunk' (three guides at triangle corners), or by point/hair root, in case of  simple random emission. Requires external geometry with closed volume.

kH Hair To Chunk Distance

Outputs relative distance to center of emitting triangle. It has effect only in 'guides and filler' mode. In picture bellow, hair length and hair color are modified by this node.

kH Stick NURBS To Mesh
Sticks NURBS surface to frozen mesh, created by 'NURBS to Mesh' command.
1: select NURBS surface, run 'NURBS to Mesh' from Model>Create>Poly.Mesh
2: In PPG, set: From Control Hull = ON, Stitch = OFF
3: Freeze the mesh
4: Create ICE tree on NURBS surface, apply the node
kH Random Value
It's similar to factory Randomize Value By Range node, but it can use more types of ID, not only Point ID. Typical usage is randomizing effect of kH Curls node, by driving the 'Roll' parameter of kH Curls (for that, values need to be set to about -90 + 90 range). Output is scalar per point.
Important parameters:
- Point: ID is per point (hair root), effect is the same as with factory Randomize Value By Range.
- Chunk: ID is per triangle of guides. Has effect only in 'Guides and Filler' mode.
- Group: ID is per group of points, created by kH Grouping node. It has different effect only if kH Grouping is applied before.

Picture shows the effect kH Hair Length, modulated by kH Random Value in different modes.

kH Turbulence From Emit UV
Similar to factory turbulence modifiers, but this time, equivalent of 'base value' is always UV value from emit location. That means, base value is fixed to emit UV - turbulence effect will not 'swim' if emitter is moved or deformed. There is a wide range for usage of this node - for example, modifying the scale of fur profile, multiplying effect of kH UV fCurve, so on.
Output is scalar per point.
Best Regards,
Anto Matkovic
July 2011