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

For my second post I wanted to explore an effect that a lot of games have but often look uninteresting, how does the surface of a character dry after being wet.

The result that I got looks better when it goes from wet to dry, but I might experiment with ways of making the surface wet using a different method, maybe a rain effect or something.

The first step was to try to understand what I needed to do, to keep it simple I'm just using fabric.
I identified 4 different stages that I would like the fabric to go through from dry to wet (although the effect is supposed to be from wet to dry, It's easier to start from dry).

1. Dry

   Material is not changed at all.

2. Damp
   Base color is slightly darkened.

3. Wet
   Roughness is lowered and the material gets glossier.

4. Dripping (there is no dripping effect at this point, but this was the best way to describe the fabric being 100% full of water)
   All normal maps are slightly blurred.

Apart from 1. which is neutral, all other stages have individual parameters, which might come in handy if I want to use this same Master material for other types of materials, like leather.

For the "Damp" effect I grabbed the base color blending that I did with the Fuzz and DetailCloth (see past post) and used a Lerp with the "Base Color Darkening" parameter as an Alpha so I can control how dark the Damp effect can be.

For the roughness it's pretty much the same thing, just a simple old Lerp making sure to use the previous roughness setup I did before, so I don't lose control over the base Fabric.

The final stage is an effect that is subtle and I'm still debating if it's worth it or not, but it's a cool idea that I will keep in mind so I can use it in the future. Basically, the technique is to force the engine to use a lower mipmap so it smooths out the details, this is to create a feeling that the fabric can't hold any more water, so the water is filling in the gaps of the fabric making it look smoother. (I got this idea from the youtuber "Visual Tech Art").

I created an Input inside my Detail Material Function so I could access it inside the master material and have more control.
Inside the master material, I've multiplied the "Wetness Blur" parameter with the "Wetness" main parameter so It can smooth in as the wetness parameter gets higher.

This effect would just affect the fine details like the tilers, it looks super noticeable on this example, but its mainly because the tile is super big and the model is super close, but I assume the effect is a lot less noticeable from far because the maps are already at a higher mipmap. But it's a cool and cheap effect.

To Give a cooler effect instead of just going from 0 to 1 in the wetness parameter, I've used a gradient with some noise, its tiled only on the U axis of the UV. I used a Lerp node to make sure the transition gets to 100% white, and I also have the Wetness parameter hooked up on a multiply to make sure the gradient is at Black when the Wetness is at 0.

The Ramp control in the middle is to have the effects kick-in in at different stages from one another, before I made this as soon as I started having the material darken it also started to get shinier and smoother, so having those functions gave a more realistic feel to the transition.

Combined with the fabric material I made on the last post, this is how the whole material looks.
In terms of learning I feel like this was super successful, I'm starting to get more comfortable with all the base nodes, and I can feel all the possibilities opening up in front of me.

Same disclaimer as last time, this is my journey into learning, so use what you learn here with caution as this is a process and next post I might discover a lot of better ways of doing the same effects. Also, It's going to take me a while until I really start to care about trying to do pretty stuff, as my main goal is to improve on the technical aspects of Unreal.

This is how the final effect is, in the future I might try to get a better effect of "getting wet" maybe with rain, as of right now this would work pretty well as a "drying" effect, so I would probably have to invert the Wetness parameter so 0 would be wet and 1 dry... but that's not super important right now.

References:
Visual Tech Art
Unreal Engine Documentation - Materials

This is the first entry of an ongoing series of posts that I'm going to be making about my learning journey.

There isn't going to be one strict theme, but I will try to post consistently about what I'm studying at the moment.

Unreal Materials / Master Material, Material Instances, Material Functions.

My goal on this study session was to get myself familiar with some of the basic tool we can use inside Unreal to create materials, I did work with materials before inside UE, and have done a lot of stuff with node based materials inside Maya, so I wasn't exactly starting from scratch... that being said I still felt that it was better to watch some tutorials and figure out how other people would try to solve the idea I had.

Before doing anything inside the material editor, I planned what I wanted to do and what I needed, just pen and paper at the moment.

Here is what I came up with:

Master Material

•     Basic Normal Folds (baked, but as for this study I used a tile with big folds)
  • Normal Flatness (intensity)
• Crumple Tile (a tileable normal map for memory folds)
  • Tile size
  • Normal Flatness
• Base Color
  • Tint
• Metallic
• Roughness

Fabric Tiler

• Normal Flatness
• Tile Size
• Diffuse Weight (to multiply on top of the base color)
• Roughness Weight (also multiply on top of the base color)

This wasn't on the initial plan but it was something I wanted to try and it was pretty much the same thing as the Fabric tiler

Fuzz Tiler

• Normal Flatness
• Tile Size
• Diffuse Weight (to multiply on top of the base color)
• Roughness Weight (also multiply on top of the base color)

After I wrote that down, I started getting the maps I needed to make that work.

Ok, so now I was ready to start building the material inside UE.
I started by working on the master material, it was a super straight forward setup, for the tilling I just used a TextureCoordinate connected to a Multiply and a float parameter to adjust the amount.

For the Normal Map control, I used the FlattenNormal node, and to combine all the normal maps I used the BlendAngleCorrectedNormals 

One thing I really wanted to try was to make the Detail Tilers outside the Master Material, to mimic what I think it would be best for a production environment, and the way I ended up doing was with Material Functions, I still need to do more digging to see if this is actually the best way, but it did work as intended.

Material Functions are super powerful as we can make a set of actions reusable in a easy way, and if we need to improve or change something inside that function it updates on all the other instances.

This is how the Cloth Detail Material Function ended up looking. Same setup for the tilling size, flatten normal for the intensity, I ended up using the Add node for the Cavity Intensity, because I used a multiply on the master material, and making it 100% white will just act as opacity.

I added an extra input for Masks, but it was needed for this study, but it's something important for more complex models.

For the Fuzz Detail, the Material Function is a bit more complex but it's just because I wanted a roughness and color control.

Adding it all together this is how the final Master Material node looked like:

and the result:

All the exposed parameters

The idea wasn't to get a perfect visual result, but to understand the workflow and learn the process, that being said I would say that it's a pretty decent result without doing anything super complex.

I assigned the material on a super simple shirt to see how it would look and I was impressed, even though the model is pretty bad, all the fine details and small folds gave the model a cool look. I might try to use it on a proper model later to see if holds up.

A little disclaimer, this series is not really intended to be used as a "tutorial" as I'm on the process of learning myself, so I might be making a lot of mistakes along the way, which is all good and part of the fun, but feel free to use it as inspiration to go and try stuff yourself.

References and tutorials I've used:
Master Material Basics! Unreal 5 (Must KNOW workflow!)

Detail Normal Mapping - Shader Graph Basics - Episode 13

Material Functions | 5-Minute Materials [UE5]

Unreal Engine Documentation - Materials