PerlinNoise - Tiles are repeating same noise

Unity Engine
1

Hi all.

I am generating infinite tiles and am having trouble getting the PerlinNoise (height) to be applied to the world coords.The tiles repeat the same noise over and over.

Not getting x/z offsets…

The references I have gone over:
Catlike coding
Holistic3d
Sebastian Lague

6651565--759835--terrain-sample.jpg
6651565--759835--terrain-sample.jpg1000×517 133 KB

The tiles are 50 x 50 – will always be increments of 10.
worldX & worldZ are the world coords of each tile.
noisePoints - number of vertices on one side (70 + 1)

     float[,] CreateNoiseMapV2(int noisePoints, int worldX, int worldZ)
        {
            float[,]  noiseMap     = new float[noisePoints, noisePoints];
            Vector2[] octaveOffset = new Vector2[terrainSettings.octaves];

            System.Random prng           = new System.Random(Statics.gameSeed);
            float         maxNoiseHeight = float.MinValue;
            float         minNoiseHeight = float.MaxValue;
            float         scale          = ((float) terrainSettings.perlinScale <= 0) ? 0.0001f : (float) terrainSettings.perlinScale;

            for (int i = 0; i < terrainSettings.octaves; i++)
            {
                float offsetX = prng.Next(-100000, 100000) + worldX;
                float offsetY = prng.Next(-100000, 100000) - worldZ;
                octaveOffset[i] = new Vector2(offsetX, offsetY);
            }

            for (int x = 0; x < noisePoints; x++)
            {
                for (int z = 0; z < noisePoints; z++)
                {
                    float amplitude   = 1f;
                    float frequency   = 1f;
                    float noiseHeight = 0f;

                    for (int i = 0; i < terrainSettings.octaves; i++)
                    {
                        float sampleX = (x + octaveOffset[i].x) / scale * frequency;
                        float sampleZ = (z + octaveOffset[i].y) / scale * frequency;

                        float perlinValue = Mathf.PerlinNoise(sampleX, sampleZ);
                        noiseHeight += perlinValue * amplitude;

                        amplitude *= terrainSettings.persistence;
                        frequency *= terrainSettings.lacinarity;
                    }

                    maxNoiseHeight = (noiseHeight > maxNoiseHeight) ? noiseHeight : maxNoiseHeight;
                    minNoiseHeight = (noiseHeight < minNoiseHeight) ? noiseHeight : minNoiseHeight;

                    noiseMap[x, z] = noiseHeight;
                }
            }
           
            // maxNoiseHeight -- To be used here

            return noiseMap;
        }
2

Line 29 and 30… you need to add (for each Perlin input axis) the GameObject world offset, but scaled down to the local “Perlin coords.”

You probably need something in line 14 and 15 too since they are randomly choosing the octave offsets, which are included in lines 29 and 30 above… thinking about it, you probably would need to use the same octave settings for ALL tiles you want to line up.

3

Thanks for the reply Kurt, that was enough to get me looking at it differently.

The gameSeed keeps the perlin noise consistent

System.Random prng         = new System.Random(Statics.gameSeed);

The mapCenter is the offset controller for the noise.

float offsetX = prng.Next(-100000, 100000) + mapCenter.x;
float offsetZ = prng.Next(-100000, 100000) + mapCenter.y;

After many more trials I am on the right track.

6654943--760528--terrain-sample-2.jpg

I still need to work on mX and mZ as they do not work for if I change the vertPoints.
But I can finally see the correlation so I will be able to find a solution that will work for all instances.
The * 2 will need to be a variable I have not found yet.

terrainSettings.meshConstant = 10;
terrainSettings.meshScale = 5;
vertPoints = 70;

          float meshMultiplier = terrainSettings.meshConstant * terrainSettings.meshScale;
            float mX             = meshMultiplier / vertPoints * 2 * vertPoints;
            mX *= meshMultiplier / terrainSettings.perlinScale ;
            float mZ = meshMultiplier  / vertPoints * 2 * vertPoints;
            mZ *= meshMultiplier / terrainSettings.perlinScale ;
          
            Vector2 mapCenter = new Vector2(x * mX, z * mZ);
          
            /* This calls CreateNoiseMapV2() */
            CreateHeightMap(vertPoints + 1, mapCenter);

and a I updated the method/function.

        float[,] CreateNoiseMapV2(int noisePoints, Vector2 mapCenter)
        {
            System.Random prng         = new System.Random(Statics.gameSeed);
            float[,]      noiseMap     = new float[noisePoints, noisePoints];
            Vector2[]     octaveOffset = new Vector2[terrainSettings.octaves];


            float maxNoiseHeight = float.MinValue;
            float amplitude      = 1f;
            float frequency      = 1f;
            float scale          = ((float) terrainSettings.perlinScale <= 0) ? 0.0001f : (float) terrainSettings.perlinScale;
            float width          = terrainSettings.meshConstant * terrainSettings.meshScale;
            float halved         = noisePoints / 2f;

            Debug.Log(">>>>>>>>>>>>>>>>>>>>>> " + mapCenter.ToString());

            for (int i = 0; i < terrainSettings.octaves; i++)
            {
                float offsetX = prng.Next(-100000, 100000) + mapCenter.x;
                float offsetZ = prng.Next(-100000, 100000) + mapCenter.y;
                octaveOffset[i] = new Vector2(offsetX / noisePoints, offsetZ / noisePoints);

                maxNoiseHeight += amplitude;
                amplitude *= terrainSettings.persistence;
            }

            for (int x = 0; x < noisePoints; x++)
            {
                for (int z = 0; z < noisePoints; z++)
                {
                    amplitude = 1f;
                    frequency = 1f;
                    float noiseHeight = 0f;

                    for (int i = 0; i < terrainSettings.octaves; i++)
                    {
                        float sampleX = (x - halved) / scale * frequency + octaveOffset[i].x * frequency;
                        float sampleZ = (z - halved) / scale * frequency + octaveOffset[i].y * frequency;

                        float perlinValue = Mathf.PerlinNoise(sampleX, sampleZ) * 2 - 1;

                        noiseHeight += perlinValue * amplitude;
                        amplitude *= terrainSettings.persistence;
                        frequency *= terrainSettings.lacinarity;
                    }

                    noiseMap[x, z] = noiseHeight;
                }
            }

            return noiseMap;
        }
1 Like
4

“I love it when a good procgen plan comes together.”

1 Like