地形的 Perlin 噪声生成

Question

我正在尝试实现一些在线找到的源代码来生成高度使用柏林噪声绘制地图。我已经成功地使用 Noise3 函数获取了高度图，其中第三个坐标是随机“种子”，以允许随机高度图。

我的问题是生成的地形相当沉闷 - 我想要山脉，但我想要连绵起伏的草地。我已经阅读了一些关于 Perlin Noise 的文章（主要是此处）。由于我发现源代码显然没有考虑到可读性，而且我对柏林噪声的概念掌握很弱，我无法弄清楚我需要在代码中调整什么（幅度和频率？）创建更激烈的地形。

有关使用柏林噪声、一般柏林噪声生成高度图的更多信息，甚至一些更容易理解的代码也将受到欢迎。

编辑：我了解（某种程度上）柏林噪声的工作原理，例如，关于幅度和频率，我只是想知道在我上面链接的代码中要更改哪些变量，这些变量用于这些两个方面。

Answer 1

Perlin 噪声完全由您设置的不同变量控制，即幅度、频率和持久性。八度的数量有一点变化，但变化不大。在我过去编写的代码中，我只是调整了频率和持久性的数量级，直到得到我需要的东西。如果需要的话我可以尝试找到我的旧来源。

PerlinNoise.h

#pragma once

class PerlinNoise
{
public:

  // Constructor
    PerlinNoise();
    PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

  // Get Height
    double GetHeight(double x, double y) const;

  // Get
  double Persistence() const { return persistence; }
  double Frequency()   const { return frequency;   }
  double Amplitude()   const { return amplitude;   }
  int    Octaves()     const { return octaves;     }
  int    RandomSeed()  const { return randomseed;  }

  // Set
  void Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);

  void SetPersistence(double _persistence) { persistence = _persistence; }
  void SetFrequency(  double _frequency)   { frequency = _frequency;     }
  void SetAmplitude(  double _amplitude)   { amplitude = _amplitude;     }
  void SetOctaves(    int    _octaves)     { octaves = _octaves;         }
  void SetRandomSeed( int    _randomseed)  { randomseed = _randomseed;   }

private:

    double Total(double i, double j) const;
    double GetValue(double x, double y) const;
    double Interpolate(double x, double y, double a) const;
    double Noise(int x, int y) const;

    double persistence, frequency, amplitude;
    int octaves, randomseed;
};

PerlinNoise.cpp

#include "PerlinNoise.h"

PerlinNoise::PerlinNoise()
{
  persistence = 0;
  frequency = 0;
  amplitude  = 0;
  octaves = 0;
  randomseed = 0;
}

PerlinNoise::PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
  persistence = _persistence;
  frequency = _frequency;
  amplitude  = _amplitude;
  octaves = _octaves;
  randomseed = 2 + _randomseed * _randomseed;
}

void PerlinNoise::Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
  persistence = _persistence;
  frequency = _frequency;
  amplitude  = _amplitude;
  octaves = _octaves;
  randomseed = 2 + _randomseed * _randomseed;
}

double PerlinNoise::GetHeight(double x, double y) const
{
  return amplitude * Total(x, y);
}

double PerlinNoise::Total(double i, double j) const
{
    //properties of one octave (changing each loop)
    double t = 0.0f;
    double _amplitude = 1;
    double freq = frequency;

    for(int k = 0; k < octaves; k++) 
    {
        t += GetValue(j * freq + randomseed, i * freq + randomseed) * _amplitude;
        _amplitude *= persistence;
        freq *= 2;
    }

    return t;
}

double PerlinNoise::GetValue(double x, double y) const
{
    int Xint = (int)x;
    int Yint = (int)y;
    double Xfrac = x - Xint;
    double Yfrac = y - Yint;

  //noise values
  double n01 = Noise(Xint-1, Yint-1);
  double n02 = Noise(Xint+1, Yint-1);
  double n03 = Noise(Xint-1, Yint+1);
  double n04 = Noise(Xint+1, Yint+1);
  double n05 = Noise(Xint-1, Yint);
  double n06 = Noise(Xint+1, Yint);
  double n07 = Noise(Xint, Yint-1);
  double n08 = Noise(Xint, Yint+1);
  double n09 = Noise(Xint, Yint);

  double n12 = Noise(Xint+2, Yint-1);
  double n14 = Noise(Xint+2, Yint+1);
  double n16 = Noise(Xint+2, Yint);

  double n23 = Noise(Xint-1, Yint+2);
  double n24 = Noise(Xint+1, Yint+2);
  double n28 = Noise(Xint, Yint+2);

  double n34 = Noise(Xint+2, Yint+2);

    //find the noise values of the four corners
    double x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09);  
    double x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06);  
    double x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08);  
    double x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04);  

    //interpolate between those values according to the x and y fractions
    double v1 = Interpolate(x0y0, x1y0, Xfrac); //interpolate in x direction (y)
    double v2 = Interpolate(x0y1, x1y1, Xfrac); //interpolate in x direction (y+1)
    double fin = Interpolate(v1, v2, Yfrac);  //interpolate in y direction

    return fin;
}

double PerlinNoise::Interpolate(double x, double y, double a) const
{
    double negA = 1.0 - a;
  double negASqr = negA * negA;
    double fac1 = 3.0 * (negASqr) - 2.0 * (negASqr * negA);
  double aSqr = a * a;
    double fac2 = 3.0 * aSqr - 2.0 * (aSqr * a);

    return x * fac1 + y * fac2; //add the weighted factors
}

double PerlinNoise::Noise(int x, int y) const
{
    int n = x + y * 57;
    n = (n << 13) ^ n;
  int t = (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff;
    return 1.0 - double(t) * 0.931322574615478515625e-9;/// 1073741824.0);
}

Answer 2

一位朋友刚刚将我与这个问题联系起来，我想我应该尝试澄清已接受的答案中未解决的一些问题。

Elias 的有趣且有用的文章使用“价值噪声”而不是“Perlin 噪声”。值噪声涉及随机点的曲线拟合。梯度噪声（Perlin 噪声是其中的一个主要示例）创建 0 值点的网格，并为每个点提供随机梯度。他们经常互相混淆！

http://en.wikipedia.org/wiki/Gradient_noise

其次，使用第三个值作为一粒种子很贵。如果您想要随机地形，请考虑将原点平移随机量。 3D 调用比 2D 调用昂贵得多（例如，更喜欢 getNoise2D(x + XSEED, y + YSEED) 优于 getNoise3D( x, y, ZSEED))。假设 z 值保持不变，您所做的就是使用 z 值来选择 2D 噪声的特定切片。

第三，直接函数调用将返回总体上相当平滑和滚动的值，而不是像真实地形那样崎岖不平，因为它的随机性仅限于单个频率。为了获得更崎岖的地形，一个好的技术是将在不同频率下穿过噪声空间的多个调用相加，通常设置“分形”值。

因此，例如，将噪声(x, y) + (1/2)(噪声(x*2, y*2) + (1/4)(噪声(x*4, y*4) 相加...

得到的总和可能经常超出 -1 到 1 的范围，因此在这些值有用之前您必须对结果进行标准化。保持在 [-1, 1] 范围内，例如，根据您使用的“八度音阶”数量进行渐进加权（但我不知道这是否确实是最有效的方法。）

四个八度音阶的示例： (1/15)(噪声(x, y) + (2/15)(噪声(2x, 2y) + (4/15)(噪声(4x, 4y) + (8/15)(噪声( 8x, 8y)

第四，当将结果（范围从-1到1）映射到更常用的颜色值或颜色图（0到1）时，Ken Perlin描述了两种算法。名称“smooth”，其中映射值通过简单的翻译算法进行操作：

f(x) = (x + 1) / 2

另一个名称为“turbulent”，其中映射值计算如下：

f(x) = | x |;

对于前者，结果值将在颜色范围内变化范围内，极端人口稀少。对于后者，结果值将在颜色范围或颜色图的一端“折叠”。这种折叠将在折叠点处给地形带来角脊，而不是平滑滚动。 （这假设将八度音阶总和保持在 -1 到 1 的范围内，并且如果使用自定义颜色映射，则颜色范围在映射过程中平滑进展。这些条件都不是不过，它是“必需的”，并且可以用来获得有趣的效果。）

我正在开发 SimplexNoise 可视化工具... [编辑：现在在 GitHub 上：SiVi：基于 Java 的 2D 梯度噪声可视化工具] ...作为 Java 项目。可以找到可视化工具的初稿...[编辑：我正在删除旧 java-gaming.org 站点的无效链接。该网站已迁移至 jvm.gaming.org。如果您访问 jvm-gaming，请注意，对 SiVi 的较旧引用也往往有死链接。]

关于 SimplexNoise 如何工作的精彩文章（以及 Perlin 与 Gradient 背景）：
http://staffwww.itn.liu.se/~stegu/simplexnoise/ simplexnoise.pdf

Stefan Gustavson 在这方面做得非常好！

Answer 3

振幅控制地形的高/低，频率，其流动程度，频率越低，流动性越强。

因此，如果您想要锯齿状的山地景观，则需要同时提升两者。

Answer 4

这是我不久前使用 3D Perlin Noise 在 JavaScript 中编写的表面生成示例。由于表面体素要么存在，要么不存在，我只需在计算柏林噪声立方体后应用阈值。在该示例中，所有维度的噪声概率都是相等的。当您增加朝向地面的随机值并减少朝向天空的随机值时，您可以获得更真实的景观。

http://kirox.de/test/Surface.html

必须启用 WebGL。在撰写本文时，我建议使用 Chrome 以获得最佳性能。