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 57 of file PerlinNoise.cpp.

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

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

References p.

Member Function Documentation

◆ fade()

float PerlinNoise::fade ( float  t) const
private

Definition at line 170 of file PerlinNoise.cpp.

171 {
172  return t * t * t * ( t * ( t * 6.0f - 15.0f ) + 10.0f );
173 }

Referenced by noise().

◆ grad() [1/2]

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

Definition at line 182 of file PerlinNoise.cpp.

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

Referenced by noise().

◆ grad() [2/2]

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

Definition at line 194 of file PerlinNoise.cpp.

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

◆ lerp()

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

Definition at line 176 of file PerlinNoise.cpp.

177 {
178  return a + t * ( b - a );
179 }

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(
129  w,
130  lerp( v, lerp( u, grad( p[AA], x, y, z ), grad( p[BA], x - 1, y, z ) ),
131  lerp( u, grad( p[AB], x, y - 1, z ), grad( p[BB], x - 1, y - 1, z ) ) ),
132  lerp( v, lerp( u, grad( p[AA + 1], x, y, z - 1 ), grad( p[BA + 1], x - 1, y, z - 1 ) ),
133  lerp( u, grad( p[AB + 1], x, y - 1, z - 1 ),
134  grad( p[BB + 1], x - 1, y - 1, z - 1 ) ) ) );
135 
136  return (res + 1.0f) / 2.0f;
137 }
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 140 of file PerlinNoise.cpp.

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