KiCad PCB EDA Suite
PerlinNoise Class Reference

#include <PerlinNoise.h>

Public Member Functions

 PerlinNoise ()
 
 PerlinNoise (unsigned int seed)
 
float noise (float x, float y, float z) const
 
float noise (float x, float y) const
 

Private Member Functions

float fade (float t) const
 
float lerp (float t, float a, float b) const
 
float grad (int hash, float x, float y, float z) const
 
float grad (int hash, float x, float y) const
 

Private Attributes

std::vector< int > p
 

Detailed Description

Definition at line 55 of file PerlinNoise.h.

Constructor & Destructor Documentation

◆ PerlinNoise() [1/2]

PerlinNoise::PerlinNoise ( )

Definition at line 58 of file PerlinNoise.cpp.

59 {
60 
61  // Initialize the permutation vector with the reference values
62  p = {
63  151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
64  8,99,37,240,21,10,23,190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
65  35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,
66  134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
67  55,46,245,40,244,102,143,54, 65,25,63,161,1,216,80,73,209,76,132,187,208, 89,
68  18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,
69  250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
70  189,28,42,223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167,
71  43,172,9,129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,
72  97,228,251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,
73  107,49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
74  138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180 };
75 
76  // Duplicate the permutation vector
77  auto oldsize = p.size();
78  p.resize( 2 * p.size() );
79  std::copy_n( p.begin(), oldsize, p.begin() + oldsize );
80 }
std::vector< int > p
Definition: PerlinNoise.h:58

References p.

◆ PerlinNoise() [2/2]

PerlinNoise::PerlinNoise ( unsigned int  seed)

Definition at line 83 of file PerlinNoise.cpp.

84 {
85  p.resize( 256 );
86 
87  // Fill p with values from 0 to 255
88  std::iota( p.begin(), p.end(), 0 );
89 
90  // Initialize a random engine with seed
91  std::default_random_engine engine( seed );
92 
93  // Suffle using the above random engine
94  std::shuffle( p.begin(), p.end(), engine );
95 
96  // Duplicate the permutation vector
97  auto oldsize = p.size();
98  p.resize( 2 * p.size() );
99  std::copy_n( p.begin(), oldsize, p.begin() + oldsize );
100 }
std::vector< int > p
Definition: PerlinNoise.h:58

References p.

Member Function Documentation

◆ fade()

float PerlinNoise::fade ( float  t) const
private

Definition at line 183 of file PerlinNoise.cpp.

184 {
185  return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
186 }

Referenced by noise().

◆ grad() [1/2]

float PerlinNoise::grad ( int  hash,
float  x,
float  y,
float  z 
) const
private

Definition at line 195 of file PerlinNoise.cpp.

196 {
197  const int h = hash & 15;
198 
199  // Convert lower 4 bits of hash inot 12 gradient directions
200  const float u = h < 8 ? x : y;
201  const float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
202 
203  return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
204 }

Referenced by noise().

◆ grad() [2/2]

float PerlinNoise::grad ( int  hash,
float  x,
float  y 
) const
private

Definition at line 207 of file PerlinNoise.cpp.

208 {
209  const int h = hash & 15;
210 
211  // Convert lower 4 bits of hash inot 12 gradient directions
212  const float u = h < 8 ? x : y;
213  const float v = h < 4 ? y : h == 12 || h == 14 ? x : 0.0f;
214 
215  return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
216 }

◆ lerp()

float PerlinNoise::lerp ( float  t,
float  a,
float  b 
) const
private

Definition at line 189 of file PerlinNoise.cpp.

190 {
191  return a + t * (b - a);
192 }

Referenced by noise().

◆ noise() [1/2]

float PerlinNoise::noise ( float  x,
float  y,
float  z 
) const

Definition at line 102 of file PerlinNoise.cpp.

103 {
104  // Find the unit cube that contains the point
105  int X = static_cast<int>( std::floor( x ) ) & 255;
106  int Y = static_cast<int>( std::floor( y ) ) & 255;
107  int Z = static_cast<int>( std::floor( z ) ) & 255;
108 
109  // Find relative x, y,z of point in cube
110  x -= std::floor( x );
111  y -= std::floor( y );
112  z -= std::floor( z );
113 
114  // Compute fade curves for each of x, y, z
115  const float u = fade( x );
116  const float v = fade( y );
117  const float w = fade( z );
118 
119  // Hash coordinates of the 8 cube corners
120  const int A = p[X] + Y;
121  const int AA = p[A] + Z;
122  const int AB = p[A + 1] + Z;
123  const int B = p[X + 1] + Y;
124  const int BA = p[B] + Z;
125  const int BB = p[B + 1] + Z;
126 
127  // Add blended results from 8 corners of cube
128  const float res = lerp( w,
129  lerp( v,
130  lerp( u,
131  grad( p[AA], x , y, z),
132  grad( p[BA], x - 1, y, z) ),
133  lerp( u,
134  grad( p[AB], x , y - 1, z ),
135  grad( p[BB], x - 1, y - 1, z) ) ),
136  lerp( v,
137  lerp( u,
138  grad( p[AA + 1], x , y, z - 1 ),
139  grad( p[BA + 1], x - 1, y, z - 1) ),
140  lerp( u,
141  grad( p[AB + 1], x , y - 1, z - 1 ),
142  grad( p[BB + 1], x - 1, y - 1, z - 1 ) ) ) );
143 
144  return (res + 1.0f) / 2.0f;
145 }
std::vector< int > p
Definition: PerlinNoise.h:58
float grad(int hash, float x, float y, float z) const
float fade(float t) const
float lerp(float t, float a, float b) const

References fade(), grad(), lerp(), and p.

Referenced by CCOPPERNORMAL::Generate(), CPLASTICNORMAL::Generate(), CPLASTICSHINENORMAL::Generate(), and CMETALBRUSHEDNORMAL::Generate().

◆ noise() [2/2]

float PerlinNoise::noise ( float  x,
float  y 
) const

Definition at line 148 of file PerlinNoise.cpp.

149 {
150  // Find the unit cube that contains the point
151  int X = static_cast<int>( std::floor( x ) ) & 255;
152  int Y = static_cast<int>( std::floor( y ) ) & 255;
153 
154  // Find relative x, y,z of point in cube
155  x -= std::floor( x );
156  y -= std::floor( y );
157 
158  // Compute fade curves for each of x, y
159  const float u = fade( x );
160  const float v = fade( y );
161 
162  // Hash coordinates of the 8 cube corners
163  const int A = p[X] + Y;
164  const int AA = p[A] + 0;
165  const int AB = p[A + 1] + 0;
166  const int B = p[X + 1] + Y;
167  const int BA = p[B] + 0;
168  const int BB = p[B + 1] + 0;
169 
170  // Add blended results from 8 corners of cube
171  const float res = lerp( v,
172  lerp( u,
173  grad( p[AA], x , y ),
174  grad( p[BA], x - 1, y ) ),
175  lerp( u,
176  grad( p[AB], x , y - 1 ),
177  grad( p[BB], x - 1, y - 1 ) ) );
178 
179  return (res + 1.0f) / 2.0f;
180 }
std::vector< int > p
Definition: PerlinNoise.h:58
float grad(int hash, float x, float y, float z) const
float fade(float t) const
float lerp(float t, float a, float b) const

References fade(), grad(), lerp(), and p.

Member Data Documentation

◆ p

std::vector<int> PerlinNoise::p
private

Definition at line 58 of file PerlinNoise.h.

Referenced by noise(), and PerlinNoise().


The documentation for this class was generated from the following files: