# 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

A simple node group that will display the X coordinate as a gray scale running from black on the left to white on the right.

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

A gray scale representation of the X coordinates ranging from black as 0 to white as 1

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)

A node group that calculates the distance from the origin at the lower left hand corner to each point on the plane

Producing

A gray scale showing the distance from the origin to each point on the plane

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:

A gray scale showing the distance each point is from the center of the plane, rather than the origin.

producing

gray scale showing distance of a point from the center of the plane

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.

Using a greater than node to divide the plane to inside the circle and outside the circle.

Renders

A red circle on a blue field.

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.

A ring ring on a blue field

and we have our red ring on our blue field

A ring ring on a 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.

Repeating coordinates 4 times

as expected, gives

Repeating coordinates 4 times

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

Trying to make the repetition symmetric

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.

A symmetric modulus

giving what we want

A symmetric modulus

# 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:

Node group that puts the ring drawing pattern together with the pattern replication node to produce repeating rings.

renders as

Render that puts the ring drawing pattern together with the pattern replication node to produce repeating rings.

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

calculate the distance from the origin

return 1 if x lies between the lower and upper bound, 0 otherwise.

and symmetric modulus becomes another

Generate a symmetric modulus

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

Blender Cycles Material that will generate linked rings on a plane.

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

Repeating Rings Node Group

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

Having created node groups, our material is simplified down to 7 nodes, although we add 3 value nodes to make it clear that we meant the rings to be the same size

# 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.

Vector mapping is translation, rotation, and scaling, in that order

Vector translate is simply adding constants to each of X, Y and Z

When applying rotation, the order matters. The mapping node rotates around X, then around Y, finally around Z.

Vector scale is similar to vector translate. It multiplies X, Y and Z by a constant value.

Rotating around an axis works the same way for each axis, so we use a single node group. It makes Vector Rotate XYZ a little hard to follow, but it works.

Blender does trig using radians, so we apply the conversion factor.

# Introduction

This texture was a contest entry in the Facebook page “Blender Procedural Textures”

The Facebook “Blender Procedural Textures” page runs a weekly contest to use procedural textures to match a specific texture, usually from a photograph. This image is similar to my entry for one of the contests. Most of the texture will be familiar to you if you create your own bump pattern and cracks, that are made with common techniques for doing so. The method for creating the layers may not be: it is not the typical approach.

This is a step by step explanation of the approach taken. If you understand what each of the individual nodes do, you will have no trouble following it. The examples were created using Blender 2.79b. Most of the approach should apply to any release with cycles. The displacement will not, but a bump map may be substituted.

# Analyzing the texture

This texture can be described as having these parts

1. The displacement of the underlying wall
2. Obviously, the paint layers
3. soft wear, in the forms of speckles and dots
4. scratches

Normally this could be accomplished using the techniques described in BlenderInsight, Joakim Tornhill’s excellent manual Procedural Wear from A to Z in Blender. The manual can be found in the files section of the Facebook procedural textures page.

A close inspection of the original photograph, (which I do not have permission to post) shows that there is different kinds of wear in each of the segments, possibly because a different pigment was used for each and wore differently.

# How to create regions and use them to select between textures

The simplest approach is to create a color ramp and use it to select the colors. Use a gradient texture for the color ramp fac and get something like

Gradient bands with linear color ramp

There are two obvious problems: the bands are vertical instead of horizontal, and they blend. The first is easy to solve: rotate the plane. The second is also easy: switch the color ramp from linear to constant

Rotating the plane is left as an exercise for the reader. The edges are too straight, so add some noise.

Use the multiply to control the strength of the noise texture. Use the color ramp to set the color, number, order and width of bands. This will do for most purposes, but it is very difficult to use it to put a different texture in the blue region than in the green. Is there another way?

Yes.  One way is with math.  It’s easy math, so take a calming breath and follow along. Start by thinking about how to mix two colors, so that one or the other is chosen, but not both. We can do this simply using a greater than node. We can easily split the plane in half this way

This image is produced by this simple node group.

The gradient texture produces a number between 0 and 1. Greater than compares that value to its other value, in this case .5. If the upper value, from the gradient, is greater than the lower value, greater than returns 1, otherwise 0. When the mix input factor is 0, only the top color is used, otherwise the bottom color. You change the width of the region by changing the value being compared to.

This image is produced by this node group

We can continue to add as many bands as we want.

There is one more feature of the banding to model: the bands slope downward from left to right. One way to do this is through the use of texture coordinates. Replace the gradient texture with a texture coordinates node’s generated coordinates and get

This is not precisely what we want.

This node group will give us exactly the same results as the gradient texture, but for a different reason. Any point on the plane can be described by two numbers, the distance along the bottom, X and the distance along the side, Y. X varies from 0, on the left, to 1, on the right. Y from 0 on the bottom to 1 on the top.

Add the slant by combining X and Y.  We could simply add them, but we only want X to have a small effect, so multiply it by a small number.

This looks good, three bands, slanted in the right direction. Add a little noise and you have what you want.  (Notice that I also rotated the bands).

The texture coordinate provides the position of a point.  The y value is used to select the band edges. As x gets larger going from left to right, it is added to y, giving the slant.

Let’s add a texture that applies only to the blue band, just a simple Voronoi to demonstrate.

This is straightforward. Replace the color in the color mix with the mixed texture. Now let’s add a texture that crosses all the bands.  This is ugly, but it shows the effect.

Add the noise on the borders back in and the result looks like this

and is produced by this

The overlay texture is mixed with the output of the band mixture and provides the color to the diffuse node.

# Glass in Blender

This discussion covers Blender 2.79. I assume you are comfortable with the user interface, know how to model, and have some understanding of the node editor and creating materials in Blender using cycles.

# Background

I posted a render of a flashlight to a Facebook group. The most challenging feedback was that the glass looked wrong. I have tried to improve my glass material, but I’m lost. Here is my story.

I made a photograph of a fountain glass in front of a window, sitting on lazy Susan, lit from the side by a 10000 lux full spectrum lamp, at night. Because I took the photo, I know the camera sensor, focal length, focal point, and exposure time.

Simple photo of a Coke glass

I then made correct scale models of the lamp, the window, the glass and the lazy susan, placing each in the positions they occupy in the photograph.

A scale model of the scene photographed above

Next, I positioned a blender camera in the same position as the real camera.

The view that will be rendered in blender

The camera view, with the models in wireframe

The objects are precisely modeled, even the thickness of the glass is accurate. Notice that the light is out of the field of view, but is reflected in the window.

I added the coke label, a dark wood texture to the table and a light wood texture to the lazy susan. Wood textures are from Poliigon. I selected wood colors that matched the objects, but didn’t model the several varieties of wood that make up the lazy susan.

I did not add dirt on the lazy susan or smears on the glass. I planned to get the materials and lighting right and then add those. This is where I hit snags. I rendered the scene using a studio lighting set up #16 HDRI from the Zbgy studio lighting pack.

First render of the scene using a studio lighting HDRI and a basic glass shader.

(Render details: I left the camera at the default 35mm setting, since this matched the image closely enough.  I set a focal point at the bottom center of the glass and an Aperture of f1.8. I enabled Filmic color management with default settings, and denoiser with default settings. The resolution is 768 x 1024 @ 100%. For the test render, clamping was set to 1 for both direct and indirect. I used 512 samples.)

# The first problem: lighting

I disabled world lighting and enabled an area lamp. The lamp was set to a blackbody temperature of 5500K and sized to match the light source of 23cm x 10cm diffuser. I calculated the strength by converting lux to wt/m^2 and setting the strength. The image was far too dark.  So I tuned the strength using the lazy susan as a guide. The light is somewhat brighter than in the photograph. In short, the scene lighting does not precisely match the real world.

The model rendered using the same lighting as the original scene

There are a few modelling discrepancies. The focal length isn’t precisely right, so the perspective distortion of the bottom of the glasses don’t match. The model glass has a thinner base than the original. There is only one Coke logo on the class and it is a slightly different size and position than in the original. The position of the lamp doesn’t seem to precisely match. It is not reflected in the window, nor is it reflected in the same place on the glass. [Note: I fixed some of this before doing the final render. It is left as a reader to determine which parts.]

# Modeling Glass in Blender

Taking these into account, we arrive at the second issue, the crux of this post: The glass shader.  How can we improve it?

There are many things that the basic glass shader doesn’t do and there are many kinds of glass. I had collected three different glass shaders from various sources and rendered the scene with exactly the same setup, but with each of the glass shaders. As you can see, each shader is focused on particular aspects of glass and the renders are different from each other and from the basic glass shader.

The basic render using a glass material that Mike Hicks published on Facebook

The scene rendered using the Principled Glass Advanced from Alexander Bräunig

There are two approaches to attempting photo realistic glass in Blender. The first augments the glass shader to add features it is missing, or replaces the glass with a refractive shader.. A wide range of tutorials on this can be found by a Google search.

The second is to fake it. An excellent discussion of this approach can be found in Alexandrov’s Create Realistic Ice and Seriously Awesome Refraction. If you would like to explore this approach I recommend subscribing to Gleb Alexandrov on youtube and perhaps visiting his site Creative Shrimp.

# Augmenting the basic glass shader.

## How light interacts with a surface

I’ll keep the physics to a minimum, but there are certain terms that are useful. Here is the obligatory diagram

Physics 101 light on glass

When light strikes a surface, it is split into up to four parts. It can be

• absorbed: Any surface will absorb light. Absorption creates the color of a surface because not all colors of light are absorbed the same amount.
• reflected: Some part of the light will be reflected from the object. When we see a surface, we are seeing the light that is reflected by it.
• scattered: The rougher the object, the more light will be scattered
• transmitted: If the object is transparent, some percentage of the light will pass through it. The light will bend as it enters the object and bend again as it leaves the object. The parameter that describes this is the Index of Refraction, IOR for short.

There is a problem with Blender’s model of light that makes modeling some aspects of light impossible. Blender’s nodes that use the IOR do not take into account that different wavelengths of light will have different IOR values at the same interface. This is called dispersion and is why you can’t model a prism creating a spectrum in Blender.

# How blender models this behavior.

Blender introduced the principled shader in 2.79. Much of what I discuss next can now be modeled by a single principled shader. I am going to use the older method because I think the separate nodes make it easier to understand what is going on. I’m also going to ignore texture for now.

Blender divides reflection and scattering into two shaders. The diffuse shader models the scattering effect while the glossy shader models the reflection effect. Andrew Price of Blender Guru likes to describe materials as metal or non-metal, which he calls dielectric. Metals are perfectly reflective while dielectric materials are not. But even metals can be rough so Blender provides a mix shader so that you can model a material with both properties.

Before the principled shader, most materials started from this node configuration

Absorption is handled by the value of the color. The material absorbs all light, except for light of the specified color. It absorbs some of the specified color as well. A light color will reflect more of the light than a dark color of the same hue.

This model doesn’t handle transmission, however. For transparent material, we can switch to the glass shader. The 2.79 Blender manual says

The GlassBSDF node is used to add a Glass-like shader mixing refraction and reflection at grazing angles.

With caustics disabled, glass will miss shadows, and with filter glossy they might be too soft. We can make a glass shader that will use a Glass BSDF when viewed directly, and a Transparent BSDF when viewed indirectly.

and provides the glass shader most often shown in tutorials

The glass material recommended in the Blender 2.79 manual

The glass shader handles reflection and refraction but will generate caustics. The thing to know about caustics is that Blender cycles renderer does a poor job with them and people often disable them in the render properties to avoid the noise they add to a scene.

The problem is that disabling caustics means that the glass won’t pass shadows from other objects. The transparent shader compensates for this.

The trick is how the glass and transparent shaders are mixed. In reality they aren’t. Either one or the other is selected by the nodes driving the Fac input of the mix shader. The math node, set to maximum will return either a 0 or a 1 depending on the output from the light path. When the fac is 0, the glass shader is used exclusively. when it is 1, the transparent shader is.

The manual has this to say about the light path node

Ray types can be divided into four categories:

1. Camera: the ray comes straight from the camera.
2. Reflection: the ray is generated by a reflection off a surface.
3. Transmission: the ray is generated by a transmission through a surface.

Reflection and transmission rays can further have these properties:

• Diffuse: the ray is generated by a diffuse reflection or transmission (translucency).
• Glossy: the ray is generated by a glossy specular reflection or transmission.
• Singular: the ray is generated by a perfectly sharp reflection or transmission.

The Light Path node can be used to find out the type of ray the shading is being computed for.

The material does this:
If the light is either a shadow ray or a diffuse reflection ray, then use the transparent shader, otherwise use the glass shader.

Oddly enough, disabling caustics and using this material makes the render less photo realistic in some ways. Making shadow rays transparent causes the render to lose the shadows created by the glass itself.

Using the glass material recommended in the Blender manual

## A different way?

The glass shader has is suitable for many situation, but it doesn’t provide the controls needed for all cases. There is another approach to modeling glass materials. An alternative approach adopted by a lot of shaders is to mix a glossy node and a refractive node, using the Fresnel effect to control the mix

The basis of a family of shaders that do not use the glass and transparency shader as a basis.

A render using the basic refraction/diffuse mix

There are many ways to adapt the basic shader. For example, Mike Hicks and Alexander Bräunig use the glass shader instead of the refractive shader. The penfinity shader avoids the Fresnel node and instead uses the Layer weight node, mixing Fresnel and Facing outputs. The variation I chose for the render is from Stephen Woods. It mixes the Fresnel and Facing output, but used two copies of the Layer Weight node, allowing the blend to be set separately for both, making it more suitable for my final render.

A simple glass shader from Stephen Woods on the Facebook Blender Nodes group.

The last render of the series, using Stephen Woods’ simple glass node

## But wait, there’s more.

There are two pieces of glass in the scene, the window and the drinking glass. While they appear to both be made from the same kind of glass, it turns out that different aspects of glass are important in each, so I used two different glass materials.

Rendering glass requires close attention to color management, sampling, and light path parameters.  While these are outside the scope of this post, I will mention in passing that glass scenes tend to be noisy and require high sample counts to render well. All of the images in this post were rendered using 512 samples, except the last. At 4096 samples, it still has some noise.

What clamping you do, if any, especially direct clamping, has a major impact.

The number of bounces may have to be increased, since light passing through or reflecting from glass may affect how other objects look.

Blender Cycles is not very good at caustics, but they may be necessary. Carefully decide whether to enable them or not.

## Conclusion

There is more than one way to model glass in Blender. You have to work around the shortcoming of the glass node if you use it.  If you have multiple glass objects in a scene you may need different glass materials for each, even if they all seem to be made from the same glass.

It is not possible to model photorealistic glass in Blender, but using a range of techniques will allow you to approximate it in a way that is appropriate to your scene.

# Update

In response to comments on Facebook, I changed the model to more accurately represent the way typical glasses are constructed and redid the render with Wood’s glass. I also rendered the model using the principled glass shader, for completeness.

This model is more typical for fountain glasses.

Exactly the same setup as the Woods glass version, with the principled shader dropped in as a replacement for the Woods shader