I thought it would be a good idea to share another example of how to use the Copy to Points node.

In theory, this setup is pretty similar to the last one, where we added meshes to points on a circular curve. However, this time I wanted more control over where each variation is placed.

Sometimes, randomizing placement works well to create a more organic feel. But when the object is handmade, there's usually a logic behind its placement.

A great way to add that "logic" is by using the Group by Range node. This is an incredibly powerful tool—I haven’t even scratched the surface of its possibilities.

In this example, I’m using it to create different groups based on point numbers. These points are selected using the Range Filter. For instance, with the default setting, all points are selected. But if I change "Select 1 of 1" to "Select 1 of 2," it selects every other point, essentially skipping one point. Changing it to "1 of 3" skips two points, and so on.

This is the basic logic of the setup. To avoid overlapping geometry, I’m also using the Blast node to remove points that were already used by the previous Copy to Points operation.

As in the last post, I can easily adjust the Resample amount to control the number of beads on the curve.

Don’t forget to use the Orient Along Curve node so the beads face the right direction.

Another helpful tip when creating this kind of procedural setup is to use a Match Size node after creating each bead. This ensures that if you swap the bead mesh, it will still fit within the setup, even if the new input mesh is larger or smaller than the previous one.

Make sure you click on Scale to Fit when using the Match Size node for the best results.

It’s hard to see, but I also added a chain to this necklace. It’s another simple Copy to Points setup!

One important thing to keep in mind is that if you change the scale of the input curve, the whole setup can fall apart. This happens because the scale of the input curve isn’t connected to the scale of each mesh transferred to the points.

So, whenever you want to move or scale the necklace, make sure to do it after the Copy to Points node.

Before we move on, here’s one last example. This setup is a bit more complex, but it highlights the possibilities. I used a Copy to Points node to scatter some detail meshes on a plane and then transferred their positions to the mask UV.

I wanted to test how quickly I could add this kind of randomized detail, and it turns out it’s really fast—and super easy to iterate, which is the most important part.

At the end of the day, just experiment and see what cool things you can create—and when you do, come tell me about it! Haha.

I have more cool uses for Copy to Points, but I think I’ll move on for now and explore other techniques in my next posts.

Until next time!

In this third entry, I want to talk about another one of my top two most-used nodes since I started learning Houdini.

The Copy to Points node is pretty straightforward in its most basic form: you plug in the mesh you want to copy and then plug in the points where you want the geometry to be placed.

To properly discuss Copy to Points, we first need to talk a little about points. As far as I know, points are a context unique to Houdini. At first, you might think of points as being the same as vertices, but they’re not exactly the same.

In geometry, which is what I use most, points and vertices share the same position, so when you move a point, you’re also moving the vertex with it. I know it sounds confusing at first, but you get used to it.

You can also store information on points and different information on vertices, but I won’t delve too deeply into that now to avoid further confusion.

What’s important—at least for the Copy to Points node—is that you store orientation and scale information on the points. When you copy geometry to those points, the size and orientation of the geometry follow the data stored on the points.

This is incredibly useful, as you can use things like masks or noise to randomize the orientation or scale of the geometries or make them follow specific patterns.

This can get pretty complex, involving things like painting flow maps or using curvature to control size, which might be a topic for another post—it’s a fun subject to explore.

For this post, I want to show you a quick and fun way to add a mesh to points and make it have random scale and rotation.

This is a simple setup I like to use often. I start with the Extract Borders node to get a curve around the border of the mesh. Then, I use the Resample node to ensure the spacing between the points is uniform. In this case, the Resample node also controls how many meshes are placed along the border since the meshes are copied to these points.

Next is the Orient Along Curve node, which ensures that the orientation of the meshes follows the curve correctly—this is a super useful node. To give it a more organic look, I added two Randomize nodes: one for scale and one for orientation. The effects are subtle, but they go a long way in making the result look more dynamic and natural.

For the border meshes, I used the same rope setup I showed in the last post, but applied it to a circle.

This same setup can be used as an InsertMesh Curve Brush in ZBrush, drawing a curve on the surface or creating your own curves in other ways, but with all the added benefits of a procedural workflow.

Another cool feature we can add is a random mesh picker. This allows us to have multiple inputs on the Copy to Points node, creating even greater variation and giving the result a more realistic look.

In this case, I just added three different color inputs to make it easier to see.

This is just one use for the Copy to Points node, but it’s one of the most valuable tools for me in Houdini. I’ll likely revisit it in future blog posts with more examples.

Thank you for reading! See you in the next one!

In the last post, I introduced why I want to explore Houdini and procedural tech as a Character Artist. From now on, I’ll dive deeper.

At the start of my journey, I focused mainly on two things: Curves and Points.

You can actually do a lot with just these two, especially using the Sweep Node and Copy to Points.

For example, a simple way to make a rope is by using a curve and two sweep nodes.

The first sweep transforms the spiral into columns of curves and twists them.

The second sweep then turns those curves into tubes with rounded caps.

There are other cool tricks I like to use to make this look even more interesting. A key point I'd like to emphasize is that being an "artist" learning a technical tool is a huge advantage; we can use our artistic knowledge to push the visuals further. The rope example I showed is fine, but knowing that real-world ropes have more imperfections and detail allows us to make it look much more convincing.

To achieve that result, I adjusted the Scale Along Curve setting on each of the Sweep nodes: on the first one to ensure the ends flare out, and on the second to make the tubes thinner at the ends. This already gives the rope a frayed look and makes it feel a bit more realistic.

Then, I duplicated the sweep nodes and created a thinner version with fewer columns to simulate some of the threads coming loose.

Of course, we can keep pushing this further—I’d add some noise to make the curve less smooth and add more variations here and there.

Another point I want to highlight is that this setup starts to function like a tool. By using the Recipe tool, you can essentially save this setup and reuse it whenever you want to make a rope. Each time you use it, you might add a bit more to the "tool," and over time, you’ll have a robust library.

And, as always, you can change the curve input, and everything updates automatically. You might need to adjust the twist amount—if the curve gets longer, you’ll need more twist.

In the next post, I'll talk a bit about the Copy to Points node.

See you in the next one!

Hello World!

For a few months, I’ve been learning Houdini, and you might wonder why. Houdini is typically used for simulations and tool creation, and most artists like myself never even considered opening it.

It's a fair question, and to be honest, during the first few days—or even weeks—I was questioning if this was really worth my time.

It turns out I soon realized that what kept me thinking about Houdini 24/7 was how incredibly fun it becomes once you get the hang of it. It’s a completely different way of thinking about modeling (which is my main skill and the one I wanted to test Houdini with). Plus, it opens a lot of doors that were only half-open before. By "half-open," I mean that, with time and effort, we can accomplish almost anything with traditional modeling, but in Houdini, some of those things are so easy that it makes you want to create characters just to try them.

And that brings me to the second reason I kept going: if this software can help me create things I’d usually avoid, then it's already worth the time and effort.

This blog will be personal, not a tutorial series. I'll write about my own experiences and hope to evolve along the way as I find new techniques and better methods. So, please don’t take everything I say here as absolute truth or the “right way.”

Hopefully, some of you find this helpful and maybe even start learning Houdini too.

On that note, you don’t need to buy a license to start; Houdini has an apprentice version that’s pretty good. There are some limitations, but for most things, you won’t even notice them. It’s the perfect way to start and see if this is for you.

Alright, let’s get to it.

I’ll try to include reference links at the end of each post whenever I have them.

Let’s talk a little about why procedural modeling is fun!

I was talking with a friend and showing him some things I was experimenting with, and his first thought (which is usually my thought too) was that the same thing could be done in Maya or ZBrush. But the perfect reply just popped into my mind: “but is it fun though?”

And that’s the main point—for me, working in Houdini is fun, maybe because it's a new approach after 14 years of traditional modeling.

If you've never tried it, you might wonder how different it is. Houdini uses a node-based approach for almost everything. Nodes are essentially visual scripting—a form of coding—so, in a way, you’re 3D modeling through code. Sounds crazy, I know, but it’s actually intuitive.

Let me give you an example:

Every node serves as an input. In this example:

1. Create a box
2. Taper it to make the top part smaller
3. Bevel the edges
4. Subdivide twice

One cool benefit of learning this approach is that it makes you reflect on how you’d typically do the same thing in other software and consider how to be more efficient in the future. For instance, here I used the bevel to add edge loops to preserve the cube's shape, whereas in Maya, I would probably add those edge loops manually.

Another example that highlights the power of procedural modeling is the ability to edit any parameter, which then updates everything down the node tree automatically.

I want to keep these blog posts relatively short so I can post more frequently.

That’s it for the first one. See you in the next one!

References:
Houdini Apprendice