 # L-System geometry node

Creates fractal geometry from the recursive application of simple rules.

L-systems (Lindenmayer-systems, named after Aristid Lindenmayer, 1925-1989), allow definition of complex shapes through the use of iteration. They use a mathematical language in which an initial string of characters is matched against rules which are evaluated repeatedly, and the results are used to generate geometry. The result of each evaluation becomes the basis for the next iteration of geometry, giving the illusion of growth.

The L-system SOP lets you simulate complex organic structures such as trees, lightning, snowflakes, flowers, and other branching phenomena.

### Placing an L-System in the viewer

To...Do this

Place the L-System anywhere in the scene

1. Click the  L-System tool on the Create tab.

2. Move the cursor into the scene view.

3. Click to place the L-System anywhere in the scene view and press Enter to confirm your selection.

If you press Enter without clicking, Houdini places the L-System at the origin.

Place the L-System at the origin

Press ⌃ Ctrl + on the  L-System tool on the shelf. Default L-Systems can be chosen from the Gear drop-down menu at the geometry level.

#### L-System Handles

The L-System does not have its own rotation parameters; however, you can rotate it at the object level using the handles in the scene view or by adding a  Transform node at the geometry level.

## Fractal properties

There are several factors which combine to organize plant structures and contribute to their beauty. These include:

• symmetry

• self-similarity

• developmental algorithms

With L-systems, we are mostly concerned with the latter two. Self-similarity implies an underlying fractal structure which is provided through strings of L-systems. Benoit Mandelbrot describes self-similarity as follows:

"When each piece of a shape is geometrically similar to the whole, both the shape and the cascade that generate it are called self-similar."

L-systems provide a grammar for describing the growth of self-similar structures in time. L-system rules determine the underlying structures of growth in a way that is analogous to the way that DNA is thought to determine biological growth. This growth relies on the principle of self-similarity to provide extremely compact descriptions of complex surfaces.

## Rewriting

The central concept of L-systems is rewriting. This works by recursively replacing an initial state (the initiator) with rewritten geometry (the generator), reduced and displaced to have the same end points as those of the interval being replaced.

In 1968, Astrid Lindenmayer introduced a string rewriting mechanism termed "L-systems". The grammar of L-systems is unique in that the method of applying productions is applied in parallel and simultaneously replaces all letters in a given "word".

The simplest example of a rewriting grammar is where two "words" or strings are used, built from the two letters: `a` and `b`, which may occur many times in a string. Each letter is associated with a rewriting rule. The rule `a = ab` means that the letter `a` is to be replaced by the string `ab`, and the rule `b = a` means that the letter `b` is to be replaced by `a`.

If we start the process with the letter `b` (the premise), and follow it through in time, we see a certain pattern emerges by following the rewriting rules: ## Production rule syntax

The general form of an L-system rule is:

`[left_context<] symbol [>right_context] [:condition]=replacement [:probability]`

Where…

left_context

An optional string that must precede the symbol for this rule to match.

symbol

The symbol to replace. For example, if the symbol is `A`, occurrences of `A` in the initial string will be replaced with replacement (if this rule matches).

right_context

An optional string that must follow the symbol for this rule to match.

condition

An optional expression that must be true for this rule to match.

replacement

The string that will replace the symbol (if this rule matches).

probability

The optional chance (between 0 and 1) that this rule will be executed. For example, using `0.8` means this rule will execute 80% of the time.

## Turtle commands

We can combine this string-manipulation system with a graphics routine that interprets the strings as commands for a drawing "turtle" with a position (XYZ) and heading (angle). By following the commands, the turtle traces out a shape as it moves.

Examples of simple turtle commands:

`F`

Move forward a step, drawing a line connecting the previous position to the new position.

`f`

Move forward without drawing.

`+`

Rotate right 90 degrees.

`-`

Rotate left 90 degrees.

(In the actual L-system node, the angle of the `+` and `-` commands is configurable.)

With these simple rules, we can easily come up with a string that causes the turtle to draw a shape such as the letter "L". For example, assuming the turtle is initially facing upwards, we would use the following string to create the letter "L": ## Rewriting turtle command strings

By iteratively running a turtle command string through rewrite rules, you can generate surprisingly complex geometry. The power of self-reference in rewrite rules can create extremely intricate figures.

As a very simple example of self-reference, consider an L-system with the initial string `A` and the rule `A=F+A`. The rule means "Wherever you see 'A', replace it with 'F+A'". Because the replacement will contain within it the trigger for the rule, each generation will cause the string to grow in a cascade effect: This generates a growing list of repeated "move forward, then turn" commands. With a turn angle less than 90 and a sufficient number of generations, this L-system will approximate an arc or circle. You could use this behavior as the basis for curling a sheet of paper or curling a scorpion’s tail. Or, you could randomize the turn angle and create a squiggly line, which you could use as the basis for a bolt of lightning.

(Be sure not to confuse the turtle command string `F+A` with the mathematical statement F plus A. In the context of L-systems, the `+` symbol means "turn", not "add".)

Another example: the following figure is called a quadratic Koch island. Beginning with these values:

 Initial string (premise) `F-F-F-F` Rewrite rule `F = F-F+F+FF-F-F+F` Angle `90`

…the turtle generates the following for three generations:   ## Branches

The systems described so far generate a single continuous line. To describe things like trees, we need a way to create branches.

In L-systems, you create branches with the square brackets (`[` and `]`). Any turtle commands you put inside square brackets are executed separately from the main string by a new turtle.

For example, the turtle commands `F [+F] F [+F] [-F]` is interpreted as:

1. Go forward.

2. Branch off a new turtle and have it turn right and then go forward.

3. Go forward.

4. Branch off a new turtle and have it turn right and then go forward.

5. Branch off a new turtle and have it turn left and then go forward.

This creates the following figure: Another example: the command string `F [+F] [-F] F [+F] -FF` creates the following figure: ## 3D

The systems described so far generate flat geometry.

To move the turtle in 3D, you use the `&` (pitch up), `^` (pitch down), `\\` (roll clockwise), and `/` (roll counter-clockwise) commands.

For example, the initial premise `FFFA` and the rule `A= " [&FFFA] //// [&FFFA] //// [&FFFA]`. This creates the following 3D figure:   `.  The rule creates three branches at every generation. The pitch up commands (`&`) split the branches off from the vertical. The roll commands (`/`) make the branches go out in different directions. (Note the `A` at the end of each branch that ensures new copies of the rule will grow from the ends of the branches.)

The `"` command makes the `F` commands half length in each generation, which makes the branches shrink further out.

## Use multiple L-system rules

In the previous section we used the rule `A= " [&FFFA] //// [&FFFA] //// [&FFFA]`.

Obviously this rule has redundancy. Since L-systems are about replacing symbols with strings, we can simply replace the repeated strings with a new symbol, and then create a new rule for that symbol:

 Rule 1 `A= " [B] //// [B] //// [B]` Rule 2 `B= &FFFA`

Because the branches are now defined in one place, if you want to change the branch instructions you only need to edit one string.

Note that the two-rule system will take twice as many generations to produce the same result. This is because each generation performs one rule substitution.

So, whereas the single rule `A= " [&FFFA] //// [&FFFA] //// [&FFFA]` grows by expanding `A` at each generation, the dual rules of `A= " [B] //// [B] //// [B]` and `B= &FFFA` work by alternating between replacing `A` with `" [B] //// [B] //// [B]` and replacing `B` with `&FFFA`.

## Turtle command reference

Normally turtle symbols use the current length/angle/thickness etc. to determine their effect. You can provide explicit arguments in brackets to override the normal values used by the turtle command.

The following list shows the bracketed arguments. Remember that you can simply use the single-character command without the arguments and Houdini will simply use the normal values.

See local functions and variables below for what functions and variables you can use in argument expressions inside the brackets.

`F(l,w,s,d)`

Move forward (creating geometry) distance l of width w using s cross sections of d divisions each.

`H(l,w,s,d)`

Move forward half the length (creating geometry) distance l of width w using s cross sections of d divisions each.

`G(l,w,s,d)`

Move forward but don’t record a vertex distance l of width w using s cross sections of d divisions each.

`f(l,w,s,d)`

Move forward (no geometry created) distance l of width w using s cross sections of d divisions each.

`h(l,w,s,d)`

Move forward a half length (no geometry created) distance l of width w using s cross sections of d divisions each.

`J(s,x,a,b,c)`, `K(s,x,a,b,c)`, `M(s,x,a,b,c)`

Copy geometry from leaf input J, K, or M at the turtle’s position after scaling and reorienting the geometry. The geometry is scaled by the s parameter (default Step Size) and stamped with the values a through c (default no stamping). Stamping occurs if the given parameter is present and the relevant Leaf parameter is set. The x parameter is not used and should be set to 0. Note that point vector attributes in the leaf inputs will be affected by the turtle movements.

`T(g)`

Apply tropism vector (gravity). This angles the turtle towards the negative Y axis. The amount of change is governed by g. The default change is to use the Gravity parameter.

`+(a)`

Turn right a degrees. Default Angle.

`-(a)`

Turn left a degrees (minus sign). Default Angle.

`&(a)`

Pitch up a degrees. Default Angle.

`^(a)`

Pitch down a degrees. Default Angle.

`\\(a)`

Roll clockwise a degrees. Default Angle.

`/(a)`

Roll counter-clockwise a degrees. Default Angle.

`|`

Turn 180 degrees

`*`

Roll 180 degrees

`~(a)`

Pitch / Roll / Turn random amount up to a degrees. Default 180.

`"(s)`

Multiply current length by s. Default Step Size Scale.

`!(s)`

Multiply current thickness by s. Default Thickness Scale.

`;(s)`

Multiply current angle by s. Default Angle Scale.

`_(s)`

Divide current length (underscore) by s. Default Step Size Scale.

`?(s)`

Divides current width by s. Default Thickness Scale.

`@(s)`

Divide current angle by s. Default Angle Scale.

`'(u)`

Increment color index U by u. Default UV Increment's first parameter.

`#(v)`

Increment color index V by v. Default UV Increment's second parameter.

`%`

Cut off remainder of branch

`\$(x,y,z)`

Rotates the turtle so the up vector is (0,1,0). Points the turtle in the direction of the point `(x,y,z)`. Default behavior is only to orient and not to change the direction.

`[`

Push turtle state (start a branch)

`]`

Pop turtle state (end a branch)

`{`

Start a polygon

`.`

Make a polygon vertex

`}`

End a polygon

`g(i)`

Create a new primitive group to which subsequent geometry is added. The group name is the Group Prefix followed by the number i. The default if no parameter is given is to create a group with the current group number and then increment the current group number.

`a(attrib, v1, v2, v3)`

This creates a point attribute of the name attrib. It is then set to the value `v1, v2, v3` for the remainder of the points on this branch, or until another a command resets it. v2 and v3 are optional. If they are not present, an attribute of fewer floats will be created. The created attribute is always of float type and with zero defaults. For example, the rule `a("Cd", 1, 0, 1)` added to the start of the premise will make the L-system a nice pugnacious purple.

## Local functions and variables

These functions and variables are available in arguments to turtle commands such as `F()`. These are separate from parameter expression functions and node local variables.

`acos(v)`

Arc cosine, the inverse of cosine. Returns the result in degrees.

`asin(v)`

Arc sine, the inverse of sine. Returns the result in degrees.

`cos(angle)`

Cosine. Takes an angle in degrees.

`sin(angle)`

Sine. Takes an angle in degrees.

`chan(idx)`

Returns the value of an animated spare parameter on this node at the current time.

You can add a spare parameter to the node, keyframe it, and then use the animated values to change the Lsystem over time.

Specify the name of the spare parameter using the LSystem channel prefix parameter.

For example, if you add a spare parameter tuple named `spare`, set the Lsystem channel prefix to `spare`. Then, to reference the value of `spare`'s first component (at the current time), use `chan(0)` (this evaluates the channel named `spare0`). To access the second component, use `chan(1)`, for the third component use `chan(2)`, and so on.

`min(a, b)`

Returns the lower of a or b.

`max(a, b)`

Returns the higher of a or b.

`in(x, y, z)`

This determines if the point (x, y, z) is inside the Meta Test Input.

`pic(x, y, plane)`

This evaluates the LSystem Picture at coordinates `(x, y)`. These should be in the range 0..1.

`plane`

Which image channel to get. `0` = luminance, `1` = red, `2` = green, and `3` = blue.

Returns a value from 0..1.

`rand(seed)`

Same as the rand expression function. You can get a quick random number using `rand(i)`.

`a`

The LSystem angle parameter.

`b`

The LSystem b parameter.

`c`

The LSystem c parameter.

`d`

The LSystem d parameter.

`g`

Initially 0. After that it is set to the age of the current rule.

`i`

The offset into the current lsystem string where the rule is being applied.

`t`

Initially 0. After that it is set to the iteration count.

`x`, `y`, `z`

The current turtle position in space.

`A`

The arc length from the root of the tree to the current point.

`L`

The current length increment at the point.

`T`

The LSystem gravity parameter.

`U`

The color map U value.

`V`

The color map V value.

`W`

The current width at the current point.

## Use modeled geometry in an L-system

Houdini lets you create a copy of some geometry at the turtle’s location using certain commands. You can use this to create leaves and flowers on an L-system shrub, for example.

1. Connect the output of the geometry you want to stamp to one of the L-system node’s inputs.

2. Use the corresponding command (`J`, `K`, or `M`) in a turtle command string to insert the geometry.

Input Turtle command
1 J
2 K
3 M

If you connect a leaf surface to the L-systems input 1 and a flower to input 2, you can use the following to create a bush with leaves and flowers:

 Premise `A` Rule 1 `A= [&FA [fK]] ///// [&FA [fJ]] /////// [&FA [fJ]]` Rule 2 `F= S/////` Rule 3 `S= F` Rule 1 prefaces the `K` and `J` commands with `f` (move forward without drawing) to offset the geometry a little bit. Otherwise, the leaf would be attached at its center, rather than the edge.

## Symbol variables

Each symbol can have up to five user-defined variables associated with it. You can reference or assign these variables in expressions. Variables in the matched symbol are instanced while variables in the replacement are assigned.

For example, the rule `A(i, j)=A(i+1, j-1)` will replace each `A` with a new `A` in which the first parameter (`i`) has been incremented and the second parameter (`j`) decremented.

Parameters assigned to geometric symbols (for example, `F`, `+`, and `!`) are interpreted geometrically. For example, the rule: ```F(i, j) = F(0.5*i, 2*j)``` will again replace each F with a new F containing modified parameters. In addition to this, the new F will now be drawn at half the length and twice the width.

## Control length over time

To create an L-system which goes forward x percent less on each iteration, you need to start your Premise with a value, and then in a rule multiply that value by the percentage you want to remain.

 Premise `A(1)` Rule `A(i)= F(i)A(i*0.5)`

This way i is scaled before A is re-evaluated. The important part is the premise: you need to start with a value to be able to scale it.

## Stamp variables onto input geometry

The third argument to the `J`/`K`/`M` commands is passed to the connected geometry.

1. Create a Circle node and set the number of divisions to `stamp("/path/to/lsystem", "lsys", 3)`.

Because the default number of divisions is 3 (the second argument in the expression), this creates a triangle.

2. Connect the output of the circle node to the J input of an L-system node.

3. In the L-system rules, you can use `J(L,0,number)` to pass number to the J geometry. For example, `J(L,0,4)` produces a square, `J(L,0,5)` produces a pentagram.

## Create groups within L-systems

The `g` command puts all geometry currently being built into a group.

The group name is composed of a prefix set on the Funcs tab and a number. Default prefix is `lsys`, producing group names like "lsys1". You can specify the number as an argument to the `g` command.

For example, `g[F]` puts geometry from the `F` into a group (named using ). Otherwise, the default index is incremented appropriately.

The current group is associated with the branch, so you can do things like `gF [ gFF ] F` to put the first and last `F` into group 0, and the middle (branched) `FF` into group 1.

To exclude a branch from its parent’s group, use `g(-1)`.

## Edge rewriting

In The Algorithmic Beauty of Plants, many examples use a technique called edge rewriting which involve left and right subscripts. A typical example is:

 Generations `10` Angle `90` Premise `F(l)` Rule 1 `F(l) = F(l)+F(r)+` Rule 2 `F(r)=-F(l)-F(r)`

However, Houdini doesn’t support the `F(l)` and `F(r)` syntax. You can modify the rules to use symbol variables instead.

For the F turtle symbol, the first four parameters are length, width, tubesides, and tubesegs. The last parameter is user-definable. We can define this last parameter so 0 is left, and 1 is right:

 Generations `10` Angle `90` Premise `F(1,1,3,3,0)` Rule 1 `F(i,j,k,l,m) :m=0 = F(i,j,k,l,0)+F(i,j,k,l,1)+` Rule 2 `F(i,j,k,l,m) :m=1 =-F(i,j,k,l,0)-F(i,j,k,l,1)`

After two generations this produces: `Fl+Fr+-Fl-Fr` There should not be any difference between this final string and: `F+F+-F-F`

Another approach is to use two new variables, and use a conditional statement on the final step to convert them to F:

 b `ch("generations")` Premise `l` Rule 1 `l:t

The produces the following output:

Generation String
0 `l`
1 `F`
2 `F+F+`
3 `F+F++-F-F+`

## Limit L-system growth inside a shape

The L-system node’s meta-test input lets you generate rules that will cause the system to stop when it reaches the edges of a defined shape, like a topiary hedge.

1. Create a metaball or merged metaballs that define the volume in which the L-system can grow.

2. Connect the metaball node’s output to the Meta-test input of the L-system node.

3. Use a conditional statement (`:`) with an "in" test. For example:

## Example

 Premise `FA` Rule 1 `A: in(x,y,z) = F [+FA] -FA : 80` Rule 2 `A: ! in(x,y,z) = A%`
• This L-system checks to see if the next iteration of growth will be within the Meta-test bounds, and if not it prunes the current branch.

• Rule 1 executes 80% of the time when the branch is within the meta-test boundary.

• Rule 2 executes when the branch is not within the meta-test boundary (the `!` negates the `in(x,y,z)` condition). The `%` command ends the branch.

## Arrange geometry instances with L-systems

L-systems can be a powerful tool for arranging modeled geometry. By using an L-system as the template input to a Copy SOP, you can place a copy of a model at every point of the L-system.

For example, you could use the "arc approximation" L-system from the L-system basics (premise=`A`, rule=`A=F+A`) to arrange a series of spheres in an arc or circle. This gives you parametric control of the bending and spacing of the arc of spheres.

If you have any serious interests in creating L-systems, you should obtain the book:

The Algorithmic Beauty of Plants by Przemyslaw Prusinkiewicz and Aristid Lindenmayer (1996, Springer-Verlag, New York. Phone 212.460.1500. ISBN: 0-387-94676-4)

It is the definitive work on the subject. It contains many L-systems examples along with ideas and theories about modeling realistic plant growth.

## Speed up calculations

Modeling something like a whole tree as single large L-System may cause collision resolution calculations to be single threaded. The wire solver will look for pieces of wire objects that can be solved independently and divide the work among the available cores. One large connected L-System means the work cannot be divided into smaller work units.

Try using a Wire Glue Constraint DOP to constrain a point on the L-System where the branches join together near the root of the tree (constrain the point to its world space position). This will cause the wire solver to see the separate branches as distinct pieces that can be solved independently. Since the constrained point will not move, any motion on one of the branches will not affect the other branches. If possible, reducing the number of points in the wire object should also speed up the calculations.

## Geometry

Type

The type of geometry to create as the turtle moves.

Skeleton

Draw polylines.

Tube

Draw tubes.

Generations

The number of times to repeat the rule-substitution. If you specify a fractional number and Continuous angles and/or Continuous length are on (below), Houdini scales the geometry generated by the last substitution to give smooth growth between generations.

Start Position

This is the starting point position for the turtle.

Random Scale

If non-zero, randomly scales all the lengths specified by F and other similar turtle functions.

Random Seed

The seed to use for the random number generator. By varying this on a L-system using random rules (Ie: random scale, ~, or probabilistic rules) one can generate different instances of the L-system.

Continuous Angles

If set, the angles rotated by the last generation’s turtle operations will be scaled by the amount into the generation.

Continuous Length

If set, the lengths taken by the last generation’s turtle operations will be scaled by the amount into the generation.

Continuous Width

If set, the widths generated by the last generation’s turtle operations will be scaled by the amount into the generation.

Apply Color

If set, the L-system will output a color attribute on each point. The color value will be found by looking up into the Image File at the current U & V positions. The current U & V is altered with the ' and # turtle operations.

Image File

This is the image file which is used for the Apply Color operation. The image files used by the pic() expression is under Funcs tab.

UV Increment

These determine the default U and V increments of the ' and

1. turtle operations.

Point Attributes

If the type is Skeleton, this is available. Turning this on will cause the creation of many point attributes to be created to track how each point was generated:

width

The width of the tube that would have been generated.

segs

The number of segments that would be made on a tube.

div

The number of divisions the tube would be divided into.

lage

The vertical increment from the root of the tree. This is affected by the Tube::Vertical Increment parameter. It is similar to arc, but not dependent on edge length.

arc

The arc length from the root of the turtles path to this point.

up

The up vector of the turtle at this point.

gen

The generation that created this point.

## Tube

Rows

The number of rows to divide tubes into. A value of 3 will cause the tubes to be swept triangles.

Cols

The number of columns to divide the tubes in. A value of 4 means one F will create 4 cross sections.

Tension

How straight the tubes should sweep to their destination point.

Branch Blend

How much a new branch should inherit off an old branches direction.

Thickness

Default width of the tubes.

Thickness Scale

How much the ! operation will affect the thickness.

Apply Tube Texture Coordinates

If checked, the tubes will generate uv texture coordinates.

Vertical Increment

The amount each tube will increment the V texture coordinate.

## Values

Step Size

The default size of a movement, such as F, command.

Step Size Scale

The number used by the " command.

Angle

The default angle for an angle, such as /, command. This also becomes the variable a in the expression.

Angle Scale

The number used by the ; command.

Variable b

The value of the expression variable b.

Variable c

The value of the expression variable c.

Variable d

The value of the expression variable d.

Gravity

The amount of tropism from the T command. Also becomes the value of the expression variable T.

Number Of Variables

This multiparm allows the assignment of an arbitrary number of new expression variables.

Variable Name

The name of the expression variable. This is a single character. Check the Local Variables section to see what variables are already reserved.

Variable Value

The value of the expression variable.

## Funcs

Pic Image File

The image file to use with the pic() expression function.

Group Prefix

The prefix used by g command.

Channel Prefix

The prefix used by the chan() expression function.

Leaf Param A

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.

Leaf Param B

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.

Leaf Param C

This is the name of the stamp parameter to stamp the leaf with. The value of the stamp comes from the J, K, or M operation. It can be read upstream using the stamp() function.

## Rules

If this is set, the rule fields are ignored. Instead, the Rule File is read and used as the rules.

Write Rule Parameters to File

This will write all the current rules to the Rule File.

Rule File

The name of the file to use as a source of rules. This file should have one line per rule. Blank lines and lines that start with '#' will be ignored, so comments may be added to the rule file with '#'.

Context Ignore

This is a list of symbols. They will be ignored when trying to determine contexts.

Context Includes Siblings

By default, the context of each branch only includes the symbols in that branch. Any sub-branches or parent branches will be skipped over. Given the rule `A>B=F`, `A[B]` will not resolve as B is in a sub-branch. `A[Q]B` will resolve because the `[Q]` is ignored. If you change the Context Ignore to have `[]`, this effect is removed and `A[Q]B` will not resolve but `A[B]` will. The Context Includes Siblings flag restores the pre-Houdini 10 behavior of context of sibling branches being included. For example, `[A]Q[B]` will resolve if this flag is set, but not resolve if it is not set.

Premise

The initial state of the L-system. This is the state of the L-system at generation 0.

Rule #

A rule to apply to the L-system. Applying the toggle will disable the rule, removing it from the generation procedure.

## Inputs

Leaf J

This geometry is used by the `J` rules.

Leaf K

This geometry is used by the `K` rules.

Leaf M

This geometry is used by the `M` rules.

Meta Test Input

This geometry is used by the `in()` function to check bounding regions (for topiaries).

## Examples

LSystemMaster Example for L-System geometry node

The LSystems SOP allows for the definition of complex shapes through the use of iteration. It uses a mathematical language in which an initial string of characters is evaluated repeatedly, and the results are used to generate geometry. The result of each evaluation becomes the basis for the next iteration of geometry, giving the illusion of growth.

The example networks located in this demonstration should be enough to get you started writing custom LSystem rules.

However, anyone seriously interested in creating LSystems should obtain the book:

The Algorithmic Beauty of Plants, Przemyslaw Prusinkiewicz and Aristid Lindenmayer

For a full list of LSystem commands, see the Houdini documentation.

LsystemBuilding Example for L-System geometry node

This example demonstrates how to use the L-System SOP to generate buildings with windows.

# Geometry nodes

• Removes elements while trying to maintain the overall appearance.

• Creates Points or Polygons, or adds points/polys to an input.

• Creates agent primitives.

• Adds new clips to agent primitives.

• Defines how agents' animation clips should be played back.

• Creates geometry describing possible transitions between animation clips.

• Creates a new agent layer that is suitable for collision detection.

• Creates point attributes that specify the rotation limits of an agent’s joints.

• Builds a constraint network to hold an agent’s limbs together.

• Writes agent definition files to disk.

• Edits properties of agent primitives.

• Adds a new layer to agent primitives.

• Adjusts the head of an agent to look at a specific object or position.

• Adds various common point attributes to agents for use by other crowd nodes.

• Provides simple proxy geometry for an agent.

• Creates parent-child relationships between agents.

• Adapts agents' legs to conform to terrain and prevent the feet from sliding.

• Adds new transform groups to agent primitives.

• Extracts geometry from agent primitives.

• Extracts geometry from agent primitives for a Vellum simulation.

• Loads the geometry from an Alembic scene archive (.abc) file into a geometry network.

• Creates a geometry group for Alembic primitives.

• Modifies intrinsic properties of Alembic primitives.

• Aligns a group of primitives to each other or to an auxiliary input.

• Cleans up a series of break operations and creates the resulting pieces.

• Blurs out (or "relaxes") points in a mesh or a point cloud.

• Changes the size/precision Houdini uses to store an attribute.

• Composites vertex, point, primitive, and/or detail attributes between two or more selections.

• Copies attributes between groups of vertices, points, or primitives.

• Adds or edits user defined attributes.

• Deletes point and primitive attributes.

• Allows simple VEX expressions to modify attributes.

• Fades a point attribute in and out over time.

• Interpolates attributes within primitives or based on explicit weights.

• Copies and flips attributes from one side of a plane to another.

• Adds noise to attributes of the incoming geometry.

• Interactively paint point attributes, such as color or deformation mask values, directly on geometry.

• Promotes or demotes attributes from one geometry level to another.

• Generates random attribute values of various distributions.

• Fits an attribute’s values to a new range.

• Renames or deletes point and primitive attributes.

• Modifies point attributes based on differences between two models.

• Edits string attribute values.

• Copies, moves, or swaps the contents of attributes.

• Transfers vertex, point, primitive, and/or detail attributes between two models.

• Transfers attributes between two geometries based on UV proximity.

• Runs a VOP network to modify geometry attributes.

• Runs a VEX snippet to modify attribute values.

• Samples texture map information to a point attribute.

• Copies information from a volume onto the point attributes of another piece of geometry, with optional remapping.

• Converts primitives for ODE and Bullet solvers.

• Computes lighting values within volume primitives

• Provides operations for moving knots within the parametric space of a NURBS curve or surface.

• Applies captures such as bend, twist, taper, and squash/stretch.

• Deletes primitives, points, edges or breakpoints.

• Computes a 3D metamorphosis between shapes with the same topology.

• The start of a looping block.

• The start of a compile block.

• The end/output of a looping block.

• The end/output of a compile block.

• Supports Bone Deform by assigning capture weights to bones.

• Supports Deform by assigning capture weights to points based on biharmonic functions on tetrahedral meshes.

• Utility node that supports Bone Capture Biharmonic by creating lines from bones with suitable attributes.

• Supports Bone Deform by assigning capture weights to points based on distance to bones.

• Uses capture attributes created from bones to deform geometry according to their movement.

• Creates default geometry for Bone objects.

• Combines two polygonal objects with boolean operators, or finds the intersection lines between two polygonal objects.

• Fractures the input geometry using cutting surfaces.

• Creates a bounding box, sphere, or rectangle for the input geometry.

• Creates a cube or six-sided rectangular box.

• Deforms the points in the first input using one or more magnets from the second input.

• Records and caches its input geometry for faster playback.

• Closes open areas with flat or rounded coverings.

• Converts array attributes into a single index-pair capture attribute.

• Converts a single index-pair capture attribute into per-point and detail array attributes.

• Adjusts capture regions and capture weights.

• Lets you paint capture attributes directly onto geometry.

• Copies capture attributes from one half of a symmetric model to the other.

• Overrides the capture weights on individual points.

• Supports Capture and Deform operation by creating a volume within which points are captured to a bone.

• Slices, cuts or extracts points or cross-sections from a primitive.

• Reads sample data from a chop and converts it into point positions and point attributes.

• Creates open or closed arcs, circles and ellipses.

• Transforms selected geometry into a circle.

• Lets you deform NURBS faces and NURBS surfaces by pulling points that lie directly on them.

• Helps clean up dirty models.

• Removes or groups geometry on one side of a plane, or creases geometry along a plane.

• Captures low-res simulated cloth.

• Deforms geometry captured by the Cloth Capture SOP.

• Creates a volume representation of source geometry.

• Fills a volume with a diffuse light.

• Applies a cloud like noise to a Fog volume.

• Low-level machinery to cluster points based on their positions (or any vector attribute).

• Higher-level node to cluster points based on their positions (or any vector attribute).

• Creates geometry and VDB volumes for use with DOPs collisions.

• Adds color attributes to geometry.

• Adjust surface point normals by painting.

• Creates lines between nearby pieces.

• Creates an attribute with a unique value for each set of connected primitives or points.

• Creates simple geometry for use as control shapes.

• Converts geometry from one geometry type to another.

• Converts a 2D height field to a 3D VDB volume, polygon surface, or polygon soup surface.

• Converts the input geometry into line segments.

• Polygonizes metaball geometry.

• Generates the oriented surface of a tetrahedron mesh.

• Converts sparse volumes.

• Converts a Point Cloud into a VDB Points Primitive, or vice versa.

• Converts the iso-surface of a volume into a polygonal surface.

• Decomposes the input geometry into approximate convex segments.

• Creates multiple copies of the input geometry, or copies the geometry onto the points of the second input.

• Copies geometry and applies transformations to the copies.

• Copies geometry in the first input onto curves of the second input.

• Copies geometry in the first input onto the points of the second input.

• Manually adds or removes a creaseweight attribute to/from polygon edges, for use with the Subdivide SOP.

• Deforms and animates a piece of geometry across a surface.

• Creates a surface around cross sections.

• Populates a crowd of agent primitives.

• Creates polygonal, NURBS, or Bezier curves.

• Deforms a spline surface by reshaping a curve on the surface.

• Finds the intersections (or points of minimum distance) between two or more curves or faces.

• Imports fields from DOP simulations, saves them to disk, and loads them back again.

• Imports scalar and vector fields from a DOP simulation.

• Imports option and record data from DOP simulations into points with point attributes.

• Generates point emission sources for debris from separating fractured rigid body objects.

• Runs a VEX snippet to deform geometry.

• Deletes input geometry by group, entity number, bounding volume, primitive/point/edge normals, and/or degeneracy.

• Smooths out (or "relaxes") point deformations.

• Attempts to prevent collisions when deforming geometry.

• Deletes edges from the input polygonal geometry merging polygons with shared edges.

• Measures the distance of the shortest path along the geometry’s edges or surfaces from each start point.

• Measures distance between each point and a reference geometry.

• Measures distance of each point from a target.

• Divides, smooths, and triangulates polygons.

• Imports and transforms geometry based on information extracted from a DOP simulation.

• Creates a curve based on user input in the viewport.

• Culls the input geometry according to the specifications of the For Each SOP.

• Collapses edges and faces to their centerpoints.

• Sharpens edges by uniquing their points and recomputing point normals.

• Inserts points on the edges of polygons and optionally connects them.

• Transforms selected edges so that all edges are of equal length.

• Flips the direction of polygon edges.

• Cuts geometry along edges using guiding curves.

• Straightens selected edges.

• Copies and optionally modifies attribute values along edges networks and curves.

• Edits points, edges, or faces interactively.

• Closes, opens, or clamps end points.

• Sets an attribute on selected points or primitives to sequential numbers or strings.

• Generates a message, warning, or error, which can show up on a parent asset.

• Pushes geometry out from the center to create an exploded view.

• Export transform attributes to object nodes.

• Computes the centroid of each piece of the geometry.

• Computes the best-fit transform between two pieces of geometry.

• Extrudes geometry along a normal.

• Extrudes surface geometry into a volume.

• Creates a surface or density VDB for sourcing FLIP simulations.

• Controls the smoothness of faceting of a surface.

• Evolves polygonal curves as vortex filaments.

• Reads, writes, or caches geometry on disk.

• Writes and reads geometry sequences to disk.

• Reads and collates data from disk.

• Creates smooth bridging geometry between two curves or surfaces.

• Finds the shortest paths from start points to end points, following the edges of a surface.

• Fits a spline curve to points, or a spline surface to a mesh of points.

• Compresses the output of fluid simulations to decrease size on disk

• Creates 3D text from Type 1, TrueType and OpenType fonts.

• Uses a metaball to attract or repel points or springs.

• Creates jagged mountain-like divisions of the input geometry.

• Creates a set of hair-like curves across a surface.

• Merges points.

• Geometry nodes live inside Geo objects and generate geometry.

• Adds strength to a glue constraint network according to cluster values.

• Generates particles to be used as sources in a particle-based grain simulation.

• Assigns a unique integer attribute to non-touching components.

• Creates planar geometry.

• Blends the guides and skin of two grooms.

• Fetches groom data from grooming objects.

• Packs the components of a groom into a set of named Packed Primitives for the purpose of writing it to disk.

• Switches between all components of two groom streams.

• Unpacks the components of a groom from a packed groom.

• Generates groups of points, primitives, edges, or vertices according to various criteria.

• Combines point groups, primitive groups, or edge groups according to boolean operations.

• Copies groups between two pieces of geometry, based on point/primitive numbers.

• Deletes groups of points, primitives, edges, or vertices according to patterns.

• Expands or shrinks groups of Edges, Points, Primitives, or Vertices.

• Runs VEX expressions to modify group membership.

• Constructs groups for paths between elements.

• Sets group membership interactively by painting.

• Converts point, primitive, edge, or vertex groups into point, primitive, edge, or vertex groups.

• Groups points and primitives by ranges.

• Renames groups according to patterns.

• Transfers groups between two pieces of geometry, based on proximity.

• Groups points and primitives by lasso.

• Creates a group that includes the boundaries of the specified attribute.

• Advects guide points through a velocity volume.

• Resolves collisions of guide curves with VDB signed distance fields.

• Deforms geometry with an animated skin and optionally guide curves.

• Allows intuitive manipulation of guide curves in the viewport.

• Creates standard primitive groups used by grooming tools.

• Quickly give hair guides some initial direction.

• Creates masking attributes for other grooming operations.

• Creates and prepares parting lines for use with hair generation.

• Looks up skin geometry attributes under the root point of guide curves.

• Constructs a coherent tangent space along a curve.

• Transfer hair guides between geometries.

• Converts dense hair curves to a polygon card, keeping the style and shape of the groom.

• Clumps guide curves together.

• Generates hair on a surface or from points.

• Generates a velocity field based on stroke primitives.

• Generates an initial heightfield volume for use with terrain tools.

• Blurs a terrain height field or mask.

• Limits height values to a certain minimum and/or maximum.

• Creates a copy of a height field or mask.

• Extracts a square of a certain width/length from a larger height volume, or resizes/moves the boundaries of the height field.

• Creates a cutout on a terrain based on geometry.

• Displaces a height field by another field.

• Advects the input volume through a noise pattern to break up hard edges and add variety.

• Lets you draw shapes to create a mask for height field tools.

• Calculates thermal and hydraulic erosion over time (frames) to create more realistic terrain.

• Simulates the erosion from one heightfield sliding over another for a short time.

• Distributes water along a heightfield. Offers controls for adjusting the intensity, variability, and location of rainfall.

• Calculates the effect of thermal erosion on terrain for a short time.

• Imports a 2D image map from a file or compositing node into a height field or mask.

• Generates flow and flow direction layers according to the input height layer.

• Copies another layer over the mask layer, and optionally flattens the height field.

• Composites together two height fields.

• Sets all values in a heightfield layer to a fixed value.

• Sets the border voxel policy on a height field volume.

• Creates a mask based on different features of the height layer.

• Creates a mask based some other geometry.

• Creates a mask where the input terrain is hollow/depressed, for example riverbeds and valleys.

• Adds vertical noise to a height field, creating peaks and valleys.

• Exports height and/or mask layers to disk as an image.

• Lets you paint values into a height or mask field using strokes.

• Patches features from one heightfield to another.

• Adds displacement in the form of a ramps, steps, stripes, Voronoi cells, or other patterns.

• Projects 3D geometry into a height field.

• Applies a material that lets you plug in textures for different layers.

• Remaps the values in a height field or mask layer.

• Changes the resolution of a height field.

• Scatters points across the surface of a height field.

• Simulates loose material sliding down inclines and piling at the bottom.

• Creates stepped plains from slopes in the terrain.

• Stitches height field tiles back together.

• Splits a height field volume into rows and columns.

• Height field specific scales and offsets.

• Visualizes elevations using a custom ramp material, and mask layers using tint colors.

• Makes holes in surfaces.

• Deforms the points in the first input to make room for the inflation tool.

• Instances Geometry on Points.

• Creates points with attributes at intersections between a triangle and/or curve mesh with itself, or with an optional second set of triangles and/or curves.

• Composes triangle surfaces and curves together into a single connected mesh.

• Processes its inputs using the operation of a referenced compiled block.

• Builds an offset surface from geometry.

• Generates an isometric surface from an implicit function.

• The Join op connects a sequence of faces or surfaces into a single primitive that inherits their attributes.

• Divides, deletes, or groups geometry based on an interactively drawn line.

• Creates fractal geometry from the recursive application of simple rules.

• Deforms geometry based on how you reshape control geometry.

• Reads a lidar file and imports a point cloud from its data.

• Creates polygon or NURBS lines from a position, direction, and distance.

• Animates points using an MDD file.

• Deforms geometry by using another piece of geometry to attract or repel points.

• Aligns the input geometry to a specific axis.

• Resizes and recenters the geometry according to reference geometry.

• Reorders the primitive and point numbers of the input geometry to match some reference geometry.

• Assigns one or more materials to geometry.

• Measures area, volume, or curvature of individual elements or larger pieces of a geometry and puts the results in attributes.

• Merges geometry from its inputs.

• Defines groupings of metaballs so that separate groupings are treated as separate surfaces when merged.

• Creates metaballs and meta-superquadric surfaces.

• Duplicates and mirrors geometry across a mirror plane.

• Displaces points along their normals based on fractal noise.

• Supports Muscle Deform by assigning capture weights to points based on distance away from given primitives

• Deforms a surface mesh representing skin to envelop or drape over geometry representing muscles

• Creates a "naming" attribute on points or primitives allowing you to refer to them easily, similar to groups.

• Computes surface normal attribute.

• Does nothing.

• Merges geometry from multiple sources and allows you to define the manner in which they are grouped together and transformed.

• Assists the creation of a Muscle or Muscle Rig by allowing you to draw a stroke on a projection surface.

• Deforms input geometry based on ocean "spectrum" volumes.

• Generates particle-based foam

• Generates particles and volumes from ocean "spectrum" volumes for use in simulations

• Generates volumes containing information for simulating ocean waves.

• Instances individual waveforms onto input points and generated points.

• Executes an OpenCL kernel on geometry.

• Computes orientations (frames) along curves.

• Marks the output of a sub-network.

• Packs geometry into an embedded primitive.

• Packs points into a tiled grid of packed primitives.

• Editing Packed Disk Primitives.

• Editing Packed Primitives.

• Creates a color volume based on drawn curve

• Creates a fog volume based on drawn curve

• Creates an SDF volume based on drawn curve

• Generates a surface around the particles from a particle fluid simulation.

• Creates a set of regular points filling a tank.

• Places points and primitives into groups based on a user-supplied rule.

• Moves primitives, points, edges or breakpoints along their normals.

• Creates a planar polygonal patch.

• Fills in a 2d curve network with triangles.

• Deforms flat geometry into a pleat.

• Creates platonic solids of different types.

• Constructs an iso surface from its input points.

• Deforms geometry on an arbitrary connected point mesh.

• Creates new points, optionally based on point positions in the input geometry.

• Jitters points in random directions.

• Moves points with overlapping radii away from each other, optionally on a surface.

• Generates a cloud of points around the input points.

• Splits points shared by multiple vertices, optionally only if the vertices differ in attribute values.

• Computes and manipulates velocities for points of a geometry.

• Merges points interactively.

• Creates set of regular points filling a volume.

• Creates flat or tube-shaped polygon surfaces between source and destination edge loops, with controls for the shape of the bridge.

• Creates offset polygonal geometry for planar polygonal graphs.

• Extrudes polygonal faces and edges.

• Creates straight, rounded, or custom fillets along edges and corners.

• Breaks curves where an attribute crosses a threshold.

• Helps repair invalid polygonal geometry, such as for cloth simulation.

• Fills holes with polygonal patches.

• Creates coordinate frame attributes for points and vertices.

• Creates new polygons using existing points.

• Creates a smooth polygonal patch from primitives.

• Cleans up topology of polygon curves.

• Reduces the number of polygons in a model while retaining its shape. This node preserves features, attributes, textures, and quads during reduction.

• Combines polygons into a single primitive that can be more efficient for many polygons

• The PolySpline SOP fits a spline curve to a polygon or hull and outputs a polygonal approximation of that spline.

• Divides an existing polygon into multiple new polygons.

• Constructs polygonal tubes around polylines, creating renderable geometry with smooth bends and intersections.

• Interpolates between a set of pose-shapes based on the value of a set of drivers.

• Combine result of Pose-Space Deform with rest geometry.

• Packs geometry edits for pose-space deformation.

• Creates common attributes used by the Pose-Space Edit SOP.

• Edits primitive, primitive attributes, and profile curves.

• Extracts or manipulates profile curves.

• Creates profile curves on surfaces.

• Applies common post-processing effects to the results of Pyro solves.

• Runs a dynamic Pyro simulation.

• Creates points for sourcing pyro and smoke simulations.

• Pyro Source Spread solves for the spreading of flame across a point cloud.

• Runs a Python snippet to modify the incoming geometry.

• Runs a dynamic Bullet simulation.

• Combines fractured pieces or constraints into larger clusters.

• Packs and creates attributes describing rigid body objects.

• Stores the primitive number and distance to the opposite face on the inside faces of fractured geometry.

• Creates attributes describing rigid body constraints.

• Creates rigid body constraint geometry from curves drawn in the viewport.

• Creates rigid body constraint geometry from interactively drawn lines in the viewport.

• Creates rigid body constraint geometry from a set of rules and conditions.

• Converts existing constraint prims into constraints with different anchor positions.

• Deforms geometry with simulated proxy geometry.

• Detects when connected faces have become separated.

• Merges RBD fractured geometry with the proxy geometry and pushes it out from the center to create an exploded view.

• Packs RBD fractured geometry, saves them to disk, and loads them back again.

• Creates additional detail on the interior surfaces of fractured geometry.

• Fractures the input geometry based on a material type.

• Packs RBD geometry, constraints, and proxy geometry into a single geometry.

• Paints values onto geometry or constraints using strokes.

• Unpacks an RBD setup into three outputs.

• Attaches RenderMan shaders to groups of faces.

• Generates surfaces by stretching cross-sections between two guide rails.

• Projects one surface onto another.

• Increases the number of points/CVs in a curve or surface without changing its shape.

• Scatters new guides, interpolating the properties of existing guides.

• Recreates the shape of the input surface using "high-quality" (nearly equilateral) triangles.

• Repacks geometry as an embedded primitive.

• Resamples one or more curves or surfaces into even length segments.

• Sets the alignment of solid textures to the geometry so the texture stays put on the surface as it deforms.

• Retimes the time-dependent input geometry.

• Reverses or cycles the vertex order of faces.

• Revolves a curve around a center axis to sweep out a surface.

• Rewires vertices to different points specified by an attribute.

• Generates ripples by displacing points along the up direction specified.

• Generates ripples by displacing points along the up direction specified.

• Scatters new points randomly across a surface or through a volume.

• Runs scripts when cooked.

• Lets you interactively reshape a surface by brushing.

• Morphs though a sequence of 3D shapes, interpolating geometry and attributes.

• Computes the post-deform or pre-deform difference of two geometries with similar topologies.

• Computes the convex hull of the input geometry and moves its polygons inwards along their normals.

• Builds a skin surface between any number of shape curves.

• Creates a sky filled with volumentric clouds

• Smooths out (or "relaxes") polygons, meshes and curves without increasing the number of points.

• Moves the selected point along its normal, with smooth rolloff to surrounding points.

• Moves the selected point, with smooth rolloff to surrounding points.

• Creates a tetrahedral mesh that conforms to a connected mesh as much as possible.

• Creates a simple tetrahedral mesh that covers a connected mesh.

• Creates a partition of a tetrahedral mesh that can be used for finite-element fracturing.

• Allows running a SOP network iteratively over some input geometry, with the output of the network from the previous frame serving as the input for the network at the current frame.

• Reorders points and primitives in different ways, including randomly.

• Creates a sphere or ovoid surface.

• Splits primitives or points into two streams.

• Spray paints random points onto a surface.

• A SOP node that sets the sprite display for points.

• Insets points on polygonal faces.

• Caches the input geometry in the node on command, and then uses it as the node’s output.

• Stretches two curves or surfaces to cover a smooth area.

• Low level tool for building interactive assets.

• Subdivides polygons into smoother, higher-resolution polygons.

• The Subnet op is essentially a way of creating a macro to represent a collection of ops as a single op in the Network Editor.

• Trims or creates profile curves along the intersection lines between NURBS or bezier surfaces.

• Creates a surface by sweeping a cross section curve along a spine curve.

• Switches between network branches based on an expression or keyframe animation.

• Switches between two network branches based on an expression or geometry test.

• Sends input geometry to a TOP subnet and retrieves the output geometry.

• Reads a CSV file creating point per row.

• Creates a rock creature, which can be used as test geometry.

• Creates a pig head, which can be used as test geometry..

• Creates a rubber toy, which can be used as test geometry.

• Creates a shader ball, which can be used to test shaders.

• Creates a squab, which can be used as test geometry.

• Creates a soldier, which can be used as test geometry.

• Provides a simple crowd simulation for testing transitions between animation clips.

• Provides a simple Bullet simulation for testing the behavior of a ragdoll.

• Partitions a given tetrahedron mesh into groups of tets isolated by a given polygon mesh

• Performs variations of a Delaunay Tetrahedralization.

• Cooks the input at a different time.

• Sets attributes used by the Toon Color Shader and Toon Outline Shader.

• Lets you interactively draw a reduced quad mesh automatically snapped to existing geometry.

• Creates a torus (doughnut) shaped surface.

• Traces curves from an image file.

• Creates trails behind points.

• The Transform operation transforms the source geometry in "object space" using a transformation matrix.

• Transforms the input geometry relative to a specific axis.

• Transforms the input geometry by a point attribute.

• Transforms input geometry according to transformation attributes on template geometry.

• Creates a triangular Bezier surface.

• Refines triangular meshes using various metrics.

• Connects points to form well-shaped triangles.

• Trims away parts of a spline surface defined by a profile curve or untrims previous trims.

• Creates open or closed tubes, cones, or pyramids.

• Generates an edge group representing suggested seams for flattening a polygon model in UV space.

• Adjusts texture coordinates in the UV viewport by painting.

• Lets you interactively move UVs in the texture view.

• Creates flattened pieces in texture space from 3D geometry.

• Merges UVs.

• Packs UV islands efficiently into a limited area.

• Relaxes UVs by pulling them out toward the edges of the texture area.

• Assigns UVs by projecting them onto the surface from a set direction.

• Applies an image file as a textured shader to a surface.

• Assigns texture UV coordinates to geometry for use in texture and bump mapping.

• Transforms UV texture coordinates on the source geometry.

• Separates UVs into reasonably flat, non-overlapping groups.

• Processes geometry using an external program.

• Unpacks packed primitives.

• Unpacks points from packed primitives.

• Converts "packed USD" primitives into normal Houdini geometry.

• Creates one or more empty/uniform VDB volume primitives.

• Activates voxel regions of a VDB for further processing.

• Expand or contract signed distance fields stored on VDB volume primitives.

• Moves VDBs in the input geometry along a VDB velocity field.

• Moves points in the input geometry along a VDB velocity field.

• Computes an analytic property of a VDB volumes, such as gradient or curvature.

• Clips VDB volume primitives using a bounding box or another VDB as a mask.

• Combines the values of two aligned VDB volumes in various ways.

• Tests VDBs for Bad Values and Repairs.

• Cuts level set VDB volume primitives into multiple pieces.

• Build an LOD Pyramid from a VDB.

• Blends between source and target SDF VDBs.

• Create a mask of the voxels in shadow from a camera for VDB primitives.

• Deletes points inside of VDB Points primitives.

• Manipulates the Internal Groups of a VDB Points Primitive.

• Computes the steady-state air flow around VDB obstacles.

• Removes divergence from a Vector VDB.

• Fixes signed distance fields stored in VDB volume primitives.

• Re-samples a VDB volume primitive into a new orientation and/or voxel size.

• Reshapes signed distance fields in VDB volume primitives.

• Splits SDF VDBs into connected components.

• Smooths out the values in a VDB volume primitive.

• Smooths out SDF values in a VDB volume primitive.

• Creates an SDF VDB based on the active set of another VDB.

• Merges three scalar VDB into one vector VDB.

• Splits a vector VDB primitive into three scalar VDB primitives.

• Replaces a VDB volume with geometry that visualizes its structure.

• Generates a signed distance field (SDF) VDB volume representing the surface of a set of particles from a particle fluid simulation.

• Converts point clouds and/or point attributes into VDB volume primitives.

• Converts polygonal surfaces and/or surface attributes into VDB volume primitives.

• Fills a VDB volume with adaptively-sized spheres.

• Configures geometry for Vellum Grain constraints.

• Configure constraints on geometry for the Vellum solvers.

• Vellum solver setup to pre-roll fabric to drape over characters.

• Packs Vellum simulations, saves them to disk, and loads them back again.

• Packs Vellum geometry and constraints into a single geometry.

• Applies common post-processing effects to the result of Vellum solves.

• Ties vellum points to a reference frame defined by moving geometry.

• Blends the current rest values of constraints with a rest state calculated from external geometry.

• Runs a dynamic Vellum simulation.

• Unpacks a Vellum simulation into two outputs.

• Verify that a bsdf conforms to the required interface.

• Manually adds or edits attributes on vertices (rather than on points).

• Shows/hides primitives in the 3D viewer and UV editor.

• Lets you attach visualizations to different nodes in a geometry network.

• Creates a volume primitive.

• Computes analytic properties of volumes.

• Computes a speed-defined travel time from source points to voxels.

• Blurs the voxels of a volume.

• Bounds voxel data.

• Cuts polygonal objects using a signed distance field volume.

• Re-compresses Volume Primitives.

• Convolves a volume by a 3×3×3 kernel.

• Compute the Fast Fourier Transform of volumes.

• Feathers the edges of volumes.

• Flattens many volumes into one volume.

• Combines the scalar fields of volume primitives.

• Translates the motion between two "image" volumes into displacement vectors.

• Fill in a region of a volume with features from another volume.

• Remaps a volume according to a ramp.

• Rasterizes into a volume.

• Samples point attributes into VDBs.

• Converts a curve into a volume.

• Converts fur or hair to a volume for rendering.

• Converts a point cloud into a volume.

• Converts a point cloud into a volume.

• Reduces the values of a volume into a single number.

• Resamples the voxels of a volume to a new resolution.

• Resizes the bounds of a volume without changing voxels.

• Builds a Signed Distance Field from an isocontour of a volume.

• Extracts 2d slices from volumes.

• Splices overlapping volume primitives together.

• Stamps volumes instanced on points into a single target volume.

• Adaptively surfaces a volume hierarchy with a regular triangle mesh.

• Computes a trail of points through a velocity volume.

• Runs CVEX on a set of volume primitives.

• Computes a velocity volume.

• Generates a volume velocity field using curve tangents.

• Generates a velocity field within a surface geometry.

• Adjusts attributes for multi-volume visualization.

• Runs a VEX snippet to modify voxel values in a volume.

• Sets the voxels of a volume from point attributes.

• Fractures the input geometry by performing a Voronoi decomposition of space around the input cell points

• Given an object and points of impact on the object, this SOP generates a set of points that can be used as input to the Voronoi Fracture SOP to simulate fracturing the object from those impacts.

• Cuts the geometry into small pieces according to a set of cuts defined by polylines.

• Creates the point attributes needed to create a Vortex Force DOP.

• Generates volumes to be used as sources in a whitewater simulation.

• Computes generalized winding number of surface at query points.

• Morphs between curve shapes while maintaining curve length.

• Captures surfaces to a wire, allowing you to edit the wire to deform the surface.

• Deforms geometry captured to a curve via the Wire Capture node.

• Transfers the shape of one curve to another.

• Constructs polygonal tubes around polylines, creating renderable geometry.

• Assigns channel paths and/or pickscripts to geometry.