Hello there,

In the last and final part we looked at how to replicate the stairs into spiral, and also create the center pole and the hand rail of the staircase. And I left you with an exercise to create the balusters. I hope you tried playing with the BMesh API to create the balusters. In today’s newsletter, I am gonna be sharing my solution for the same.

Read this article online if the content gets clipped at the bottom.

Generating the Balusters

As I mentioned in the previous part, there are a couple of things to care about when it comes to generating the balusters:

We can’t get away with adding a single baluster per step, because the spacing between them would be too high. So we need to figure out how to add two or more balusters per step while still keeping them evenly spaced across.

The top of the baluster where it meets the hand rail is going to be different for each baluster added to a particular step. And the more number of balusters you want per step, the more the range of values will be.

Let’s first figure out the spacing of the balusters so that we can add multiple of them per stair and still have them spaced evenly. In my case I am gonna be adding two balusters for each step, but of course, the same be applied for any number of them.

Calculating the spacing of balusters

The first solution that comes to mind when you decide you want to add two balusters per step is to split the stair into 3 equal parts radially using two line and place our balusters on those lines. But let’s have a look at the following diagram:

It’s pretty clear, looking at the above diagram, that dividing a step into three parts and placing two balusters in each of them isn’t working. The balusters are spaced unevenly where there is less space between the two that are on the same step, but more space between two subsequent balusters that belong to different steps.

So in our case, in order to add two balusters per step and have them evenly spaced across the stairs, we have to divide the step into four equal parts (using three lines):

Looking at the diagram, we can see that dividing the each step into four equal parts and placing the balusters at alternating dotted lines makes them evenly spaced across. And if you were do some rough sketches and try extending this idea to more number of balusters, you will soon notice a recurring pattern. In order to add n number of balusters per step while still keeping them evenly across, we need to divide each step in 2 * n equal parts.

That is, if you want to add 3 balusters per step, you should divide each step into 6 equal parts (using 5 dotted lines), if you want to add 4, you need to divide each step into 8 equal parts (using 7 dotted lines) and so on. But I am gonna be sticking with 2 balusters for each step. So with the spacing figured out, let’s start writing some code.

Creating and distributing balusters

If you remember from part 1, we used X axis as our reference to create the first stair, eventually replicated it, and finally deleted the first stair since it was sitting exactly on the ground. We are gonna follow a similar approach here, but instead of deleting our original baluster, we are going to create them with reference to X axis, and directly move them into place.

First let’s create two balusters for the first step we created (which not longer exists) with one sitting above and one below the X axis (looking from the top view):

    ...
    angle=angle_rot * steps,
    dvec=(0, 0, thread_height/4)
)
# ---------------------- Code from part 2 ------------------------

angle_offset = angle_rot / 4

for i in range(1, 3):
    return_geo = bmesh.ops.create_circle(
        bm,
        cap_ends=True,
        segments=12, 
        radius=.0125
    )
    
    bmesh.ops.translate(
        bm,
        verts=return_geo['verts'],
        vec=(stair_diameter - RAILING_RADIUS - 0.05, 0, 0)
    )

    if i == 1:
        angle = angle_offset
    else:
        angle = angle_offset * -1
        
    matrix_rot = Matrix.Rotation(angle, 4, (0, 0, 1))      
    bmesh.ops.transform(bm, verts=return_geo['verts'], matrix=matrix_rot)
    circle_face = circle_face = return_geo['verts'][0].link_faces[0]

    return_geo = bmesh.ops.extrude_face_region(
        bm, 
        geom=return_geo['verts'] + [circle_face]
    )
    
    verts = [elem for elem in return_geo['geom'] \
                    if type(elem) == bmesh.types.BMVert]         
    bmesh.ops.translate(bm, verts=verts, vec=(0, 0, RAILING_HEIGHT))
				
    

# ---------------------- Code from part 2 ------------------------
bm.to_mesh(bpy.data.objects['Staircase'].data)
bpy.data.objects['Staircase'].data.update()
bm.free()

A few things to note here:

First we are calculating the angle_offset which is nothing but our angle_rot divided by the number of parts we decided to divide each step into, which is 4 in this case.

Then we create a for loop that runs for two iterations (because 2 balusters per step) within which we are creating the balusters. The reason we start from 1 instead of 0 for the range() function will become apparent shortly.

Inside the for loop we create a circle as usual and move it to the outer edge of the staircase using the same technique we used for positioning the initial circular profile for the hand rail. You can also notice we are referencing the same stair_diameter variable for this.

Then using an if statement, we are determining if the baluster should be rotated clockwise or counter-clockwise so that one sits above and one below the X axis in top view.

And finally we get the circle face and extrude it in Z axis using the RAILING_HEIGHT variable that we defined in the previous part. This extrusion distance is not correct, but at the moment it’s alright.

If everything went well, you should be seeing something like this in your viewport:

Now, let’s move these two balusters into place so that they sit on the existing first stair. All we need to do to position them on the stair is to simply add our angle_rot to our angle variable:

    ...
    if i == 1:
        angle = angle_rot + angle_offset
    else:
        angle = angle_rot + angle_offset * -1
    ...

What this basically means is that we first create the balusters exactly on the X axis, rotate them along Z axis by the angle of rotation, so that they sit on the midpoint of our first stair element, and depending on if it is the first or second iteration, we add or subtract our angle_offset respectively, so that the two balusters are rotated in opposite directions and placed on the either side with the spacing we need.

Let’s also add the tread_height as the Z component of the vector in our call to bmesh.ops.translate() so that the balusters sit on the stair rather than poking through them:

    ...    
    bmesh.ops.translate(
        bm,
        verts=return_geo['verts'],
        vec=(stair_diameter - RAILING_RADIUS - 0.05, 0, tread_height)
    )

    if i == 1:
        angle = angle_offset
    else:
        angle = angle_offset * -1
    ...

If you run the script now you should be seeing something like this in the viewport:

You can see that the balusters are not meeting the hand rail at the top. This is the problem we will be addressing next. But before that, let’s wrap our existing for loop in an another for loop, so that we have balusters on all the steps of the staircase:

for i in range(1, step_count + 1):
    for j in range(1, 3):
        ...
        
        bmesh.ops.translate(
            bm,
            verts=return_geo['verts'],
            vec=(stair_diameter - RAILING_RADIUS - 0.05, 0, i * tread_height)
        )

        if j == 1:
            angle = i * angle_rot + angle_offset
        else:
            angle = i * angle_rot + angle_offset * -1
            
        ...

A few things to note:

First we create another for loop that has iterations equal to the number of steps we have. Also note the outer loop has i as the loop variable and we have flipped i for j in the inner loop.

In our translate method, we are multiplying the tread_height by i and using it as the Z component for the translation vector. This way, with each iterations, the pair of balusters will be increment their Z position to match their corresponding stairs.

We do the same with our angle calculation by multiplying our the results by i, so that with each iteration the angle is incremented to match the rotation of their corresponding steps.

It is for this multiplication we start the loop variables at 1 instead of 0. Otherwise the first set of balusters will stay in their original places and not on the first stair.

The rest of the code inside the for loop remains the same, so I haven’t shown them in the above snippet. If everything went well, running the script should leave you with this result:

You can notice that there is a significant gap between the top of one of the balusters and the hand rail in each step. This is what we are gonna be solving next.

Calculating the right baluster heights

In order to calculate the correct height for the balusters, based on where they sit on a step, we need some more high school math. Have a look at the following diagram:

The above diagram is a simplified side view of a stair a stair. Assume the rectangular grey box at the bottom to be the stair and the inclined grey box at the top to be the railing. The black dotted lines (EF and E’F’) denote the balusters of the stair.

Looking at the diagram above, it is pretty clear that depending on where place a baluster on a stair between G and G’, the baluster height is going to be different at every point. And, if you didn’t realize already, G is the point at which the baluster height is going to be exactly the same as the our railing height. And at every point, as we move from G to G’, the baluster height is going to be slightly different.

The other thing to note is that, if we draw a horizontal line from A (where the baluster has the shortest height) to the line CG’ (where the baluster height is going to be maximum), we get a triangle ABC. And since AG and BG’ are of equal height, we only need to figure out what is the additional height offset we require from the line AB so that our balusters meet the hand rail.

Since ABC form a triangle, we can say that ratios between AD and DE, AD’ and D’E’, and AB and BC are equal. Which means, if we calculate the slope of the the railing, which in the diagram is the line AC, we can multiply the slope by length of AD to get the length DE which is the additional offset required at D. The same applies for point D’ and B. If we multiply lengths of AD’ and AB by the slope of AC, we would get the heights D’E’ and BC respectively.

In our case, the length of GG’ is nothing but he angle of rotation in radians which we already have in our angle_rot variable. So let adjust the heights of our balusters!

Making the balusters meet the hand rail

Even though we discussed quite a bit of math in the above section, there isn’t much code to write in this case. We simply need to calculate the slope of the hand rail and introduce it into the calculation of the baluster heights:

angle_offset = angle_rot / 4
slope = tread_height / angle_rot

for i in range(1, step_count + 1):
    for j in range(1, 3):

        ...

        if j == 1:
            angle = i * angle_rot + angle_offset
            height_offset = (angle_rot / 2 + angle_offset) * slope
        else:
            angle = i * angle_rot + angle_offset * -1
            height_offset = (angle_rot / 2 - angle_offset) * slope

        ...

        bmesh.ops.translate(
            bm, 
            verts=verts, 
            vec=(0, 0, RAILING_HEIGHT + height_offset)
        )

        ...

All we did we here is, first we calculated the slope by finding the ratio between the tread_height and angle_rot, introduced it into the height_offset calculation inside our if statement, and finally added it to the Z component of the translation vector used in the end of the loop that takes the extruded circle and moves them up until it meets the baluster.

That’s it! If everything went well, you should be seeing something like this in your viewport:

And there we go. We have our finished spiral staircase, with the balusters all meeting the hand rail at the right height. Kudos if you made it this far. I hope this gave you a good introduction on how to use BMesh to generate forms in Blender. You can grab the finished blend file from the same Gumroad link.

Thank you for reading. Let me know what you think in the comments (or Twitter). See you in the next post!

—Salai Vedha Viradhan

P.S.

There are a couple of more things you can explore in generating spiral staircases. For example:

You can create a solid block of mesh that can be used to cut a hole in the floor above using a boolean modifier. You will have to think about how to cut this hole so that it starts before a climbing person’s head would meet the ceiling.

You can also try adapting this method to generate a helical staircase, which is a variant of a spiral staircase, by introducing something like inner radius.

0 comments

Transformation Matrix – Interactive BLEND file

Blender Python Bites #7 – Implementing your own Context Managers

Blender Python Bites #6 – Arbitrary transforms using Transformation Matrices

Create a live 3D clock in Blender in less than 10 lines of Python 😎

🚀 Blender Python Cheatsheet – A Handy Reference for the Blender API

See all posts from Salai Vedha Viradhan