KiCad PCB EDA Suite
PerlinNoise Class Reference

#include <PerlinNoise.h>

Public Member Functions

 PerlinNoise ()
 Initialize with the reference values for the permutation vector. More...
 
 PerlinNoise (unsigned int seed)
 Generate a new permutation vector based on the value of seed. More...
 
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 ( )

Initialize with the reference values for the permutation vector.

Definition at line 55 of file PerlinNoise.cpp.

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

References p.

◆ PerlinNoise() [2/2]

PerlinNoise::PerlinNoise ( unsigned int  seed)

Generate a new permutation vector based on the value of seed.

Definition at line 80 of file PerlinNoise.cpp.

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

References p.

Member Function Documentation

◆ fade()

float PerlinNoise::fade ( float  t) const
private

Definition at line 168 of file PerlinNoise.cpp.

169 {
170  return t * t * t * ( t * ( t * 6.0f - 15.0f ) + 10.0f );
171 }

Referenced by noise().

◆ grad() [1/2]

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

Definition at line 180 of file PerlinNoise.cpp.

181 {
182  const int h = hash & 15;
183 
184  // Convert lower 4 bits of hash inot 12 gradient directions
185  const float u = h < 8 ? x : y;
186  const float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
187 
188  return ( ( h & 1 ) == 0 ? u : -u ) + ( ( h & 2 ) == 0 ? v : -v );
189 }

Referenced by noise().

◆ grad() [2/2]

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

Definition at line 192 of file PerlinNoise.cpp.

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

◆ lerp()

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

Definition at line 174 of file PerlinNoise.cpp.

175 {
176  return a + t * ( b - a );
177 }

Referenced by noise().

◆ noise() [1/2]

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

Definition at line 100 of file PerlinNoise.cpp.

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

Referenced by BOARD_NORMAL::Generate(), COPPER_NORMAL::Generate(), PLATED_COPPER_NORMAL::Generate(), PLASTIC_NORMAL::Generate(), PLASTIC_SHINE_NORMAL::Generate(), BRUSHED_METAL_NORMAL::Generate(), and SILK_SCREEN_NORMAL::Generate().

◆ noise() [2/2]

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

Definition at line 138 of file PerlinNoise.cpp.

139 {
140  // Find the unit cube that contains the point
141  int X = static_cast<int>( std::floor( x ) ) & 255;
142  int Y = static_cast<int>( std::floor( y ) ) & 255;
143 
144  // Find relative x, y,z of point in cube
145  x -= std::floor( x );
146  y -= std::floor( y );
147 
148  // Compute fade curves for each of x, y
149  const float u = fade( x );
150  const float v = fade( y );
151 
152  // Hash coordinates of the 8 cube corners
153  const int A = p[X] + Y;
154  const int AA = p[A] + 0;
155  const int AB = p[A + 1] + 0;
156  const int B = p[X + 1] + Y;
157  const int BA = p[B] + 0;
158  const int BB = p[B + 1] + 0;
159 
160  // Add blended results from 8 corners of cube
161  const float res = lerp( v, lerp( u, grad( p[AA], x, y ), grad( p[BA], x - 1, y ) ),
162  lerp( u, grad( p[AB], x, y - 1 ), grad( p[BB], x - 1, y - 1 ) ) );
163 
164  return ( res + 1.0f ) / 2.0f;
165 }
std::vector< int > p
Definition: PerlinNoise.h:79
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 A, B, fade(), grad(), lerp(), and p.

Member Data Documentation

◆ p

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

Definition at line 79 of file PerlinNoise.h.

Referenced by noise(), and PerlinNoise().


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