How do you generate seamless Perlin noise?

To make the noise tile, all you need is to ensure that the gradient you select for integer point (x, y) is the same as the gradient point you select for (x + j*tileFrequency, y + k*tileFrequency), where tileFrequency is the number of grid cells across your tile.

(See this answer for a bit more illustration of how this gets us seamless tiling)

Inside your Perlin noise function, you'll usually have something that looks like this:

float PerlinNoise(float x, float y) { int xFloor = Mathf.FloorToInt(x); int yFloor = Mathf.FloorToInt(y); Vector2 g1 = GetPerlinGradient(xFloor, yFloor); Vector2 g2 = GetPerlinGradient(xFloor + 1, yFloor); Vector2 g3 = GetPerlinGradient(xFloor + 1, yFloor + 1); Vector2 g4 = GetPerlinGradient(xFloor, yFloor + 1); /... 

What we need to do is wrap around those indices where we're fetching the gradients, something like this:

int Wrap(int v, int period) { if(v < 0) return (v % period) + period; return v % period; } 

(If coordinates don't go negative in your situation, you can skip the if — I suspect not handling this case is why you were seeing out of bounds errors)

This wrapping means one corner of our tile is always at zero, no matter how we've shifted our inputs. For a single octave that's fine, but if we want to stack octaves this can show visible correlations as the pattern of gradients near zero repeats. So we'll add some parameters to shift our window after wrapping, which also gives us more ways to vary up our noise tile based on an input seed. :)

float TiledPerlinNoise(float x, float y, int period, int xShift, int yShift) { int xFloor = Mathf.FloorToInt(x); int yFloor = Mathf.FloorToInt(y); int left = Wrap(xFloor, period) + xShift; int right = Wrap(xFloor + 1, period) + xShift; int bottom = Wrap(yFloor, period) + yShift; int top = Wrap(yFloor + 1, period) + yShift; Vector2 g1 = GetPerlinGradient(left, bottom); Vector2 g2 = GetPerlinGradient(right, bottom); Vector2 g3 = GetPerlinGradient(right, top); Vector2 g4 = GetPerlinGradient(left, top); // ... 

Now we can use this with a collection of octave amplitudes and frequencies to generate tiling turbulence:

float TiledTurbulence(float x, float y, Octave[] octaves) { float sum = 0f; foreach (var octave in octaves) { sum += octave.amplitude * TiledPerlinNoise( x * octave.frequency, y * octave.frequency, octave.frequency, octave.xShift, octave.yShift); } return sum; } 

Here the input x & y are in "tilespace", so 1.0 is one tile width.

Note that if your periods are always powers of two, you can use a bitmask instead of the modulo operator to do your wrapping, for a little extra efficiency. :)