如何实现可平铺的Perlin Noise地图？C#开发者技术求助

Hey there! Let's figure out how to fix that tiling issue with your Perlin Noise map. The core problem with standard Perlin is that the random gradient vectors at the map's edges don't match up—so we need to make the gradient field periodic (it repeats perfectly at your map's dimensions). Here's a step-by-step solution tailored to your existing code:

1. Make Gradients Periodic #

Instead of generating random gradients for each grid point independently, we need gradients at (xsize, y) to be identical to those at (0, y), and (x, ysize) to match (x, 0).

Key Formula for Periodic Hashing #

Replace your gradient lookup hash function with one that wraps around at your map's width/height. This ensures the same gradient is used for grid points that are on opposite edges:

// Assume you have a predefined list of gradient vectors (e.g., 8 or 16 directions)
private List<(float dx, float dy)> _gradients;
private int _xSize;
private int _ySize;
private int _seed;

private int GetPeriodicHash(int i, int j)
{
    // Wrap coordinates to map bounds to ensure periodicity
    i = i % _xSize;
    j = j % _ySize;
    
    // Fix negative mod results (C# returns negative values for negative inputs)
    if (i < 0) i += _xSize;
    if (j < 0) j += _ySize;
    
    // Seed-based hash to keep noise consistent per seed
    int hash = _seed * 196314165;
    hash ^= i * 1566083941;
    hash ^= j * 1117897853;
    
    // Return index into your gradient list
    return Math.Abs(hash) % _gradients.Count;
}

2. Modify Perlin Sampling to Use Periodic Hashes #

Update your core Perlin noise function to use this new hash. This ensures that when sampling near the right/bottom edges, the algorithm uses gradients matching the left/top edges:

private float SamplePerlin(float x, float y)
{
    int xi = (int)Math.Floor(x);
    int yi = (int)Math.Floor(y);
    float xf = x - xi;
    float yf = y - yi;
    
    // Standard Perlin fade curve: 6t⁵ -15t⁴ +10t³
    float u = xf * xf * xf * (xf * (xf * 6 - 15) + 10);
    float v = yf * yf * yf * (yf * (yf * 6 - 15) + 10);
    
    // Get periodic hashes for the four cell corners
    int h00 = GetPeriodicHash(xi, yi);
    int h10 = GetPeriodicHash(xi + 1, yi);
    int h01 = GetPeriodicHash(xi, yi + 1);
    int h11 = GetPeriodicHash(xi + 1, yi + 1);
    
    // Fetch gradient vectors
    var g00 = _gradients[h00];
    var g10 = _gradients[h10];
    var g01 = _gradients[h01];
    var g11 = _gradients[h11];
    
    // Calculate dot products
    float dot00 = g00.dx * xf + g00.dy * yf;
    float dot10 = g10.dx * (xf - 1) + g10.dy * yf;
    float dot01 = g01.dx * xf + g01.dy * (yf - 1);
    float dot11 = g11.dx * (xf - 1) + g11.dy * (yf - 1);
    
    // Bilinear interpolation with fade curves
    float xLerp = MathF.Lerp(dot00, dot10, u);
    float yLerp = MathF.Lerp(dot01, dot11, u);
    return MathF.Lerp(xLerp, yLerp, v);
}

3. Adjust Octave Handling for Tiling #

When using multiple octaves, each octave's noise must also be periodic. Ensure you wrap coordinates to the map bounds before scaling for each octave:

public float[,] GenerateTiledNoise(int xSize, int ySize, float scale, int seed, int octaves, float persistance)
{
    _xSize = xSize;
    _ySize = ySize;
    _seed = seed;
    float[,] map = new float[xSize, ySize];
    
    for (int y = 0; y < ySize; y++)
    {
        for (int x = 0; x < xSize; x++)
        {
            float noiseValue = 0;
            float amplitude = 1;
            float frequency = 1;
            
            for (int o = 0; o < octaves; o++)
            {
                // Wrap coordinates to map bounds to maintain periodicity across octaves
                float tiledX = (x % xSize) / (float)xSize * scale * frequency;
                float tiledY = (y % ySize) / (float)ySize * scale * frequency;
                
                noiseValue += SamplePerlin(tiledX, tiledY) * amplitude;
                amplitude *= persistance;
                frequency *= 2;
            }
            
            map[x, y] = noiseValue;
        }
    }
    
    // Optional: Normalize noise values to 0-1 range
    float min = map.Cast<float>().Min();
    float max = map.Cast<float>().Max();
    for (int y = 0; y < ySize; y++)
        for (int x = 0; x < xSize; x++)
            map[x, y] = (map[x, y] - min) / (max - min);
    
    return map;
}

4. Test for Seams #

To verify, generate your map and:

• Check if the first column (x=0) matches the last column (x=xSize-1)
• Stitch multiple copies of the map together visually—there should be no visible line between them

Common Mistakes to Avoid #

• Forgetting to fix negative mod results in the hash function (C# returns negative values for negative inputs)
• Skipping octave wrapping—even one non-tiled octave will create a seam
• Using gradients that aren't evenly distributed (stick to 8 or 16 standard directions for best results)

内容的提问来源于stack exchange，提问作者yente paternotte