How do I create repeating patterns with cycles' procedural textures

Question

Most people's question in this area is how to reduce repeating patterns, however I want to create them.

I'm creating 2d rendered tiles for my game, and I want to create procedural materials for my tiles that will seamlessly match. For that I need the cycles procedural textures to repeat on a predictable interval.

I've looked at similar threads, and they only deal with simple gradients, or images, not things like voronoi, musgrave, noise.
I haven't been able to figure out how to scale/manupilate with math, the procedural nodes to any degree of repetition.

Answer 1

You can use the math Modulo node on mapping vectors to create tilling for procedural textures:

To tile them seamlessly you need to flip tiles in X and Y axis:

For the Tilling X and Y nodes use values between 0 and 1. And to tile them in 3D just copy the setup into Z channel.

---

Why Mapping node does not add tilling to procedural textures:

Mapping node does adjust tilling for Image textures. This is because image has finite dimensions and repeats itself - the tilling is already "build-in". The Mapping node only zooms, translates and rotates this tilled image.

Since procedural textures are infinite, they have no borders and are not tilled. The Mapping node will just transform them but not tile them.

---

How and why the math nodes work:

Texture mapping does transform texture space to object space - you can visualize it like this:

This is for Generated mapping, other types will be mapped differently. Generated mapping will map the <0,1> interval to object bounding box. Therefore it stretches with scaling the mesh, but it does not rotate with mesh rotating (edit mode). It does rotate with object since generated mapping will be always aligned with object's local coords. To bind the texture to mesh UV mapping must be chosen and mesh unwrapped to tangent space.

When we split the mapping vectors into XYZ channels, we get access to each axis and can manipulate it:

Lets focus only on single channel (all apply the same principles). Now we output what we get (in the marked rectangle). This can be visualized with a graph function:

What we need for tilling though is this graph:

This is a graph of a modulo function (precisely modulo 0.33..) and will create 3 tiles on each axis. It is mapping the output to the same input locations repeatedly.

To have it tile seamlessly and flip every odd tile lower the graph of half the curve height and make the values absolute:

You get double the tiles naturally.

---

There are many effects you can do with this:

Texture pixelation with rounding node: How to pixelate a texture in Cycles?

Image blurring with noising the vectors: Motion blur on texture

Staggered mapping with rounding and offsetting: Staggered Texture Mapping

Etc..

Answer 2

Jerryno answer is great but there is another way to achieve that with some simple trigonometry.

1) Use Cosine operation on coordinates multiplied by Pi (just type "pi" in node value slider). This will create sine wave that wraps on integer values.

2) Then use Arccosine operation to create Saw-like wave from it.

3) Complete setup. Quite simple as you see.

Bonus thing- Use Z value in Combine XYZ node as time input to modify your texture!

Answer 3

SleepyMolecule’s answer shows a way to get a seamlessly repeating pattern without mirroring, but unfortunately it uses OSL, and therefore can’t be used for Cycles GPU rendering. But Blender 2.81 added a 4D option to the Noise Texture node, so the same idea can now be used without recourse to OSL, and the resulting node setup can be used for both CPU and GPU Cycles rendering (and also for Eevee).

Here’s an example of a shader node setup for this, applied to a horizontal plane.

(The number in the Scale node is 2π, which can be entered as 2*pi. This scaling changes the repeat distance from 2π to 1. The Hue Saturation Value is inserted just to give better coloration, so that the pattern is clearer.)

The above uses a Noise Texture node, but a Musgrave Texture or Voronoi Texture node can be used instead, as they also now have 4D options. (But the Voronoi Texture exhibits mirroring in some modes. I don’t know why.)

Answer 4

To wrap a 2d texture seamlessly the 2d coordinates need to become circular in higher dimensional space. Think of it like painting a torus and then cutting it open and folding it flat, only without the distortion.

Fortunately the OSL noise functions support more than 3 dimensions.

By taking the X and Y components and remapping them we can sample 4D noise in to a 2D loop

shader noise(
 point Point = P,
    float Wrap = 1,
    float Scale = 1,
 output color Perlin2d = 0.8,
    )
{
    vector mx =0;
    vector my =0;

    point map(float c)
    {
        point z = 0;
        c = c / Wrap;
        z[0] = sin(c * M_2PI)*Scale;
        z[1] = cos(c * M_2PI)*Scale;
        return z;
    }

    color res2d(point _p)
    {
        point z1 = map( _p[0] );
        point z2 = map( _p[1] );
        z1[2] = z2[0];
        float z3 = z2[1];
        return noise("perlin", z1, z3);
    }

    Perlin2d = res2d(Point);

}

With the wrap and scale values we can change the area it covers and the detail of the texture. You may change the 'seed' by adding to the final coordinates (just before the noise function) effectively sliding the object through 4D space.

Answer 5

Also tossing in a couple absolute nodes will do the mirrored tile trick, but sorry don't know of a solution for non-mirrored tiles besides photoshopping out the seams yourself.