The Generation properties are describe in full detail under 'Generation Properties'.

**Enabled** (checkbox)

While all forces in the scene are listed in this group, only enabled forces affect this generator.

Click on the colored square to the right of the force name to edit its properties. |
---|

Various seed values are used to procedurally generate nodes. Each random number has been separated out into groups of like properties. *(Integer)*

**Randomize button**

Seeds can be incremented with the spinner or chosen at random via the Randomize button. All seeds can be randomized at once with 'Randomize all'.

Randomizes the value for all seeds used to compute this generator. *(Function)*

Scales the number of length, radial, and cap segments uniformly. *(Float)*

**Relative**: Both length and radial segments are computed based on the length and radius of the node, respectively.*(Enumeration)*

**Length relative**: Length segments are computed based on the length of the node.*(Enumeration)*

**Radial relative**: Radial Segments are computed based on the radius of the node.*(Enumeration)*

**Absolute**: Both length and radial segments are set explicitly.*(Enumeration)*

The maximum fidelity of spines. *(Integer)*

Changing accuracy may drastically affect the shape of your spines. Set this value to the maximum desired fidelity early to avoid design losses. Higher values result in slower computes. |
---|

The number of segments composing spines. *(Integer / Float)*

If Segments: Style is set to relative, this integer becomes a float and the actual number of segments generated is computed based on the length of the parent. |
---|

The number of segments composing the radial cross-section of branches. *(Integer / Float)*

If Segments: Style is set to relative, this integer becomes a float and the actual number of segments generated is computed based on the radius of individual nodes. |
---|

The number of rings composing the cap geometry of broken or open-ended branches. *(Integer / Float)*

If Segments: Style is set to relative, this integer becomes a float and the actual number of segments generated is a function of the radius of individual nodes. |
---|

The method used to determine spine length – either “Absolute” or “Relative”. When set to “Relative”, two new options become available; Length % and Limit Length, which factor into determining the final calculated lengths. *(Enumeration)*

When Length Style is set to “Relative”, this value is used to determine how long the nodes of this generator will be as a percentage of their parent's length. Optionally a length limit can be enacted, which will limit the maximum length of spines at the value set generically for Length. *(percentage)*

When enabled, relative length spines will be capped at the Length value, however any individual node may be shorter than this value depending on the value set for Length % as well as the actual length of each parent node. *(Boolean)*

The length of the spine nodes as distributed along the parent node. *(Float)*

**Relative length limiter**
If Length Style is set to “Relative” and 'Limit Length' is enabled, this value serves as the limiter for all possible lengths, regardless of the length of each parent.

The amount of angle offset from the parent node's growth direction at the point where each node occurs.
Where 0.0 is equal to the parent's direction, 1.0 is an inversion of the parent's direction, and 0.5 is perpendicular to the parent. *(Percentage)*

Uniform rotation of each spine. Roll is applied after *Spine:Alignment*. *(Percentage)*

Toggles the affect of spine disturbance, jink frequency, and jink amount. *(Boolean)*

The amount of randomness applied to each angle along the spine length. *(Float)*

By entering Node Mode, individual disturbance seeds are exposed and can be randomized. |
---|

The sampling rate of the jink behavior. *(Float)*

Jink:Frequency and Jink:Amount work together to make the jink behavior. Either set to 0 nullifies the effect. |
---|

The amount to sample the jink behavior. *(Float)*

Jink:Frequency and Jink:Amount work together to make the jink behavior. Either set to 0 nullifies the effect. |
---|

Forces the spine node to return to it's original growth path as if none of the 'Perturbance' properties were ever applied, even though in reality they are still in effect.

Helpful when trying to recreate a tree with many knots and jinx, while keeping the trunk or branch on it's original direction of growth. |
---|

Randomizes the values entered of the 'Perturbance' properties.

Pressing this button will convert a procedural branch into a hand drawn branch and vice versa. During the process, some properties (such as Allow forces and Spine:Perturbance) are disabled or enabled to provide a more seamless conversion. *(Function)*

Converting to hand drawn may result in a slightly different branch. Bifurcations will become disabled and/or the spline may twitch slightly during the resampling. |
---|

In the Hand Drawn group, there are 2 sets of properties: 'New' and 'Resample'. The properties under 'New' is applied to any nodes that will be created, while the properties under 'Resample' effects any of the nodes that already have been created.

The types of control points that are used to form the bezier spline. *(Enumeration))*

**Corner**: Control point handles are independently rotated and scaled to best fit the hand drawing.

**Linear**: Control point handles are rotated in unison (per control point) but are scaled independently, creating linear tangents.

**Smooth**: Control point handles are rotated and scaled in unison, creating symmetrical tangents.

The accuracy of the bezier spline that is created after hand drawing. Higher values result in the creation of more control points. Once drawn, a spline can be resampled with the 'Curve fit scalar' found in the 'Resample' group.

**Absolute**: The radius of the branch is determined using real world units.*(Enumeration)*

**Relative**: The radius of the branch is a percentage of its parent node at the point where it was generated.*(Enumeration)*

The radius of the extruded branch skin. *(Float)*

Radius is limited to the radius profile percentage of the parent node at the point where each branch is generated unless clamp radius is disabled. |
---|

This controls how far away the child's ring is from the parent. The closer the child's ring is to the parent then the harsher the intersection is and the further out the child's ring is then the smoother the intersection is. *(Float)*

Averages out the vertices at the conjunction in order to remove artifacts.

The amount to spread the weld segments towards the end of the parent branch, creating a “web” where the branches meet. *(Float)*

The amount to spread the weld segments towards the start of the parent branch, creating a “web” where the branches meet. *(Float)*

The amount to extend the blended texture region up the child branch, elongating or squashing the texture mapping. *(Percentage)*

The denseness of the texture applied around the intersections.

The number of flares around the branch. *(Integer)*

An interpolation between equally-spaced and randomly-positioned flares. *(Percentage)*

The radial spread of each flare. *(Float)*

The distance out from the initial branch radius that the flares will extend. *(Float)*

The distance the flare extends up the spine of each node. *(Float)*

Compresses the flare area for a more compact and denser look with out affecting the radius of the area where the vertices intersect.

Rotates the end of the flares, which is furthest away from the intersection, around the center spine.

Randomizes the values of the 'Flare' properties.

Insets the cap from the branch proper to simulate bark thickness. *(Percentage)*

A cap border greater than 0.0 results in an extra ring of cap segments. |
---|

Extrudes the cap geometry in the direction of the last length segment. *(Float)*

Requires a Cap: Border value greater than 0.0. |
---|

The length of the ring edge surrounding the end of a trunk or branch.

The width of the cap's ring edge. Scales from 0 to 1; at 0 the cap has a thin edge and at 1 it has a thick edge.

The rotation of the texture coordinates around the center of the cap. *(Percentage)*

The length to extend one side of the cap, creating a slope. *(Float)*

Rotate the slope with Cap:Angle |
---|

Each layer applies only to branch geometry. Branches have two distinct sets of texture coordinates, 'Base' and 'Detail'. *(Enumeration)*

**Base**: Show the base layer property set.

**Detail**: Show the detail layer property set.

The detail layer is a superset of the base layer which includes additional Clamp properties. Detail textures must be present in the material to show up on the branch and are masked by the Detail: Diffuse texture's alpha channel. |
---|

**Relative**: Both 'U' and V tile are computed based on the length and radius of the node.*(Enumeration)*

**U relative**: 'U' tile is computed based on the radius of the node.*(Enumeration)*

**V relative**: 'V' tile is computed based on the length of the node.*(Enumeration)*

**Absolute**: Both 'U' and 'V' tile are set explicitly.*(Enumeration)*

The number of times the material tiles around a branch.

If Texture Coordinates: Style is set to relative, this integer becomes a float and the actual value is a function of the radius of individual nodes. The computed U tile value is then rounded to an integer to avoid texture seams. |
---|

The number of times the material tiles along the length of a branch. *(Float)*

If Texture Coordinates: Style is set to relative, this integer becomes a float and the actual value is a function of the length of individual nodes. |
---|

Maximum possible 'U' offset. Each node receives a random value between 0 and this. *(Percentage)*

Setting the value to 1.0 ensures totally random U offsets. |
---|

Maximum possible 'V' offset. Each node receives a random value between 0 and this. *(Percentage)*

Setting the value to 1.0 ensures totally random 'V' offsets. |
---|

The number of full revolutions to twist the material per 'V' tile. *(Percentage)*

**False**- Each branch twists in a counter-clockwise direction.*(Boolean)*

**True**- Each branch twists the same amount in either a clockwise or counter-clockwise direction.*(Boolean)*

The number of times the material tiles around a branch. *(Integer / Float)*

If Texture Coordinates: Style is set to relative, this integer becomes a float and the actual value is a function of the radius of individual nodes. The computed U tile value is then rounded to an integer to avoid texture seams. |
---|

“Clamping” a detail texture prohibits it from tiling. Use this to make a non-repeating mark that appears on a specific part of a branch. *(Enumeration)*

**Both ›**Clamp texture from all four sides.**U ›**Clamp texture from Left to Right.**V ›**Clamp texture from Bottom to Top.**Neither ›**Do not clamp this texture.

Only available when editing Layer: Detail. Clamping streaks the last row of pixels in the clamped direction. Ensure that the detail mask is transparent at the point where the clamping occurs to avoid visible streaking. |
---|

Initial 'U' clamp percentage. *(Percentage)*

Terminal 'U' clamp percentage. *(Percentage)*

Initial 'V' clamp percentage. *(Percentage)*

Terminal 'V' clamp percentage. *(Percentage)*

Allows for a 0 to 360 degree rotation of the texture assigned to the cap's surface.

Scales the texture assigned to the cap's surface.

Branches, caps and fronds can each have multiple materials to be distributed randomly. Use the button controls to add [+] or remove [-] materials per geometry type. *(Enumeration)*

**Geometry**: A named mesh asset (only applies to fronds).

**Material**: A named material from the material bank, or set to 'inherited'.

**Weight**: Probability that a node will receive this material index (this weight ÷ sum of all weights).

Using multiple branch maps will require additional draw calls in real-time use. Use sparingly for tiling (branch) textures. |
---|

When enabled (and multiple branch, cap, and fronds materials are present), the distribution of cap and frond materials is synced to the distribution of branch materials. This ensures that “Branch 1” and “Cap 1” are always assigned together, and so on. *(Boolean)*

Under this property set, there are two groups in which the controls listed below will effect; 'Branch' and 'Cap'.

**Noise**: A generic, scalable noise pattern is used for displacement.*(Enumeration)*

**Use material**: The material's height map (located in the normal map's alpha channel) is used for displacement.*(Enumeration)*

**Named Displacement Texture**: A named 'displacement map' from the Asset bar is used for displacement.*(Enumeration)*

The displacement source is not exported for real-time use; it is used only as a modeling aid. |
---|

**Use base tex coords**: Displacement is mapped on top of the existing Layer: Base coordinates. Tile and offset are applied after obtaining the base coordinates.*(Enumeration)*

**Overwrite base tex coords**: Ignore the existing coordinates and map displacement explicitly by the other values in this group.*(Enumeration)*

The amount of surface displacement caused by displacement. *(Float)*

The amount to offset the vertices of each branch ring. Jaggedness is necessary for creating realistic breaks when physics are enabled. *(Float)*

The number of times displacement is repeated across the U direction of the geometry. *(Integer)*

If Displacement: Mapping is set to 'Use base tex coords', this value is a multiplier of the base U tile value. |
---|

The number of times displacement is repeated along the length of the geometry. *(Float)*

If Displacement: Mapping is set to 'Use base tex coords', this value is a multiplier of the base V tile value. |
---|

Maximum possible U offset. Each node receives a random value between 0 and this. *(Float)*

Setting the value to 1.0 ensures totally random U offsets. |
---|

Maximum possible V offset. Each node receives a random value between 0 and this. *(Boolean)*

Setting the value to 1.0 ensures totally random V offsets. |
---|

The amount to offset the depth of the displacement source. Values greater than one will push the displacement outwards and less than one will bring the displacement in towards the center of the branch. *(Float)*

The number of times displacement is tiled from the center of a cap. *(Float)*

Rotation offset for displacement texture. *(Percentage)*

Apply wind at this level. *(Boolean)*

Wind can only be applied to 2 distinct branch levels. |
---|

The strength of the wind effect on this set of nodes. *(Float)*

The left hand side of the profile curve must be zero to avoid branch disconnections. |
---|

Controls the direction of the vector along which this branch travels during wind oscillation. These values seldom change but can be modified to prevent neighboring branches from oscillating in the same direction (this is usually done in node editing mode). *(Percentage)*

When leaf style fronds are enabled, this selects a “wind group” that this generator belongs to. On the global wind properties, there are two distinct wind groups, each with their own set of property values. *(Enumeration)*

Controls how much this frond adheres to the frond rippling distance values set on the global wind settings. *(Percentage)*

Selects the fan object, allowing the alteration of all global wind settings. *(Function)*

An offset for the calculated amount of ambient occlusion. Increasing this value lessens the affect of ambient occlusion. *(Percentage)*

The difference in brightness from the heaviest ambient occlusion to no ambient occlusion. *(Percentage)*

This value clamps the least amount of ambient occlusion allowed. *(Percentage)*

This value clamps the most that ambient occlusion can ever darken. *(Percentage)*

When enabled, frond geometry is made physical as well. *(Boolean)*

**Relative**- The number of bones is based on the length of the spine.*(Enumeration)*

**Absolute**- The number of bones is explicitly set per-node.*(Enumeration)*

The number of bones generated along the length of spines (analogous to *Segments: Length*) (*Integer / Float)*

If Bone Style is set to relative, this integer becomes a float and the actual number of bones generated is a function of the length of individual nodes. |
---|

The percentage to scale the radius of the bones. *(Percentage)*

The percentage to scale the length of the bones. *(Percentage)*

The weight and stiffness of branch geometry in physics calculations. *(Float)*

Scales all of the geometry in this object's relevance in the automatically computed lightmap uv set. Keep in mind that the scale value is considered along with the geometry area and texture area of the object. In addition, every object's lightmap scale is compared to every other object and then the lightmap packing is determined. This means that your scale value may not be honored exactly or may get so large as to exhibit unexpected results. Use 'Tools→Reset lightmap scalars' to go back to default values for the whole model. *(Float)*