# A step by step guide to linking rings in Blender

There are two important parts to making linked rings in Blender: Making a ring and making it repeat. The ring requires a bit of math, but it’s not hard math. Repeating requires a different bit of math, but it’s not hard either. I’ll explain the math as I go along, but you can skip it and still learn how to use ring textures.

# Drawing a circle

Remember from Cartesian geometry that a circle is all of the points that are the same distance from a given point. The distance is called the radius, and the given point the center.

The Generated output from the Texture Coordinates node encodes the X, Y, Z coordinates of a point in space. Since we’re only using a flat plane, we only care about X and Y. We can feed the Generated output into the Vector input of a Separate XYZ node and obtain those coordinates, mapped so they fit in the range of 0 to 1. If we view our plane from above, the X coordinates run along the bottom of the plane from zero on the left to 1 on the right. Because blender also uses the range of 0 to 1 for the gray scale, we can visualize this using a simple node group

Rendering this gives up the coordinates, ranging from black as 0, to 1 as white.

If we take the X and Y values from the Separate XYZ and combine them properly, we will know the distance of any point on the plane from the origin, the lower left hand corner. Recall from Cartesian geometry that the distance to a point is the square root of the sum of the square of X and the square of Y, SQRT(X^2+Y^2). We calculate this with a combination of 4 math nodes. Blender doesn’t have a node to calculate the square root, but recall that the square root is the same thing as raising the sum to the 1/2 power. (generalizing: The Nth root is the same as the 1/Nth power)

Producing

That’s an interesting blob, but we want our center at the midpoint of the plane. The formula for the distance between two points is only slightly more complicated that the one for the distance from the origin: sqrt((X1 – X0)^2 + (Y1 – Y0)^2) where (X0, Y0) is the coordinate of the center and (X1, Y1) Is the coordinate of the point. An easy adjustment:

producing

It’s a step in the right direction. Let’s turn it into a circle, using another math node, a greater than. Now the gray scale goes from black at the center to 0 at the edge, so it’s no longer a direct match for the coordinates. Let’s place the edge of the circle half way between the center and the edge. Since the center is at .5, half way between it and the edge will be half that or .25. The greater than node will return a 1 if the point is farther away and a 0 if it’s not. We can apply that to a Mix RGB node and produce a nice red circle on a blue field.

Renders

Now to make it a ring. Let’s use a less than math node along with the greater than. We’ll make anything that’s in the range between the two red and leave everything else blue. Blender doesn’t have logic nodes, but we want to know when the distance is less than the higher value and also greater than the lower value. To do this we use a minimum math node. If the distance is outside the range, one or the other of the compare nodes will return 0 and the minimum will select 0. If it’s inside the range, than both will return 1 and the minimum will select 1.

We need to make another change. For the circle, we had 0 mean outside and 1 mean inside. But for the ring we have the opposite. There are several ways to fix this. I simply switched the two colors in the mix RGB node.

and we have our red ring on our blue field

Now we can create a ring of any width. The value in the greater than provides the inner radius of the ring, while the value in the less than provides the outer radius.

# Repeating patterns

It would be nice if Blender had a tile option that would resize its input and repeat it, like the checker tile, but using the whole pattern. It doesn’t, so we fake it. Time for our last bit of math: Modulus. We’re going to repeat the pattern by repeating the coordinates, going from 0 to 1 many times. Recall that if you divide one integer by another, the remainder is called the modulus of the number being divided. For instance 22 divided by 7 returns 3, 3 times 7 returns 21 and 22 minus 21 gives 1, so the modulus of 22 with respect to 7 is 1. The modulus “wraps around” every time the number is divisible by 7, so it will be a repeating pattern from 0 to 6. The function that calculates the modulus is modulo and blender has a module function.

Since Blender coordinates go from 0 to 1, the Blender modulo function is a bit funky. Without going into the details, what we need to know is that the modulo operator takes an argument such that the pattern from 0 to 1 is repeated a certain number of times that depend on the value of the modulo’s second argument. If modulo were .5, the pattern would be reproduced twice. If it were .25, it would be reproduced 4 times. The number of patterns across is 1 divided by the second argument. Here’s an example with modulus set to .25. Notice that the value node contains the number of repetitions we want. The divide node converts it to the value expected by modulo.

as expected, gives

This is good, but it’s not quiet what we want. (Why it’s not is left as an exercise for the curious.) It repeats the pattern 0..1 4 times, but what we really want the pattern 0..1..0 Let’s add a color ramp with white at both ends and black in the middle

Unfortunately, we get symmetry but it doesn’t go 0..1..0. (The math for this is left as an exercise for the curious.) Without going into details, I will replace the modulus operator with a group of math nodes that give us useful values to work with.

giving what we want

# Putting it all together

There are only two more things to do: have the repeating pattern be the rings, and then do it again, offset, to make the links. Putting it together is easy:

renders as

The next step requires duplicating all those nodes and adding two more. This is a good time to turn some of the repetition into node groups. Calculating the ring become two node groups, distance and in range

and symmetric modulus becomes another

Put it all together and duplicate it we get our final material

We’ve added a mapping node to the second copy, using its parameters to move the X and Y coordinates slightly, resulting in the image we started with.

# Extra credit: One last node group.

Suppose we wanted to reuse the repeated ring pattern in other contexts. We can easily create a node group that does that, if we have our own version of the mapping node. I won’t go into the custom mapping node, but having it handy, we create a new node group that produced the repeating rings pattern

In our example, we want the rings to be the same size, so we use a few value parameters to insure this and our final material is the very simple

# Appendix: The custom mapping node group

This is not a precise duplicate of the mapping node, but it often serves when we would like to control the mapping node. It duplicates the group behavior of applying the translation first, the rotation second, and the scaling last. It could be made simpler by using vector math for the translation and scaling. This version was written for clarity.