Nowadays, Parametric and Generative Design is getting popular. There are available several pieces of software developed by different companies, such as Rhino/Grasshopper (McNeel), Revit/Dynamo (Autodesk), Archicad/Param-o (Graphisoft), Sketchup/Viz-Pro (Trimble), Microstation/Generative Components (Bentley). However, almost all options are proprietary software.
This tutorial is a brief introduction to Sverchok. The examples will be more AEC related, but can the general principles explained can be applied in other fields as well.
First, download and install Sverchok on your machine. Go to Sverchok GitHub page and download
sverchok-master or use this link here. Then, in Blender, go to
Edit -> Preferences -> Add-ons -> Install an add-on and choose the file
svechok-master zip file. Check up the Sverchok box to activate it and save preferences.
Set up the Environment for Sverchok
In this next step, we are going to set up the Sverchok working environment. This is not mandatory, but it is convenient to use two monitors or a dedicated area to work with Sverchok.
With the Sverchok Layout selected, go to
Layout Workspace and duplicate, then rename it to “Sverchok”. After that, go to timeline viewport and hold
Shift+Mouse Left Button, dragging it outside the Blender window. It will make a new Blender window with the timeline, then you change the timeline window to Sverchok. After that, you can split the original timeline in two and set one as
Text Editor. We are going to check Sverchok geometry values on it.
Keep the other timeline as default because it will help you to visualise parametric changes through animations.
Also, you can minimise the
N tab on the Sverchok window and maximise Blender windows with
Crtl+spacebar to gain a little more space to work.
Finally, you can set up to visualise nodes icons under the
Edit -> Preferences -> add-ons -> Sverchok -> General -> Display icons only toggle box. Save this configuration under
File -> Defaults -> Save Startup File. It will make the changes persistent to your system with a dedicated layout to work with Sverchok.
First of all, we need to understand how Sverchok understands and manipulates geometries. The basic geometry in Sverchok is composed of vertices, edges, and polygons.
Edges paired vertices. In the case of our
Cube the pairs will be 12 pairs of vertices:
(0,1),(1,2),(2,3),(3,0),(4,5),(5,6),(6,7),(7,4),(0,4),(1,5),(2,6),(3,7) as shown bellow:
Finally, there are faces, which are groups (commonly composed by 3 or 4 elements) of edges. Using the
Cube as example, there are 6 faces:
Vertices, edges, and faces are stored in
Lists as in Python Lists.
Lists are data structures that store elements in an ordered manner.
For example, we can have a list of colours composed of four elements: “red”, “blue”, “yellow”, and “purple”. In Python, it will look like as shown below:
my_list_of_colours = ["red","blue","yellow","purple"]
We can access each element using an
index number representing the “address” of a specific number in a list as an
Indexes in Python and Sverchok start counting from the number
For example in the previous example
my_list_of_colour, the first element
red has the index
To access an element in a list, you can use its corresponding index in square brackets as shown:
my_list_of_colours # This access colour red
my_list_of_colours # This access colour blue
my_list_of_colours # This access colour yellow
my_list_of_colours # This access colour purple
For instance, if we use our previous described box
(1,1,1) the corresponding vertices, edges, and polygon as Python list will be:
vertices = [(0,0,0),(0,1,0),(1,1,0),(1,0,0),(0,0,1),(0,1,1),(1,1,1),(1,0,1)]`
In Sverchok, the data structure used to represent vertices is tuples. Tuples is an immutable data structure differing from lists that is mutable. A tuple can not be changed after its creation. However, inside Sverchok nodes, those data structures will be managed for us for now, and we do not need to worry about it.
edges = [ [0,1],[1,2],[2,3],[3,0],[4,5],[5,6],[6,7],[7,4],[0,4],[1,5],[2,6],[3,7] ]
Edges lists are represented as paired vertices lists.
polygons = [ [4,5,1,0],[5,6,2,1],[6,7,3,2],[7,4,0,3],[7,6,5,4],[0,1,2,3] ]
Polygons lists are lists of vertices index that describes a specific polygon. A polygon implicit carries edge information on it.
As you could note, the lists or tuples presented before are nested in another list
Sverchok lists can be nested on many levels. We start counting from
0 incrementing the counting as more nested levels are included.
level_one_list = [1,2,3,4]
level_two_list = [ [1,2,3], [4,5,6,7], [8,9,10] ]
level_three_list = [ [ [ 1,2,3] , [4,5,6,7] ] , [ [8,9] , [10,11,12] ] ]
In Sverchok the elements at level
0 are objects. For example, in the previous examples,
level_one_list has 4 objects,
level_two_list has 3 objects, and
level_three_list has two objects.
Let’s start it!
We have learnt how Sverchok organises data structures. Let’s make something more interesting. In this Hello World tutorial, we are making a Panelised Sine Wave Structure.
The first thing that we need to do is breaking our problem into small steps. So if we want to create Sine Wave like grid structure, first of all, we need to build a grid of vertices in the first place, but first need to know how to create a sequence of vertices, but before it comes to how to make a vertex.
We now roughly know the steps that we need to follow towards the final design:
vertex -> sequence of vertices -> grid -> Sine Wave like grid structure. We are going to add complexity to our algorithm incrementally. As we have seen before, a
vertex is represented by a vector in the
(x,y,z) Cartesian space. We can define a vector using a
number for each (x,y,z) axis. To create a number in Sverchok, first, we create a new node clicking in
New Node, then we can use
Shift+a to access the floating panel and get
Number -> a number then click in the canvas. We can define a number as a
float number (with decimal points) or
int (with no decimal points). Also, we can slide or click the panel at the bottom to increase or decrease the value of our number. To change the possible range of a number (change its minimum and maximum value), we can click into the gears of the node and choose the min and max values.
So to create the
vertex, we need
3 numbers, one for
x, another for
y, and another for
z. Let’s make two more as we did before or copy and paste the existing one with
Now, we can create the
vertex (vector) by using the node called
Vector In, in
Vector > Vector in.
I did not mention it yet, but Sverchok nodes are functions that operate values as
inputs on the left side, mapping those values as an expected outcome as an
output or outputs. In Sverchok, generally, inputs go into the left side, while outputs come out on the right side.
To run a Sverchok node, we just need to connect the
output from one node into the
input of another and get the expected result in the
output of the second node. To create a
vector, we can connect each number output to the input
Z of the
Vector in. To visualise the vector node, we can add another node called
Viz -> Viewer Draw), connecting the
Vector in output into
Also, we can visualise the vertices properties using the node
Stethoscope MK2, under
Text -> Stethoscope MK2 or using
Viewer text Mk3 under
Text -> Viewer text mk3. To visualise as a text rather than a frame in the Sverchok canvas, uncheck the box
frame and go to the Blender
Text editor Viewport and choose
text in the Sverchok_viewer. Sverchok automatically creates this text for us.
We can check that we have
1 object of the type
(x,y,z) coordinates corresponding to the chosen numbers.
The next step is to create a sequence of vertices. First, we need to create a sequence of numbers that will fill
(x,y,z) of the
Vector in node. We can use the node
Number Range (
Number -> Number Range). There are three different methods of creating a list of numbers:
Range, we can define a
start point, a
stop an endpoint, and
step that will establish the steps from one number to another inside the predefined range.
Count we define the
count, which means how many numbers will have inside the range (The steps will be base on the
count variable). The last option is
Step, in which we define
count(the stop number will be defined by the node).
In our example, we are going to use the method
Count. This example defines
25, and we can play with these numbers later. The next step is to plug the output
Number Range into the input
Vector in, and then we can have a
Viewer Draw to visualise our sequence of vertices. Now we can play with the number and see how it changes the number sequence.
So, what’s happening if we plug the same output
Range from the
Number Range node into the input
We just shift the vertices in the
Y direction as well, but if we want to have a grid of vertices, what is the next step?
So we just need to cross-reference the matrix between
Y using the node
List Match (
List -> List MAin -> List Match and choose the option
The next step is to transform the flat grid point into a sine/cosine grid. To make it, we define a cosine variation for
(x), a height for the curvature
(h), a displacement distance for the grid stay above of the ground
(d), a sine variation for
(y), and a factor for multiplication to amplify the curvature
The formula for this variation is:
d + (h*((cos(x)/f)+(sin(y)/f)))
We use the node
Script -> Formula) to use it in Sverchok.
We can use an
A Number (
Number -> A Number) for each value of
y will receive corresponding values from
To create panels, first, we divide the list into several lists with the same number of points in both dimensions.
To do that, we use the node
List Split (
List -> List Struct -> List Split). After that, we use the node
List Flip to transpose the matrix of points in the other direction.
After that, we are going to use both lists to build the panels. The node used to make panels in Sverchok is called
UV Connection (
Modifiers -> Modifiers Make -> UV Connection). We choose option
V and uncheck the option
slice, connecting the outputs of
List Split and
List Flip in
To divide the panels into triangular panels we can use the node
Poke Faces (
Modifiers -> Modifiers Change -> Poke Faces).
To create the openings in the panels we can use the node
CAD -> Inset Faces), then we mask the list just to get or frames or panels, using the node
List Mask (
List -> List Mask (out)).
To make it more interesting, we can use a parametric relation to transform the panels dynamically according to the height of the curvature of the sine wave. To create this effect, we need to work with some logical operators.
First, we need to determine the centre point of each panel. To do that we can use the node
Analyzer -> Origins).
Next, we can deconstruct the centre points into the corresponding
x,y,z values, using the
Vector Out node (
Vectors -> Vector Out).
We can use a threshold value to determine the height for the panels to start to change form. Therefore, we use the node
A Number and summing it to the number of displacement
d determined previously, using the node
Scalar Math, choosing the option
Number -> Scalar Math (Add)).
Now we can compare if the
z value of the centre points are bigger than our threshold, using the node
Logic Functions choosing the options
Logic -> Logic Functions (>))
We can divide the panels between above and below the threshold. First, we mask the output from the
Logic Functions node using
List Mask and level list equal
The next step is to delete the vertices that do not have faces associated with them, using the node
Delete Loose (
Modifiers -> Modifiers Change -> Delete Loose).
Now we can connect
Delete Loose output into
Poke Faces input and check for the filtered result.
To create the second part of the surface, we need to get the inverse mask from the previous one. We first use the node from
Logic Functions called
not and connect in the output of our list mask, inversing the boolean logic from the list, which means that every
True condition will become a
False and the same for the opposite. After that, we copy and paste the following nodes deleting the
Poke Faces nodes from the sequence. The panels will be created as a single rectangular panel in this second part differentiating from the first one of triangular panels.
Finally, we can replace
Viewer Draw with
Mesh Viewer, creating real-time meshes into the blender scene that can be animated. Also, we can put an extra
Mesh Viewer for the panels getting the
data false parameter from the
List Mask node.
Now we can play with the parameters and parametrically change the geometry.
You can download the blend file here