blocks|key|2449490|text|振幅控制地形的高低，流动的频率，低频更流动。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2449491|所以，如果你想要一个参差不齐的山地景观，你需要两者兼而有之。|2449492|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Amplitude controls how high/low the terrain is, the frequency how flowing it is, with lower frequency being more flowing.

So if you want a jagged mountainous landscape you need to up both.

blocks|key|894094|text|Perlin噪声完全由您设置的不同变量控制，即振幅、频率和持续时间。八度的音阶变化不大，但变化不大。在我过去写的代码中，我只是按频率和持续性的数量级来玩，直到我得到了我所需要的。如果需要的话我可以去找我以前的线人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|894095|PerlinNoise.h|894096|#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;
};|code-block|syntax|javascript|894097|PerlinNoise.cpp|894098|#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+%2B+_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+%2B+_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%2B%2B)+
++++{
++++++++t+%2B=+GetValue(j+*+freq+%2B+randomseed,+i+*+freq+%2B+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%2B1,+Yint-1);
++double+n03+=+Noise(Xint-1,+Yint%2B1);
++double+n04+=+Noise(Xint%2B1,+Yint%2B1);
++double+n05+=+Noise(Xint-1,+Yint);
++double+n06+=+Noise(Xint%2B1,+Yint);
++double+n07+=+Noise(Xint,+Yint-1);
++double+n08+=+Noise(Xint,+Yint%2B1);
++double+n09+=+Noise(Xint,+Yint);

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

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

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

++++//find+the+noise+values+of+the+four+corners
++++double+x0y0+=+0.0625*(n01%2Bn02%2Bn03%2Bn04)+%2B+0.125*(n05%2Bn06%2Bn07%2Bn08)+%2B+0.25*(n09);++
++++double+x1y0+=+0.0625*(n07%2Bn12%2Bn08%2Bn14)+%2B+0.125*(n09%2Bn16%2Bn02%2Bn04)+%2B+0.25*(n06);++
++++double+x0y1+=+0.0625*(n05%2Bn06%2Bn23%2Bn24)+%2B+0.125*(n03%2Bn04%2Bn09%2Bn28)+%2B+0.25*(n08);++
++++double+x1y1+=+0.0625*(n09%2Bn16%2Bn28%2Bn34)+%2B+0.125*(n08%2Bn14%2Bn06%2Bn24)+%2B+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%2B1)
++++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+%2B+y+*+fac2;+//add+the+weighted+factors
}

double+PerlinNoise::Noise(int+x,+int+y)+const
{
++++int+n+=+x+%2B+y+*+57;
++++n+=+(n+<<+13)+%5E+n;
++int+t+=+(n+*+(n+*+n+*+15731+%2B+789221)+%2B+1376312589)+&+0x7fffffff;
++++return+1.0+-+double(t)+*+0.931322574615478515625e-9;///+1073741824.0);
}|894099|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Perlin noise is completely controlled by the different variables you set, i.e. amplitude, frequency and persistance. The amount of octaves has a little change, but not much. In code that I have written in the past I have just played around with the order of magnitude of the frequency and persistance until I have gotten what I needed. I can try to find my old source if needed.

<h2>PerlinNoise.h</h2>

<pre><code>#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;
};
</code></pre>

<h2>PerlinNoise.cpp</h2>

<pre><code>#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 &lt; 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 &lt;&lt; 13) ^ n;
 int t = (n * (n * n * 15731 + 789221) + 1376312589) &amp; 0x7fffffff;
 return 1.0 - double(t) * 0.931322574615478515625e-9;/// 1073741824.0);
}
</code></pre>

blocks|key|894155|text|一位朋友刚刚把我和这个问题联系起来，我想我应该试着澄清一些在公认的答案中没有提到的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|894156|Elias的有趣和有用的文章使用的是“值噪声”而不是"Perlin噪声“。值噪声涉及随机点的曲线拟合.梯度噪声(+Perlin噪声是其中的一个主要例子)创建了一个0-值点的格，并给每个点一个随机梯度。他们经常互相混淆！|894157|噪声|offset|length|894158|其次，使用第三个值作为种子是昂贵的。如果你想要随机地形，考虑把你的原点翻译成随机的数量。3D调用比2D调用要昂贵得多(例如，更喜欢getNoise2D(x+%2B+XSEED,+y+%2B+YSEED)而不是getNoise3D(x,+y,+ZSEED))。假设z值保持不变，您所做的就是使用z值来选择特定的2D噪声片段。|style|CODE|894159|第三，直线函数调用将返回的值是相当平滑和滚动的整体，不像真实地形那样崎岖，因为它的随机性仅限于一个频率。为了使地形更加粗糙，一种很好的方法是把在不同频率的噪声空间中进行的多次呼叫加在一起，通常设置一个“分形”值。|894160|因此，例如，求和noise(x,+y)+%2B+(1/2)(noise(x*2,+y*2)+%2B+(1/4)(noise(x*4,+y*4).|894161|结果的和可能经常超出-1到1的范围，所以在这些值有用之前，您必须对结果进行规范化。我想建议设置一个系列，保证保持在-1，1，例如，通过累进加权取决于你使用多少‘八度’。(但我不知道这是否真的是最有效的方法。)|894162|有四个八度的例子：(1/15)(noise(x,+y)+%2B+(2/15)(noise(2x,+2y)+%2B+(4/15)(noise(4x,+4y)+%2B+(8/15)(noise(8x,+8y)|894163|第四，当将结果从-1到1映射到更多地使用颜色值或颜色映射(0+~+1)的规范化时，Ken描述了两种算法。其中一个被命名为“平滑”，其中映射的值由一个简单的翻译算法操作：|894164|f(x)+=+(x+%2B+1)+/+2|code-block|syntax|javascript|894165|另一个被命名为“湍流”，其中映射的值计算如下：|894166|f(x)+=+%7C+x+%7C;|894167|对于前者，得到的值将在颜色范围内，稀疏的人口在极端范围内。对于后者，生成的值将在颜色范围或颜色地图的一端“折叠”。这种折叠将使地形角脊在褶皱点，而不是顺利滚动。(这假设是将八度和保持在-1到1之间，并且如果使用自定义颜色映射，则颜色范围在地图过程中进展顺利。但是，这些条件都不是“必需的”，而且可以用来进行有趣的效果。)|894168|我正在研制一个SimplexNoise视觉器.SiVi:一种基于Java的二维梯度噪声可视化器]+.[编辑:现在在GitHub:+GitHub.作为Java项目。可视化工具的第一稿可以找到.编辑:我正在删除一个指向java-gaming.org旧站点的死链接。该站点已迁移到jvm.gaming.org。如果您去玩jvm游戏，请注意，对SiVi的旧引用也有死链接。。|BOLD|894169|关于SimplexNoise如何工作的伟大文章(以及Perlin渐变背景)：http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf|894170|斯特凡·古斯塔夫森在这方面做得很好！|894171|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Gradient_noise|1|https://github.com/philfrei/SiVi|2|http://staffwww.itn.liu.se/%257Estegu/simplexnoise/simplexnoise.pdf^0|0|0|0|2|0|0|1T|W|2S|N|0|0|8|1N|0|0|9|2F|0|0|0|0|0|0|1B|1|1E|E|2N|2F|N|O|1|0|12|1R|2|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1R|8|@]|9|@$F|1S|G|1T|1|1U]]|A|$]]|$1|H|3|I|5|6|7|1V|8|@$F|1W|G|1X|J|K]|$F|1Y|G|1Z|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|20|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|21|8|@$F|22|G|23|J|K]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|24|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|25|8|@$F|26|G|27|J|K]]|9|@]|A|$]]|$1|T|3|U|5|6|7|28|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|29|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|2A|8|@]|9|@]|A|$]]|$1|12|3|13|5|X|7|2B|8|@]|9|@]|A|$Y|Z]]|$1|14|3|15|5|6|7|2C|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2D|8|@$F|2E|G|2F|J|18]|$F|2G|G|2H|J|18]|$F|2I|G|2J|J|18]]|9|@$F|2K|G|2L|1|2M]]|A|$]]|$1|19|3|1A|5|6|7|2N|8|@]|9|@$F|2O|G|2P|1|2Q]]|A|$]]|$1|1B|3|1C|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]]|1E|$1F|$5|1G|1H|1I|A|$1J|1K]]|1L|$5|1G|1H|1I|A|$1J|1M]]|1N|$5|1G|1H|1I|A|$1J|1O]]]]

A friend just linked me to this question, and I thought I'd try and clear up a couple things that aren't addressed in the accepted answer.
Elias' interesting and helpful article uses &quot;value noise&quot; not &quot;Perlin noise&quot;. Value noise involves curve-fitting of randomized points. Gradient noise (of which Perlin noise is a primary example) creates a lattice of 0-value points and gives each one a random gradient. They are frequently confused with one another!
<a href="http://en.wikipedia.org/wiki/Gradient_noise" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Gradient_noise</a>
Secondly, using a 3rd value as a seed is expensive. If you want random terrain, consider translating your origin a random amount instead. 3D calls are significantly more expensive than 2D calls (e.g., prefer <code>getNoise2D(x + XSEED, y + YSEED)</code> over <code>getNoise3D(x, y, ZSEED)</code>). Assuming the z value remains constant, all you are doing is using the z value to select a particular slice of 2D noise.
Thirdly, the straight function call is going to return values that are fairly smooth and rolling overall, not as craggy as real terrain, since it's randomness is limited to a single frequency. To get craggier terrain, a good technique is to sum together multiple calls that progress through the noise space at differing frequencies, usually set a &quot;fractal&quot; values.
Thus, for example, sum together <code>noise(x, y) + (1/2)(noise(x*2, y*2) + (1/4)(noise(x*4, y*4)</code>...
The resulting sum will probably often be outside the range -1 to 1, so you will have to normalize the result before the values are useful. I'd like to suggest setting up a series that is guaranteed to remain within [-1, 1], for example, by progressive weighting depending upon how many 'octaves' you use. (But I don't know if this is truly the most efficient way to do this.)
Example with four octaves: <code>(1/15)(noise(x, y) + (2/15)(noise(2x, 2y) + (4/15)(noise(4x, 4y) + (8/15)(noise(8x, 8y)</code>
Fourthly, when mapping the results, which range from -1 to 1, to the normalization more often used with color values or color maps (0 to 1), Ken Perlin described two algorithms. One was given the name &quot;smooth&quot;, where the mapped values are operated on by a simple translation algorithm:
<pre><code>f(x) = (x + 1) / 2
</code></pre>
The other was given the name &quot;turbulent&quot;, where the mapped values are computed as follows:
<pre><code>f(x) = | x |;
</code></pre>
With the former, the resulting values will range over the color range, with sparser population at the extremes. With the latter, the resulting values will &quot;fold&quot; at one end of the color range or color map. This folding will give the terrain angular ridges at the fold point, as opposed to being smoothly rolling. (This assumes that one is keeping the sum of the octaves within the range -1 to 1, and that if a custom color mapping is being used, the color ranges progress smoothly over the course of the map. Neither of these conditions is &quot;required&quot; though, and can be played with for interesting effects.)
I'm working on a SimplexNoise visualizer... [Edit: now up at GitHub: <a href="https://github.com/philfrei/SiVi" rel="nofollow noreferrer">SiVi: A Java-based 2D Gradient Noise Visualizer</a>] ... as a Java project. A first draft of the visualizer can be found ... [Edit: I am deleting a dead link to the old java-gaming.org site. The site has been migrated to jvm.gaming.org. If you go to jvm-gaming, be warned that older references to SiVi tend to have dead links, as well.]
Great article on how SimplexNoise works (and Perlin vs Gradient background):
<a href="http://staffwww.itn.liu.se/%7Estegu/simplexnoise/simplexnoise.pdf" rel="nofollow noreferrer">http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf</a>
Stefan Gustavson did a really nice job of this!

blocks|key|2449654|text|下面是我不久前在JavaScript中使用3D+Perlin噪声编写的一个曲面生成示例。由于在表面上，无论是否存在体素，我只需在计算Perlin噪声立方体之后应用一个阈值。在该示例中，所有维数的噪声概率相等。你可以得到一个更现实的景观，当你增加对地面的随机值，并减少它的天空。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2449655|http://kirox.de/test/Surface.html|offset|length|2449656|必须启用WebGL。在写这篇文章的时候，我建议使用Chrome来获得最好的性能。|2449657|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|X|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Here's an example of surface generation I wrote a while ago in JavaScript using 3D Perlin Noise. Since in a surface voxels are either present or not I simply apply a threshold after calculating the Perlin Noise cube. In the example the noise probability is equal for all dimensions. You can get a more realistic landscape when you increase the random values towards the ground and reduce it towards the sky.

<a href="http://kirox.de/test/Surface.html" rel="nofollow">http://kirox.de/test/Surface.html</a>

WebGL must be enabled. At the time of writing this I recommend to use Chrome for best performance.

I'm trying to implement some source code I found <a href="http://mrl.nyu.edu/~perlin/doc/oscar.html" rel="noreferrer">online</a> to generate a height map using Perlin Noise. I've successfully managed to get the height map using the noise3 function, with the third coordinate being a random "seed", to allow for random height maps.

My problem is that the terrain generated is rather dull - I want mountains and I'm getting rolling grassland. I've done some reading up on Perlin Noise (mostly <a href="http://freespace.virgin.net/hugo.elias/models/m_perlin.htm" rel="noreferrer">here</a>). Due to the source code I've found obviously not written with readability in mind and my weak grasp on the concept of Perlin Noise in general, I can't figure out what I need to tweak in the code (amplitude and frequency?) to create more drastic terrain.

Some more info on generating height maps using Perlin Noise, Perlin Noise in general, or even some more decipherable code would also be welcome.

EDIT: I understand (kind of) how Perlin Noise works, e.g., with respect to amplitude and frequency, I'm just wondering what variables to change in the code I linked above, which are used for these two aspects.

Perlin Noise generation for terrain

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试实现一些源代码，我发现使用Perlin噪声生成一个高度图。我已经成功地使用noise3函数获得了高度图，第三个坐标是一个随机的“种子”，以允许随机的高度映射。我的问题是，生成的地形相当单调--我想要山，我要的是起伏的草原。我已经读了一些关于Perlin噪音(主要是)的内容。由于我发现源代码的编写显然没有考虑到...

问地形的Perlin噪声产生
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问地形的Perlin噪声产生EN