| 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.1 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. So it's harmless to use work done with different versions, all in the same scene - as long there is no ICE connection in between. 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...). |
| 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. |
| Emitters |
![]() |
| 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 overriden by styling nodes. However, it always suplies 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. - Init 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. Parameters: - 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 |
![]() |
| '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's length. - Blend Type: 0 is exponent, 1 is smooth step. - 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 boundary of 'filtering NURBS' is close to itself, there is a chance for finding the locations on wrong side. If sampled "V" is higher than "V threshold", third sample is activated. This sample is defined by direction between chunk and point position. Inverse of direction is used as UV sample, which is always on the same side as chunk sample. Default "V threshold" value should be adequate, all the time. - 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, 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. - 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 from emitter's UV 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 adapts automatically to count of used NURBS surfaces. Minimum is two. 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. - Align To Tangent: aligns strand along curve. Emit Point Normal is used as Up Vector, strand tangent as 'point at' of 'Direction To Rotation' node - so it is supposed to works somewhere in hemisphere deined by Emit Point Normal - still outside of parallel Emit Point Normal and strand tangent. |
| 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 of 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 of poly mesh emitter: should point at 'UVs' attribute. - Two references to tangent map property, in case of poly mesh emitter: should point at 'Colors' attribute. |
![]() |
| Modifiers |
![]() |
| 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. Important parameters: adds Raycasting to computation, measuring the distance between the last 'in' and first 'out' segment. |
| 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. - Count X and Count Y: Number of groups along. It's approximation, it can be slightly different than input. - Randomize: Proportional randomizing of diagonal grid. - Clump, 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 Loose Hair |
| Randomizes position of each strand position, interpolates 3-point Bezier curve along only a few of strand positions. Result is smooth, randomized shape, with ability to skip te details, but still following the original. Parameters: - Segments: count of used positions. Should be smaller than original strand count. - Form node X: in case of applying after 'Follow Nurbs', takes only points, close to parting line. - Rotation: rotates along first used strand tangent - Weights: X is cross product od strand up vector and tangent, Y is up vector, Z is tangent. |
![]() |
| 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. |
| Shading |
![]() |
| 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. |
| Simulation |
![]() |
| 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. |
| Utilities |
| 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 Match NURBS To Mesh |
| Sticks NURBS surface to frozen mesh, created by
'NURBS to Mesh' command. Procedure: 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: ID: - 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 June 2012 |